mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-03 09:01:54 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
pipewire/src/modules/module-protocol-native/protocol-native.c

2278 lines
67 KiB
C
Raw Normal View History

pinos -> pipewire
2017-05-23 19:15:33 +02:00
/* PipeWire
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* Copyright © 2018 Wim Taymans
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
*/
Implement protocol extensions Add hooks that contain protocol specific interfaces that can be used to extend the protocol. This makes it possible to add new interfaces to the protocol and implement the protocol specific data transport. Move these protocol specific extension to the extensions directory.
2017-07-12 18:04:00 +02:00
#include <stdio.h>
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
#include <errno.h>
fix includes
2019-10-25 15:01:02 +02:00
#include <spa/pod/builder.h>
Don't use __ in defines or declarations, it's reserved SPA_TYPE -> SPA_TYPE_INFO for type info strings improve includes Fixes #115
2019-01-14 12:58:23 +01:00
#include <spa/pod/parser.h>
fix includes
2019-10-25 15:01:02 +02:00
#include <spa/utils/result.h>
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
move proxy implementations in their own file Rearrange headers
2019-12-11 10:57:10 +01:00
#include <pipewire/impl.h>
Don't use __ in defines or declarations, it's reserved SPA_TYPE -> SPA_TYPE_INFO for type info strings improve includes Fixes #115
2019-01-14 12:58:23 +01:00
#include <extensions/protocol-native.h>
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
#include "connection.h"
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int core_method_marshal_add_listener(void *object,
struct spa_hook *listener,
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
const struct pw_core_events *events,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
void *data)
{
struct pw_proxy *proxy = object;
clean up proxy and resource api Remove override for resources, it can't work in general. Rename method to add_object_listener to add a listener for events/methods from the remote object. Rename some methods to _call to call the interface and _notify to notify the listeners. Remove unused client event to be notified of resource implementations.
2019-05-29 10:39:24 +02:00
pw_proxy_add_object_listener(proxy, listener, events, data);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
return 0;
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int core_method_marshal_hello(void *object, uint32_t version)
rework initial connection Make a steal_fd method on the remote. Add a hello method that sends the initial core info and types to the client. With an explicit method we can do this multiple times when we steal the fd from a remote and use it to make a new remote.
2018-01-19 17:57:59 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_CORE_METHOD_HELLO, NULL);
rework initial connection Make a steal_fd method on the remote. Add a hello method that sends the initial core info and types to the client. With an explicit method we can do this multiple times when we steal the fd from a remote and use it to make a new remote.
2018-01-19 17:57:59 +01:00
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_builder_add_struct(b,
SPA_POD_Int(version));
rework initial connection Make a steal_fd method on the remote. Add a hello method that sends the initial core info and types to the client. With an explicit method we can do this multiple times when we steal the fd from a remote and use it to make a new remote.
2018-01-19 17:57:59 +01:00
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
rework initial connection Make a steal_fd method on the remote. Add a hello method that sends the initial core info and types to the client. With an explicit method we can do this multiple times when we steal the fd from a remote and use it to make a new remote.
2018-01-19 17:57:59 +01:00
}
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
static int core_method_marshal_sync(void *object, uint32_t id, int seq)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
struct pw_protocol_native_message *msg;
indent
2017-05-26 08:05:01 +02:00
struct pw_proxy *proxy = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
Rework serialization Move serialization to the protocol, we now just send blocks of bytes over the connection and let the protocol deserialize them.
2017-03-06 15:48:04 +01:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_CORE_METHOD_SYNC, &msg);
Add update_uris method and event Add a way to send mapper updates between client and server and a way to map between client and server types.
2017-03-14 20:18:31 +01:00
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_builder_add_struct(b,
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
SPA_POD_Int(id),
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
SPA_POD_Int(SPA_RESULT_RETURN_ASYNC(msg->seq)));
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static int core_method_marshal_pong(void *object, uint32_t id, int seq)
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_CORE_METHOD_PONG, NULL);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
spa_pod_builder_add_struct(b,
SPA_POD_Int(id),
SPA_POD_Int(seq));
return pw_protocol_native_end_proxy(proxy, b);
}
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
static int core_method_marshal_error(void *object, uint32_t id, int seq, int res, const char *error)
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_CORE_METHOD_ERROR, NULL);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
spa_pod_builder_add_struct(b,
SPA_POD_Int(id),
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
SPA_POD_Int(seq),
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
SPA_POD_Int(res),
SPA_POD_String(error));
return pw_protocol_native_end_proxy(proxy, b);
}
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
static struct pw_registry * core_method_marshal_get_registry(void *object,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
uint32_t version, size_t user_data_size)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
indent
2017-05-26 08:05:01 +02:00
struct pw_proxy *proxy = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct pw_proxy *res;
uint32_t new_id;
protocol: add v0 compatibility For flatpaks we need to be able to support older v0 protocol clients. To handle this we have: - the connection detects an old client when it receives the first message. It can do this by checking the sequence number, on old versions it contains the message size and is never 0, on new clients the sequence number is 0. - We add a new signal at the start of the connection with the detected version number. This installs the right version of the core proxy. We also move the binding of the client until the hello message is received. This way we can have a new client connect (portal), hand over the connection to an old client, which then removes the client binding again in the hello request with a v0 version. There are some changes to the passing of fds in v0 vs v3 which need to investigated some more. - bump version of our interfaces to 3. This makes it possible to have v0 and v3 protocol marshal functions. - Add version number in the proxy. This is mostly automatically done internally based on the version numbers the library is compiled with. Where the version number was in the API before, it is now actually used to look up the right protocol marshal functions. For Proxies there is usually just 1 version, the current one. It is the server that will support different versions. - Add v0 compat marshal functions to convert from and to v0 format. This has some complications. v0 has a type map it keeps in sync with the server. For this we have a static type map with mappings to our own v3 types. Pods are mostly the same except for objects that used to have arbitrary pods in v0 vs spa_pod_prop in v3. Also convert between v0 spa_pod_prop and v3 spa_pod_choice. Formats and commands are also slightly different so handle those mappings as well. We only have marshal functions for the server side (resource) v0 functions. - Add v0 compatible client-node again. It's a bit tricky to map, v0 client-node basically lets the server to the mixing and teeing and just does the processing of the internal node.
2019-10-08 22:52:25 +02:00
res = pw_proxy_new(object, PW_TYPE_INTERFACE_Registry, version, user_data_size);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
if (res == NULL)
return NULL;
new_id = pw_proxy_get_id(res);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_CORE_METHOD_GET_REGISTRY, NULL);
Add support for trace logging in lockfree ringbuffer Fix some crashes when the connection is dead. Small cleanups in the audio mixer Only propose alloc_buffer when we are using export_buf in v4l2
2017-04-27 17:17:47 +02:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
spa_pod_builder_add_struct(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(version),
SPA_POD_Int(new_id));
Add update_uris method and event Add a way to send mapper updates between client and server and a way to map between client and server types.
2017-03-14 20:18:31 +01:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
pw_protocol_native_end_proxy(proxy, b);
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
return (struct pw_registry *) res;
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
static inline void push_item(struct spa_pod_builder *b, const struct spa_dict_item *item)
{
const char *str;
spa_pod_builder_string(b, item->key);
str = item->value;
if (strstr(str, "pointer:") == str)
str = "";
spa_pod_builder_string(b, str);
}
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
static void push_dict(struct spa_pod_builder *b, const struct spa_dict *dict)
{
uint32_t i, n_items;
struct spa_pod_frame f;
n_items = dict ? dict->n_items : 0;
spa_pod_builder_push_struct(b, &f);
spa_pod_builder_int(b, n_items);
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
for (i = 0; i < n_items; i++)
push_item(b, &dict->items[i]);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_pop(b, &f);
}
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
static inline int parse_item(struct spa_pod_parser *prs, struct spa_dict_item *item)
{
int res;
if ((res = spa_pod_parser_get(prs,
SPA_POD_String(&item->key),
SPA_POD_String(&item->value),
NULL)) < 0)
return res;
if (strstr(item->value, "pointer:") == item->value)
item->value = "";
return 0;
}
static inline int parse_dict(struct spa_pod_parser *prs, struct spa_dict *dict)
{
uint32_t i;
int res;
for (i = 0; i < dict->n_items; i++) {
if ((res = parse_item(prs, (struct spa_dict_item *) &dict->items[i])) < 0)
return res;
}
return 0;
}
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
static void push_params(struct spa_pod_builder *b, uint32_t n_params,
const struct spa_param_info *params)
{
uint32_t i;
struct spa_pod_frame f;
spa_pod_builder_push_struct(b, &f);
spa_pod_builder_int(b, n_params);
for (i = 0; i < n_params; i++) {
spa_pod_builder_id(b, params[i].id);
spa_pod_builder_int(b, params[i].flags);
}
spa_pod_builder_pop(b, &f);
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static void *
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
core_method_marshal_create_object(void *object,
node_factory -> factory Rename the node-factory to a more generic object factory. Add type and version to create objects from a factory Start on factory introspection
2017-09-17 16:47:03 +02:00
const char *factory_name,
uint32_t type, uint32_t version,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
const struct spa_dict *props, size_t user_data_size)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
indent
2017-05-26 08:05:01 +02:00
struct pw_proxy *proxy = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct pw_proxy *res;
uint32_t new_id;
protocol: add v0 compatibility For flatpaks we need to be able to support older v0 protocol clients. To handle this we have: - the connection detects an old client when it receives the first message. It can do this by checking the sequence number, on old versions it contains the message size and is never 0, on new clients the sequence number is 0. - We add a new signal at the start of the connection with the detected version number. This installs the right version of the core proxy. We also move the binding of the client until the hello message is received. This way we can have a new client connect (portal), hand over the connection to an old client, which then removes the client binding again in the hello request with a v0 version. There are some changes to the passing of fds in v0 vs v3 which need to investigated some more. - bump version of our interfaces to 3. This makes it possible to have v0 and v3 protocol marshal functions. - Add version number in the proxy. This is mostly automatically done internally based on the version numbers the library is compiled with. Where the version number was in the API before, it is now actually used to look up the right protocol marshal functions. For Proxies there is usually just 1 version, the current one. It is the server that will support different versions. - Add v0 compat marshal functions to convert from and to v0 format. This has some complications. v0 has a type map it keeps in sync with the server. For this we have a static type map with mappings to our own v3 types. Pods are mostly the same except for objects that used to have arbitrary pods in v0 vs spa_pod_prop in v3. Also convert between v0 spa_pod_prop and v3 spa_pod_choice. Formats and commands are also slightly different so handle those mappings as well. We only have marshal functions for the server side (resource) v0 functions. - Add v0 compatible client-node again. It's a bit tricky to map, v0 client-node basically lets the server to the mixing and teeing and just does the processing of the internal node.
2019-10-08 22:52:25 +02:00
res = pw_proxy_new(object, type, version, user_data_size);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
if (res == NULL)
return NULL;
new_id = pw_proxy_get_id(res);
indent
2017-05-26 08:05:01 +02:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_CORE_METHOD_CREATE_OBJECT, NULL);
indent
2017-05-26 08:05:01 +02:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
spa_pod_builder_add(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_String(factory_name),
SPA_POD_Id(type),
SPA_POD_Int(version),
NULL);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
push_dict(b, props);
spa_pod_builder_int(b, new_id);
spa_pod_builder_pop(b, &f);
indent
2017-05-26 08:05:01 +02:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
pw_protocol_native_end_proxy(proxy, b);
return (void *)res;
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
core_method_marshal_destroy(void *object, void *p)
port: add port globals Expose all ports as globals, linking is then done by specifying the global id of the ports. Add method to destroy objects. not much security on this one but yet but it should allow priviledged clients to kill connections and other clients etc. Make events on the global object. Implement the bind with the event, handle destroy of the globals. Add link properties Use append to preserve the order.
2018-02-15 17:49:04 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
uint32_t id = pw_proxy_get_id(p);
port: add port globals Expose all ports as globals, linking is then done by specifying the global id of the ports. Add method to destroy objects. not much security on this one but yet but it should allow priviledged clients to kill connections and other clients etc. Make events on the global object. Implement the bind with the event, handle destroy of the globals. Add link properties Use append to preserve the order.
2018-02-15 17:49:04 +01:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_CORE_METHOD_DESTROY, NULL);
port: add port globals Expose all ports as globals, linking is then done by specifying the global id of the ports. Add method to destroy objects. not much security on this one but yet but it should allow priviledged clients to kill connections and other clients etc. Make events on the global object. Implement the bind with the event, handle destroy of the globals. Add link properties Use append to preserve the order.
2018-02-15 17:49:04 +01:00
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_builder_add_struct(b,
SPA_POD_Int(id));
port: add port globals Expose all ports as globals, linking is then done by specifying the global id of the ports. Add method to destroy objects. not much security on this one but yet but it should allow priviledged clients to kill connections and other clients etc. Make events on the global object. Implement the bind with the event, handle destroy of the globals. Add link properties Use append to preserve the order.
2018-02-15 17:49:04 +01:00
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
port: add port globals Expose all ports as globals, linking is then done by specifying the global id of the ports. Add method to destroy objects. not much security on this one but yet but it should allow priviledged clients to kill connections and other clients etc. Make events on the global object. Implement the bind with the event, handle destroy of the globals. Add link properties Use append to preserve the order.
2018-02-15 17:49:04 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_event_demarshal_info(void *object, const struct pw_protocol_native_message *msg)
Add update_uris method and event Add a way to send mapper updates between client and server and a way to map between client and server types.
2017-03-14 20:18:31 +01:00
{
indent
2017-05-26 08:05:01 +02:00
struct pw_proxy *proxy = object;
protocol: init spa_dict properly Or else the flags might be wrong.
2019-11-04 17:25:20 +01:00
struct spa_dict props = SPA_DICT_INIT(NULL, 0);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
indent
2017-05-26 08:05:01 +02:00
struct pw_core_info info;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
Add update_uris method and event Add a way to send mapper updates between client and server and a way to map between client and server types.
2017-03-14 20:18:31 +01:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0)
return -EINVAL;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
if (spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&info.id),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_Int(&info.cookie),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_String(&info.user_name),
SPA_POD_String(&info.host_name),
SPA_POD_String(&info.version),
SPA_POD_String(&info.name),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_Long(&info.change_mask), NULL) < 0)
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
return -EINVAL;
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0)
return -EINVAL;
if (spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&props.n_items), NULL) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
info.props = &props;
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
if (parse_dict(&prs, &props) < 0)
return -EINVAL;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_proxy_notify(proxy, struct pw_core_events, info, 0, &info);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_event_demarshal_done(void *object, const struct pw_protocol_native_message *msg)
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_parser prs;
uint32_t id, seq;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id),
SPA_POD_Int(&seq)) < 0)
return -EINVAL;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_proxy_notify(proxy, struct pw_core_events, done, 0, id, seq);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_event_demarshal_ping(void *object, const struct pw_protocol_native_message *msg)
indent
2017-05-26 08:05:01 +02:00
{
struct pw_proxy *proxy = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
uint32_t id, seq;
indent
2017-05-26 08:05:01 +02:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
SPA_POD_Int(&id),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&seq)) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_proxy_notify(proxy, struct pw_core_events, ping, 0, id, seq);
indent
2017-05-26 08:05:01 +02:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_event_demarshal_error(void *object, const struct pw_protocol_native_message *msg)
indent
2017-05-26 08:05:01 +02:00
{
struct pw_proxy *proxy = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
indent
2017-05-26 08:05:01 +02:00
uint32_t id, res;
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
int seq;
indent
2017-05-26 08:05:01 +02:00
const char *error;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id),
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
SPA_POD_Int(&seq),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&res),
SPA_POD_String(&error)) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_proxy_notify(proxy, struct pw_core_events, error, 0, id, seq, res, error);
indent
2017-05-26 08:05:01 +02:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_event_demarshal_remove_id(void *object, const struct pw_protocol_native_message *msg)
indent
2017-05-26 08:05:01 +02:00
{
struct pw_proxy *proxy = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
indent
2017-05-26 08:05:01 +02:00
uint32_t id;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs, SPA_POD_Int(&id)) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_proxy_notify(proxy, struct pw_core_events, remove_id, 0, id);
indent
2017-05-26 08:05:01 +02:00
}
interfaces: add event to notify of global bound id Make it possible to know when a proxy is bound to a global id before the global shows up in the registry. This makes it possible to match locally created objects to the one appearing in the registry and possibly avoid a second bind.
2019-11-28 11:50:17 +01:00
static int core_event_demarshal_bound_id(void *object, const struct pw_protocol_native_message *msg)
{
struct pw_proxy *proxy = object;
struct spa_pod_parser prs;
uint32_t id, global_id;
spa_pod_parser_init(&prs, msg->data, msg->size);
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id),
SPA_POD_Int(&global_id)) < 0)
return -EINVAL;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_proxy_notify(proxy, struct pw_core_events, bound_id, 0, id, global_id);
interfaces: add event to notify of global bound id Make it possible to know when a proxy is bound to a global id before the global shows up in the registry. This makes it possible to match locally created objects to the one appearing in the registry and possibly avoid a second bind.
2019-11-28 11:50:17 +01:00
}
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
static int core_event_demarshal_add_mem(void *object, const struct pw_protocol_native_message *msg)
{
struct pw_proxy *proxy = object;
struct spa_pod_parser prs;
protocol: we need to read Fd into int64_t
2019-08-20 10:50:56 +02:00
uint32_t id, type, flags;
int64_t idx;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
int fd;
spa_pod_parser_init(&prs, msg->data, msg->size);
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id),
SPA_POD_Id(&type),
protocol: use Fd pod for fd indexes for easier debugging
2019-08-16 15:11:04 +02:00
SPA_POD_Fd(&idx),
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
SPA_POD_Int(&flags)) < 0)
return -EINVAL;
fd = pw_protocol_native_get_proxy_fd(proxy, idx);
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_proxy_notify(proxy, struct pw_core_events, add_mem, 0, id, type, fd, flags);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
}
static int core_event_demarshal_remove_mem(void *object, const struct pw_protocol_native_message *msg)
{
struct pw_proxy *proxy = object;
struct spa_pod_parser prs;
uint32_t id;
spa_pod_parser_init(&prs, msg->data, msg->size);
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id)) < 0)
return -EINVAL;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_proxy_notify(proxy, struct pw_core_events, remove_mem, 0, id);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void core_event_marshal_info(void *object, const struct pw_core_info *info)
indent
2017-05-26 08:05:01 +02:00
{
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_resource *resource = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
indent
2017-05-26 08:05:01 +02:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_resource(resource, PW_CORE_EVENT_INFO, NULL);
indent
2017-05-26 08:05:01 +02:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
spa_pod_builder_add(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(info->id),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_Int(info->cookie),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_String(info->user_name),
SPA_POD_String(info->host_name),
SPA_POD_String(info->version),
SPA_POD_String(info->name),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_Long(info->change_mask),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
NULL);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
push_dict(b, info->props);
spa_pod_builder_pop(b, &f);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
Rework serialization Move serialization to the protocol, we now just send blocks of bytes over the connection and let the protocol deserialize them.
2017-03-06 15:48:04 +01:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void core_event_marshal_done(void *object, uint32_t id, int seq)
Make done event on node Replace the AsyncDone event with an explicit done callback in the node to signal completion of an async operation. Pass read and write fd together with the transport
2017-06-09 17:24:18 +02:00
{
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_resource *resource = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
Make done event on node Replace the AsyncDone event with an explicit done callback in the node to signal completion of an async operation. Pass read and write fd together with the transport
2017-06-09 17:24:18 +02:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_resource(resource, PW_CORE_EVENT_DONE, NULL);
Make done event on node Replace the AsyncDone event with an explicit done callback in the node to signal completion of an async operation. Pass read and write fd together with the transport
2017-06-09 17:24:18 +02:00
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_builder_add_struct(b,
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
SPA_POD_Int(id),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(seq));
Make done event on node Replace the AsyncDone event with an explicit done callback in the node to signal completion of an async operation. Pass read and write fd together with the transport
2017-06-09 17:24:18 +02:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
Make done event on node Replace the AsyncDone event with an explicit done callback in the node to signal completion of an async operation. Pass read and write fd together with the transport
2017-06-09 17:24:18 +02:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void core_event_marshal_ping(void *object, uint32_t id, int seq)
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_builder *b;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
struct pw_protocol_native_message *msg;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_resource(resource, PW_CORE_EVENT_PING, &msg);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
spa_pod_builder_add_struct(b,
SPA_POD_Int(id),
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
SPA_POD_Int(SPA_RESULT_RETURN_ASYNC(msg->seq)));
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void core_event_marshal_error(void *object, uint32_t id, int seq, int res, const char *error)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_resource *resource = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
Rework serialization Move serialization to the protocol, we now just send blocks of bytes over the connection and let the protocol deserialize them.
2017-03-06 15:48:04 +01:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_resource(resource, PW_CORE_EVENT_ERROR, NULL);
Add support for trace logging in lockfree ringbuffer Fix some crashes when the connection is dead. Small cleanups in the audio mixer Only propose alloc_buffer when we are using export_buf in v4l2
2017-04-27 17:17:47 +02:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
spa_pod_builder_add_struct(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(id),
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
SPA_POD_Int(seq),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(res),
resource: improve error handling Make some more varargs error functions Make pw_resource_error always just send the error to the resource id. Make sure we send errors to the right destination. Add proxy error event and emit it when the core finds an error for the given proxy id. The client error is supposed to be sent to all resources of a client for the given global.
2019-02-14 16:53:42 +01:00
SPA_POD_String(error));
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void core_event_marshal_remove_id(void *object, uint32_t id)
Rework serialization Move serialization to the protocol, we now just send blocks of bytes over the connection and let the protocol deserialize them.
2017-03-06 15:48:04 +01:00
{
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_resource *resource = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
indent
2017-05-26 08:05:01 +02:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_resource(resource, PW_CORE_EVENT_REMOVE_ID, NULL);
indent
2017-05-26 08:05:01 +02:00
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_builder_add_struct(b,
SPA_POD_Int(id));
indent
2017-05-26 08:05:01 +02:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
interfaces: add event to notify of global bound id Make it possible to know when a proxy is bound to a global id before the global shows up in the registry. This makes it possible to match locally created objects to the one appearing in the registry and possibly avoid a second bind.
2019-11-28 11:50:17 +01:00
static void core_event_marshal_bound_id(void *object, uint32_t id, uint32_t global_id)
{
struct pw_resource *resource = object;
struct spa_pod_builder *b;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_resource(resource, PW_CORE_EVENT_BOUND_ID, NULL);
interfaces: add event to notify of global bound id Make it possible to know when a proxy is bound to a global id before the global shows up in the registry. This makes it possible to match locally created objects to the one appearing in the registry and possibly avoid a second bind.
2019-11-28 11:50:17 +01:00
spa_pod_builder_add_struct(b,
SPA_POD_Int(id),
SPA_POD_Int(global_id));
pw_protocol_native_end_resource(resource, b);
}
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
static void core_event_marshal_add_mem(void *object, uint32_t id, uint32_t type, int fd, uint32_t flags)
{
struct pw_resource *resource = object;
struct spa_pod_builder *b;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_resource(resource, PW_CORE_EVENT_ADD_MEM, NULL);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
spa_pod_builder_add_struct(b,
SPA_POD_Int(id),
SPA_POD_Id(type),
protocol: use Fd pod for fd indexes for easier debugging
2019-08-16 15:11:04 +02:00
SPA_POD_Fd(pw_protocol_native_add_resource_fd(resource, fd)),
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
SPA_POD_Int(flags));
pw_protocol_native_end_resource(resource, b);
}
static void core_event_marshal_remove_mem(void *object, uint32_t id)
{
struct pw_resource *resource = object;
struct spa_pod_builder *b;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
b = pw_protocol_native_begin_resource(resource, PW_CORE_EVENT_REMOVE_MEM, NULL);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
spa_pod_builder_add_struct(b,
SPA_POD_Int(id));
pw_protocol_native_end_resource(resource, b);
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_method_demarshal_hello(void *object, const struct pw_protocol_native_message *msg)
rework initial connection Make a steal_fd method on the remote. Add a hello method that sends the initial core info and types to the client. With an explicit method we can do this multiple times when we steal the fd from a remote and use it to make a new remote.
2018-01-19 17:57:59 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
Add version to hello
2018-10-27 17:19:50 +01:00
uint32_t version;
rework initial connection Make a steal_fd method on the remote. Add a hello method that sends the initial core info and types to the client. With an explicit method we can do this multiple times when we steal the fd from a remote and use it to make a new remote.
2018-01-19 17:57:59 +01:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&version)) < 0)
rework initial connection Make a steal_fd method on the remote. Add a hello method that sends the initial core info and types to the client. With an explicit method we can do this multiple times when we steal the fd from a remote and use it to make a new remote.
2018-01-19 17:57:59 +01:00
return -EINVAL;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_resource_notify(resource, struct pw_core_methods, hello, 0, version);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_method_demarshal_sync(void *object, const struct pw_protocol_native_message *msg)
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
uint32_t id, seq;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id),
SPA_POD_Int(&seq)) < 0)
return -EINVAL;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_resource_notify(resource, struct pw_core_methods, sync, 0, id, seq);
rework initial connection Make a steal_fd method on the remote. Add a hello method that sends the initial core info and types to the client. With an explicit method we can do this multiple times when we steal the fd from a remote and use it to make a new remote.
2018-01-19 17:57:59 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_method_demarshal_pong(void *object, const struct pw_protocol_native_message *msg)
Add doxygen docs
2017-05-30 19:46:51 +02:00
{
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_resource *resource = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
uint32_t id, seq;
Add doxygen docs
2017-05-30 19:46:51 +02:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
SPA_POD_Int(&id),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&seq)) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
Add doxygen docs
2017-05-30 19:46:51 +02:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_resource_notify(resource, struct pw_core_methods, pong, 0, id, seq);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_method_demarshal_error(void *object, const struct pw_protocol_native_message *msg)
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
uint32_t id, res;
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
int seq;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
const char *error;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id),
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
SPA_POD_Int(&seq),
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
SPA_POD_Int(&res),
SPA_POD_String(&error)) < 0)
return -EINVAL;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_resource_notify(resource, struct pw_core_methods, error, 0, id, seq, res, error);
Add doxygen docs
2017-05-30 19:46:51 +02:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_method_demarshal_get_registry(void *object, const struct pw_protocol_native_message *msg)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_resource *resource = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
Add version to more methods
2017-07-11 19:50:26 +02:00
int32_t version, new_id;
indent
2017-05-26 08:05:01 +02:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&version),
SPA_POD_Int(&new_id)) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_resource_notify(resource, struct pw_core_methods, get_registry, 0, version, new_id);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_method_demarshal_create_object(void *object, const struct pw_protocol_native_message *msg)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_resource *resource = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
uint32_t version, type, new_id;
node_factory -> factory Rename the node-factory to a more generic object factory. Add type and version to create objects from a factory Start on factory introspection
2017-09-17 16:47:03 +02:00
const char *factory_name;
protocol: init spa_dict properly Or else the flags might be wrong.
2019-11-04 17:25:20 +01:00
struct spa_dict props = SPA_DICT_INIT(NULL, 0);
indent
2017-05-26 08:05:01 +02:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_String(&factory_name),
SPA_POD_Id(&type),
SPA_POD_Int(&version),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
NULL) < 0)
return -EINVAL;
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&props.n_items), NULL) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
if (parse_dict(&prs, &props) < 0)
return -EINVAL;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_parser_pop(&prs, &f[1]);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get(&prs,
SPA_POD_Int(&new_id), NULL) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_resource_notify(resource, struct pw_core_methods, create_object, 0, factory_name,
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
type, version,
&props, new_id);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int core_method_demarshal_destroy(void *object, const struct pw_protocol_native_message *msg)
port: add port globals Expose all ports as globals, linking is then done by specifying the global id of the ports. Add method to destroy objects. not much security on this one but yet but it should allow priviledged clients to kill connections and other clients etc. Make events on the global object. Implement the bind with the event, handle destroy of the globals. Add link properties Use append to preserve the order.
2018-02-15 17:49:04 +01:00
{
struct pw_resource *resource = object;
pw_client -> pw_impl_client
2019-12-11 11:21:43 +01:00
struct pw_impl_client *client = pw_resource_get_client(resource);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct pw_resource *r;
port: add port globals Expose all ports as globals, linking is then done by specifying the global id of the ports. Add method to destroy objects. not much security on this one but yet but it should allow priviledged clients to kill connections and other clients etc. Make events on the global object. Implement the bind with the event, handle destroy of the globals. Add link properties Use append to preserve the order.
2018-02-15 17:49:04 +01:00
struct spa_pod_parser prs;
uint32_t id;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id)) < 0)
port: add port globals Expose all ports as globals, linking is then done by specifying the global id of the ports. Add method to destroy objects. not much security on this one but yet but it should allow priviledged clients to kill connections and other clients etc. Make events on the global object. Implement the bind with the event, handle destroy of the globals. Add link properties Use append to preserve the order.
2018-02-15 17:49:04 +01:00
return -EINVAL;
improve debug
2019-07-17 15:29:18 +02:00
pw_log_debug("client %p: destroy resource %u", client, id);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
pw_client -> pw_impl_client
2019-12-11 11:21:43 +01:00
if ((r = pw_impl_client_find_resource(client, id)) == NULL)
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
goto no_resource;
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
return pw_resource_notify(resource, struct pw_core_methods, destroy, 0, r);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
no_resource:
improve debug
2019-07-17 15:29:18 +02:00
pw_log_error("client %p: unknown resouce %u op:%u", client, id, msg->opcode);
Add printf checks for proxy_error and resource_error Add an error variant without checks.
2019-11-21 16:09:05 +01:00
pw_resource_errorf(resource, -EINVAL, "unknown resource %d op:%u", id, msg->opcode);
improve debug
2019-07-17 15:29:18 +02:00
return 0;
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
}
static int registry_method_marshal_add_listener(void *object,
struct spa_hook *listener,
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
const struct pw_registry_events *events,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
void *data)
{
struct pw_proxy *proxy = object;
clean up proxy and resource api Remove override for resources, it can't work in general. Rename method to add_object_listener to add a listener for events/methods from the remote object. Rename some methods to _call to call the interface and _notify to notify the listeners. Remove unused client event to be notified of resource implementations.
2019-05-29 10:39:24 +02:00
pw_proxy_add_object_listener(proxy, listener, events, data);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
return 0;
port: add port globals Expose all ports as globals, linking is then done by specifying the global id of the ports. Add method to destroy objects. not much security on this one but yet but it should allow priviledged clients to kill connections and other clients etc. Make events on the global object. Implement the bind with the event, handle destroy of the globals. Add link properties Use append to preserve the order.
2018-02-15 17:49:04 +01:00
}
core: remove parent_id from the global event Remove the parent_id from the global event. Remove the parent and owner from the global object. Use properties instead to mark parents and owners of objects. Properties are easier to control for client exported objects and usually a simple parent/child is not enough. For example, a client exported node has the client as a parent but also the factory that created the node.
2019-08-16 22:11:42 +02:00
static void registry_marshal_global(void *object, uint32_t id, uint32_t permissions,
global: add properties Add properties to global objects to make it easier to select what nodes and objects to bind too. They can also be used to implement permissions on the globals based on properties. Add more error handling in _register. Make more functions return a result code. Make a separate pw_module_register, like all other objects.
2018-01-19 11:18:17 +01:00
uint32_t type, uint32_t version, const struct spa_dict *props)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_resource *resource = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
b = pw_protocol_native_begin_resource(resource, PW_REGISTRY_EVENT_GLOBAL, NULL);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
global: add properties Add properties to global objects to make it easier to select what nodes and objects to bind too. They can also be used to implement permissions on the globals based on properties. Add more error handling in _register. Make more functions return a result code. Make a separate pw_module_register, like all other objects.
2018-01-19 11:18:17 +01:00
spa_pod_builder_add(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(id),
SPA_POD_Int(permissions),
SPA_POD_Id(type),
SPA_POD_Int(version),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
NULL);
push_dict(b, props);
spa_pod_builder_pop(b, &f);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void registry_marshal_global_remove(void *object, uint32_t id)
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
{
struct pw_resource *resource = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
b = pw_protocol_native_begin_resource(resource, PW_REGISTRY_EVENT_GLOBAL_REMOVE, NULL);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_builder_add_struct(b, SPA_POD_Int(id));
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int registry_demarshal_bind(void *object, const struct pw_protocol_native_message *msg)
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
{
struct pw_resource *resource = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
uint32_t id, version, type, new_id;
indent
2017-05-26 08:05:01 +02:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id),
SPA_POD_Id(&type),
SPA_POD_Int(&version),
SPA_POD_Int(&new_id)) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
return pw_resource_notify(resource, struct pw_registry_methods, bind, 0, id, type, version, new_id);
indent
2017-05-26 08:05:01 +02:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int registry_demarshal_destroy(void *object, const struct pw_protocol_native_message *msg)
Add proxy destroy Make the current destroy method on the core for proxies to remove the server side resource. Make a new destroy method on the registry to destroy globals. Remove the destroy method on the client-node media-session: monitor the dsp and device node states to manage the session state
2018-09-21 16:43:11 +02:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
uint32_t id;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id)) < 0)
Add proxy destroy Make the current destroy method on the core for proxies to remove the server side resource. Make a new destroy method on the registry to destroy globals. Remove the destroy method on the client-node media-session: monitor the dsp and device node states to manage the session state
2018-09-21 16:43:11 +02:00
return -EINVAL;
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
return pw_resource_notify(resource, struct pw_registry_methods, destroy, 0, id);
Add proxy destroy Make the current destroy method on the core for proxies to remove the server side resource. Make a new destroy method on the registry to destroy globals. Remove the destroy method on the client-node media-session: monitor the dsp and device node states to manage the session state
2018-09-21 16:43:11 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int module_method_marshal_add_listener(void *object,
struct spa_hook *listener,
pw_module_proxy -> pw_module
2019-12-11 15:16:30 +01:00
const struct pw_module_events *events,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
void *data)
{
struct pw_proxy *proxy = object;
clean up proxy and resource api Remove override for resources, it can't work in general. Rename method to add_object_listener to add a listener for events/methods from the remote object. Rename some methods to _call to call the interface and _notify to notify the listeners. Remove unused client event to be notified of resource implementations.
2019-05-29 10:39:24 +02:00
pw_proxy_add_object_listener(proxy, listener, events, data);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
return 0;
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void module_marshal_info(void *object, const struct pw_module_info *info)
indent
2017-05-26 08:05:01 +02:00
{
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_resource *resource = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
indent
2017-05-26 08:05:01 +02:00
pw_module_proxy -> pw_module
2019-12-11 15:16:30 +01:00
b = pw_protocol_native_begin_resource(resource, PW_MODULE_EVENT_INFO, NULL);
indent
2017-05-26 08:05:01 +02:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
spa_pod_builder_add(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(info->id),
SPA_POD_String(info->name),
SPA_POD_String(info->filename),
SPA_POD_String(info->args),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_Long(info->change_mask),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
NULL);
push_dict(b, info->props);
spa_pod_builder_pop(b, &f);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
indent
2017-05-26 08:05:01 +02:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int module_demarshal_info(void *object, const struct pw_protocol_native_message *msg)
indent
2017-05-26 08:05:01 +02:00
{
struct pw_proxy *proxy = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
protocol: init spa_dict properly Or else the flags might be wrong.
2019-11-04 17:25:20 +01:00
struct spa_dict props = SPA_DICT_INIT(NULL, 0);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_module_info info;
indent
2017-05-26 08:05:01 +02:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&info.id),
SPA_POD_String(&info.name),
SPA_POD_String(&info.filename),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_String(&info.args),
SPA_POD_Long(&info.change_mask), NULL) < 0)
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
return -EINVAL;
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&props.n_items), NULL) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
info.props = &props;
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
if (parse_dict(&prs, &props) < 0)
return -EINVAL;
pw_module_proxy -> pw_module
2019-12-11 15:16:30 +01:00
return pw_proxy_notify(proxy, struct pw_module_events, info, 0, &info);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int device_method_marshal_add_listener(void *object,
struct spa_hook *listener,
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
const struct pw_device_events *events,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
void *data)
{
struct pw_proxy *proxy = object;
clean up proxy and resource api Remove override for resources, it can't work in general. Rename method to add_object_listener to add a listener for events/methods from the remote object. Rename some methods to _call to call the interface and _notify to notify the listeners. Remove unused client event to be notified of resource implementations.
2019-05-29 10:39:24 +02:00
pw_proxy_add_object_listener(proxy, listener, events, data);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
return 0;
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void device_marshal_info(void *object, const struct pw_device_info *info)
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
b = pw_protocol_native_begin_resource(resource, PW_DEVICE_EVENT_INFO, NULL);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
spa_pod_builder_add(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(info->id),
SPA_POD_Long(info->change_mask),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
NULL);
push_dict(b, info->props);
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
push_params(b, info->n_params, info->params);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_pop(b, &f);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int device_demarshal_info(void *object, const struct pw_protocol_native_message *msg)
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
protocol: init spa_dict properly Or else the flags might be wrong.
2019-11-04 17:25:20 +01:00
struct spa_dict props = SPA_DICT_INIT(NULL, 0);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
struct pw_device_info info;
uint32_t i;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&info.id),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
SPA_POD_Long(&info.change_mask), NULL) < 0)
return -EINVAL;
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&props.n_items), NULL) < 0)
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
return -EINVAL;
info.props = &props;
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
if (parse_dict(&prs, &props) < 0)
return -EINVAL;
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
spa_pod_parser_pop(&prs, &f[1]);
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
SPA_POD_Int(&info.n_params),
NULL) < 0)
return -EINVAL;
info.params = alloca(info.n_params * sizeof(struct spa_param_info));
for (i = 0; i < info.n_params; i++) {
if (spa_pod_parser_get(&prs,
SPA_POD_Id(&info.params[i].id),
SPA_POD_Int(&info.params[i].flags), NULL) < 0)
return -EINVAL;
}
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
return pw_proxy_notify(proxy, struct pw_device_events, info, 0, &info);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void device_marshal_param(void *object, int seq, uint32_t id, uint32_t index, uint32_t next,
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
const struct spa_pod *param)
{
struct pw_resource *resource = object;
struct spa_pod_builder *b;
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
b = pw_protocol_native_begin_resource(resource, PW_DEVICE_EVENT_PARAM, NULL);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_builder_add_struct(b,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
SPA_POD_Int(seq),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(id),
SPA_POD_Int(index),
SPA_POD_Int(next),
SPA_POD_Pod(param));
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int device_demarshal_param(void *object, const struct pw_protocol_native_message *msg)
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_parser prs;
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
uint32_t id, index, next;
int seq;
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
struct spa_pod *param;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
SPA_POD_Int(&seq),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(&id),
SPA_POD_Int(&index),
SPA_POD_Int(&next),
SPA_POD_Pod(&param)) < 0)
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
return -EINVAL;
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
return pw_proxy_notify(proxy, struct pw_device_events, param, 0,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
seq, id, index, next, param);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
}
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
static int device_marshal_enum_params(void *object, int seq,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
uint32_t id, uint32_t index, uint32_t num, const struct spa_pod *filter)
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
{
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
struct pw_protocol_native_message *msg;
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_DEVICE_METHOD_ENUM_PARAMS, &msg);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
spa_pod_builder_add_struct(b,
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
SPA_POD_Int(SPA_RESULT_RETURN_ASYNC(msg->seq)),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(id),
SPA_POD_Int(index),
SPA_POD_Int(num),
SPA_POD_Pod(filter));
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int device_demarshal_enum_params(void *object, const struct pw_protocol_native_message *msg)
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
uint32_t id, index, num;
int seq;
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
struct spa_pod *filter;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
SPA_POD_Int(&seq),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(&id),
SPA_POD_Int(&index),
SPA_POD_Int(&num),
SPA_POD_Pod(&filter)) < 0)
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
return -EINVAL;
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
return pw_resource_notify(resource, struct pw_device_methods, enum_params, 0,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
seq, id, index, num, filter);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int device_marshal_set_param(void *object, uint32_t id, uint32_t flags,
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
const struct spa_pod *param)
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_DEVICE_METHOD_SET_PARAM, NULL);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
spa_pod_builder_add_struct(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(id),
SPA_POD_Int(flags),
SPA_POD_Pod(param));
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int device_demarshal_set_param(void *object, const struct pw_protocol_native_message *msg)
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
uint32_t id, flags;
struct spa_pod *param;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Id(&id),
SPA_POD_Int(&flags),
SPA_POD_Pod(&param)) < 0)
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
return -EINVAL;
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
return pw_resource_notify(resource, struct pw_device_methods, set_param, 0, id, flags, param);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int factory_method_marshal_add_listener(void *object,
struct spa_hook *listener,
pw_factory_proxy -> pw_factory
2019-12-11 15:06:00 +01:00
const struct pw_factory_events *events,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
void *data)
{
struct pw_proxy *proxy = object;
clean up proxy and resource api Remove override for resources, it can't work in general. Rename method to add_object_listener to add a listener for events/methods from the remote object. Rename some methods to _call to call the interface and _notify to notify the listeners. Remove unused client event to be notified of resource implementations.
2019-05-29 10:39:24 +02:00
pw_proxy_add_object_listener(proxy, listener, events, data);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
return 0;
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void factory_marshal_info(void *object, const struct pw_factory_info *info)
factory: add introspection
2017-09-18 09:35:00 +02:00
{
struct pw_resource *resource = object;
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
factory: add introspection
2017-09-18 09:35:00 +02:00
pw_factory_proxy -> pw_factory
2019-12-11 15:06:00 +01:00
b = pw_protocol_native_begin_resource(resource, PW_FACTORY_EVENT_INFO, NULL);
factory: add introspection
2017-09-18 09:35:00 +02:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
factory: add introspection
2017-09-18 09:35:00 +02:00
spa_pod_builder_add(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(info->id),
SPA_POD_String(info->name),
SPA_POD_Id(info->type),
SPA_POD_Int(info->version),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_Long(info->change_mask),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
NULL);
push_dict(b, info->props);
spa_pod_builder_pop(b, &f);
factory: add introspection
2017-09-18 09:35:00 +02:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
factory: add introspection
2017-09-18 09:35:00 +02:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int factory_demarshal_info(void *object, const struct pw_protocol_native_message *msg)
factory: add introspection
2017-09-18 09:35:00 +02:00
{
struct pw_proxy *proxy = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
protocol: init spa_dict properly Or else the flags might be wrong.
2019-11-04 17:25:20 +01:00
struct spa_dict props = SPA_DICT_INIT(NULL, 0);
factory: add introspection
2017-09-18 09:35:00 +02:00
struct pw_factory_info info;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&info.id),
SPA_POD_String(&info.name),
SPA_POD_Id(&info.type),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_Int(&info.version),
SPA_POD_Long(&info.change_mask), NULL) < 0)
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
return -EINVAL;
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&props.n_items), NULL) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
factory: add introspection
2017-09-18 09:35:00 +02:00
info.props = &props;
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
if (parse_dict(&prs, &props) < 0)
return -EINVAL;
pw_factory_proxy -> pw_factory
2019-12-11 15:06:00 +01:00
return pw_proxy_notify(proxy, struct pw_factory_events, info, 0, &info);
factory: add introspection
2017-09-18 09:35:00 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int node_method_marshal_add_listener(void *object,
struct spa_hook *listener,
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
const struct pw_node_events *events,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
void *data)
{
struct pw_proxy *proxy = object;
clean up proxy and resource api Remove override for resources, it can't work in general. Rename method to add_object_listener to add a listener for events/methods from the remote object. Rename some methods to _call to call the interface and _notify to notify the listeners. Remove unused client event to be notified of resource implementations.
2019-05-29 10:39:24 +02:00
pw_proxy_add_object_listener(proxy, listener, events, data);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
return 0;
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void node_marshal_info(void *object, const struct pw_node_info *info)
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
{
struct pw_resource *resource = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
indent
2017-05-26 08:05:01 +02:00
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
b = pw_protocol_native_begin_resource(resource, PW_NODE_EVENT_INFO, NULL);
indent
2017-05-26 08:05:01 +02:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
spa_pod_builder_add(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(info->id),
SPA_POD_Int(info->max_input_ports),
SPA_POD_Int(info->max_output_ports),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_Long(info->change_mask),
SPA_POD_Int(info->n_input_ports),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(info->n_output_ports),
SPA_POD_Id(info->state),
SPA_POD_String(info->error),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
NULL);
push_dict(b, info->props);
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
push_params(b, info->n_params, info->params);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_pop(b, &f);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
indent
2017-05-26 08:05:01 +02:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int node_demarshal_info(void *object, const struct pw_protocol_native_message *msg)
indent
2017-05-26 08:05:01 +02:00
{
struct pw_proxy *proxy = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
protocol: init spa_dict properly Or else the flags might be wrong.
2019-11-04 17:25:20 +01:00
struct spa_dict props = SPA_DICT_INIT(NULL, 0);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_node_info info;
fix some signed vs unsigned comparisons
2018-02-20 18:19:11 +01:00
uint32_t i;
indent
2017-05-26 08:05:01 +02:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&info.id),
SPA_POD_Int(&info.max_input_ports),
SPA_POD_Int(&info.max_output_ports),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_Long(&info.change_mask),
SPA_POD_Int(&info.n_input_ports),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&info.n_output_ports),
SPA_POD_Id(&info.state),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
SPA_POD_String(&info.error), NULL) < 0)
return -EINVAL;
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&props.n_items), NULL) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
info.props = &props;
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
if (parse_dict(&prs, &props) < 0)
return -EINVAL;
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
spa_pod_parser_pop(&prs, &f[1]);
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
SPA_POD_Int(&info.n_params),
NULL) < 0)
return -EINVAL;
info.params = alloca(info.n_params * sizeof(struct spa_param_info));
for (i = 0; i < info.n_params; i++) {
if (spa_pod_parser_get(&prs,
SPA_POD_Id(&info.params[i].id),
SPA_POD_Int(&info.params[i].flags), NULL) < 0)
return -EINVAL;
}
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
return pw_proxy_notify(proxy, struct pw_node_events, info, 0, &info);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void node_marshal_param(void *object, int seq, uint32_t id,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
uint32_t index, uint32_t next, const struct spa_pod *param)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_builder *b;
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
b = pw_protocol_native_begin_resource(resource, PW_NODE_EVENT_PARAM, NULL);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_builder_add_struct(b,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
SPA_POD_Int(seq),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(id),
SPA_POD_Int(index),
SPA_POD_Int(next),
SPA_POD_Pod(param));
indent
2017-05-26 08:05:01 +02:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int node_demarshal_param(void *object, const struct pw_protocol_native_message *msg)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_parser prs;
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
uint32_t id, index, next;
int seq;
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
struct spa_pod *param;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
SPA_POD_Int(&seq),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(&id),
SPA_POD_Int(&index),
SPA_POD_Int(&next),
SPA_POD_Pod(&param)) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
return pw_proxy_notify(proxy, struct pw_node_events, param, 0,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
seq, id, index, next, param);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
}
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
interfaces: add subscribe params method Add a node subscribe params method that automatically emits the new params when they change so that we can avoid an enum_params. Use this in the stream object. Remove the control messages to update controls in stream, use the set_param. This is more overhead but allows for notifications to other clients. Make it possible to update many controls in one go.
2019-03-18 16:12:27 +01:00
static int node_marshal_subscribe_params(void *object, uint32_t *ids, uint32_t n_ids)
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_NODE_METHOD_SUBSCRIBE_PARAMS, NULL);
interfaces: add subscribe params method Add a node subscribe params method that automatically emits the new params when they change so that we can avoid an enum_params. Use this in the stream object. Remove the control messages to update controls in stream, use the set_param. This is more overhead but allows for notifications to other clients. Make it possible to update many controls in one go.
2019-03-18 16:12:27 +01:00
spa_pod_builder_add_struct(b,
SPA_POD_Array(sizeof(uint32_t), SPA_TYPE_Id, n_ids, ids));
return pw_protocol_native_end_proxy(proxy, b);
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int node_demarshal_subscribe_params(void *object, const struct pw_protocol_native_message *msg)
interfaces: add subscribe params method Add a node subscribe params method that automatically emits the new params when they change so that we can avoid an enum_params. Use this in the stream object. Remove the control messages to update controls in stream, use the set_param. This is more overhead but allows for notifications to other clients. Make it possible to update many controls in one go.
2019-03-18 16:12:27 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
uint32_t csize, ctype, n_ids;
uint32_t *ids;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
interfaces: add subscribe params method Add a node subscribe params method that automatically emits the new params when they change so that we can avoid an enum_params. Use this in the stream object. Remove the control messages to update controls in stream, use the set_param. This is more overhead but allows for notifications to other clients. Make it possible to update many controls in one go.
2019-03-18 16:12:27 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Array(&csize, &ctype, &n_ids, &ids)) < 0)
return -EINVAL;
if (ctype != SPA_TYPE_Id)
return -EINVAL;
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
return pw_resource_notify(resource, struct pw_node_methods, subscribe_params, 0,
interfaces: add subscribe params method Add a node subscribe params method that automatically emits the new params when they change so that we can avoid an enum_params. Use this in the stream object. Remove the control messages to update controls in stream, use the set_param. This is more overhead but allows for notifications to other clients. Make it possible to update many controls in one go.
2019-03-18 16:12:27 +01:00
ids, n_ids);
}
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
static int node_marshal_enum_params(void *object, int seq, uint32_t id,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
uint32_t index, uint32_t num, const struct spa_pod *filter)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
{
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
struct pw_protocol_native_message *msg;
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_NODE_METHOD_ENUM_PARAMS, &msg);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
spa_pod_builder_add_struct(b,
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
SPA_POD_Int(SPA_RESULT_RETURN_ASYNC(msg->seq)),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(id),
SPA_POD_Int(index),
SPA_POD_Int(num),
SPA_POD_Pod(filter));
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int node_demarshal_enum_params(void *object, const struct pw_protocol_native_message *msg)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
uint32_t id, index, num;
int seq;
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
struct spa_pod *filter;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
SPA_POD_Int(&seq),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(&id),
SPA_POD_Int(&index),
SPA_POD_Int(&num),
SPA_POD_Pod(&filter)) < 0)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
return -EINVAL;
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
return pw_resource_notify(resource, struct pw_node_methods, enum_params, 0,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
seq, id, index, num, filter);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int node_marshal_set_param(void *object, uint32_t id, uint32_t flags,
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
const struct spa_pod *param)
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_NODE_METHOD_SET_PARAM, NULL);
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
spa_pod_builder_add_struct(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(id),
SPA_POD_Int(flags),
SPA_POD_Pod(param));
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int node_demarshal_set_param(void *object, const struct pw_protocol_native_message *msg)
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
uint32_t id, flags;
struct spa_pod *param;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Id(&id),
SPA_POD_Int(&flags),
SPA_POD_Pod(&param)) < 0)
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
return -EINVAL;
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
return pw_resource_notify(resource, struct pw_node_methods, set_param, 0, id, flags, param);
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int node_marshal_send_command(void *object, const struct spa_command *command)
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_NODE_METHOD_SEND_COMMAND, NULL);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_builder_add_struct(b,
SPA_POD_Pod(command));
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int node_demarshal_send_command(void *object, const struct pw_protocol_native_message *msg)
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
add const to spa_event and spa_command
2019-05-28 13:51:12 +02:00
const struct spa_command *command;
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Pod(&command)) < 0)
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
return -EINVAL;
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
return pw_resource_notify(resource, struct pw_node_methods, send_command, 0, command);
node: add set_param and send_command methods
2018-09-18 09:28:17 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int port_method_marshal_add_listener(void *object,
struct spa_hook *listener,
const struct pw_port_proxy_events *events,
void *data)
{
struct pw_proxy *proxy = object;
clean up proxy and resource api Remove override for resources, it can't work in general. Rename method to add_object_listener to add a listener for events/methods from the remote object. Rename some methods to _call to call the interface and _notify to notify the listeners. Remove unused client event to be notified of resource implementations.
2019-05-29 10:39:24 +02:00
pw_proxy_add_object_listener(proxy, listener, events, data);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
return 0;
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void port_marshal_info(void *object, const struct pw_port_info *info)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
b = pw_protocol_native_begin_resource(resource, PW_PORT_PROXY_EVENT_INFO, NULL);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
spa_pod_builder_add(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(info->id),
SPA_POD_Int(info->direction),
SPA_POD_Long(info->change_mask),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
NULL);
push_dict(b, info->props);
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
push_params(b, info->n_params, info->params);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_pop(b, &f);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int port_demarshal_info(void *object, const struct pw_protocol_native_message *msg)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
protocol: init spa_dict properly Or else the flags might be wrong.
2019-11-04 17:25:20 +01:00
struct spa_dict props = SPA_DICT_INIT(NULL, 0);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
struct pw_port_info info;
fix some signed vs unsigned comparisons
2018-02-20 18:19:11 +01:00
uint32_t i;
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&info.id),
SPA_POD_Int(&info.direction),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
SPA_POD_Long(&info.change_mask), NULL) < 0)
return -EINVAL;
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&props.n_items), NULL) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
info.props = &props;
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
if (parse_dict(&prs, &props) < 0)
return -EINVAL;
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
spa_pod_parser_pop(&prs, &f[1]);
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
SPA_POD_Int(&info.n_params),
NULL) < 0)
return -EINVAL;
info.params = alloca(info.n_params * sizeof(struct spa_param_info));
for (i = 0; i < info.n_params; i++) {
if (spa_pod_parser_get(&prs,
SPA_POD_Id(&info.params[i].id),
SPA_POD_Int(&info.params[i].flags), NULL) < 0)
return -EINVAL;
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_proxy_notify(proxy, struct pw_port_proxy_events, info, 0, &info);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void port_marshal_param(void *object, int seq, uint32_t id,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
uint32_t index, uint32_t next, const struct spa_pod *param)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_builder *b;
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
b = pw_protocol_native_begin_resource(resource, PW_PORT_PROXY_EVENT_PARAM, NULL);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_builder_add_struct(b,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
SPA_POD_Int(seq),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(id),
SPA_POD_Int(index),
SPA_POD_Int(next),
SPA_POD_Pod(param));
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int port_demarshal_param(void *object, const struct pw_protocol_native_message *msg)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_parser prs;
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
uint32_t id, index, next;
int seq;
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
struct spa_pod *param;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
SPA_POD_Int(&seq),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(&id),
SPA_POD_Int(&index),
SPA_POD_Int(&next),
SPA_POD_Pod(&param)) < 0)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
return -EINVAL;
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
return pw_proxy_notify(proxy, struct pw_port_proxy_events, param, 0,
seq, id, index, next, param);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
}
port: add port subscribe_params
2019-03-18 16:34:07 +01:00
static int port_marshal_subscribe_params(void *object, uint32_t *ids, uint32_t n_ids)
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
b = pw_protocol_native_begin_proxy(proxy, PW_PORT_PROXY_METHOD_SUBSCRIBE_PARAMS, NULL);
spa_pod_builder_add_struct(b,
SPA_POD_Array(sizeof(uint32_t), SPA_TYPE_Id, n_ids, ids));
return pw_protocol_native_end_proxy(proxy, b);
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int port_demarshal_subscribe_params(void *object, const struct pw_protocol_native_message *msg)
port: add port subscribe_params
2019-03-18 16:34:07 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
uint32_t csize, ctype, n_ids;
uint32_t *ids;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
port: add port subscribe_params
2019-03-18 16:34:07 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Array(&csize, &ctype, &n_ids, &ids)) < 0)
return -EINVAL;
if (ctype != SPA_TYPE_Id)
return -EINVAL;
clean up proxy and resource api Remove override for resources, it can't work in general. Rename method to add_object_listener to add a listener for events/methods from the remote object. Rename some methods to _call to call the interface and _notify to notify the listeners. Remove unused client event to be notified of resource implementations.
2019-05-29 10:39:24 +02:00
return pw_resource_notify(resource, struct pw_port_proxy_methods, subscribe_params, 0,
port: add port subscribe_params
2019-03-18 16:34:07 +01:00
ids, n_ids);
}
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
static int port_marshal_enum_params(void *object, int seq, uint32_t id,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
uint32_t index, uint32_t num, const struct spa_pod *filter)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
{
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
struct pw_protocol_native_message *msg;
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_PORT_PROXY_METHOD_ENUM_PARAMS, &msg);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
spa_pod_builder_add_struct(b,
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
SPA_POD_Int(SPA_RESULT_RETURN_ASYNC(msg->seq)),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(id),
SPA_POD_Int(index),
SPA_POD_Int(num),
SPA_POD_Pod(filter));
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int port_demarshal_enum_params(void *object, const struct pw_protocol_native_message *msg)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
uint32_t id, index, num;
int seq;
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
struct spa_pod *filter;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
SPA_POD_Int(&seq),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Id(&id),
SPA_POD_Int(&index),
SPA_POD_Int(&num),
SPA_POD_Pod(&filter)) < 0)
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
return -EINVAL;
clean up proxy and resource api Remove override for resources, it can't work in general. Rename method to add_object_listener to add a listener for events/methods from the remote object. Rename some methods to _call to call the interface and _notify to notify the listeners. Remove unused client event to be notified of resource implementations.
2019-05-29 10:39:24 +02:00
return pw_resource_notify(resource, struct pw_port_proxy_methods, enum_params, 0,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
seq, id, index, num, filter);
indent
2017-05-26 08:05:01 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int client_method_marshal_add_listener(void *object,
struct spa_hook *listener,
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
const struct pw_client_events *events,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
void *data)
{
struct pw_proxy *proxy = object;
clean up proxy and resource api Remove override for resources, it can't work in general. Rename method to add_object_listener to add a listener for events/methods from the remote object. Rename some methods to _call to call the interface and _notify to notify the listeners. Remove unused client event to be notified of resource implementations.
2019-05-29 10:39:24 +02:00
pw_proxy_add_object_listener(proxy, listener, events, data);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
return 0;
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void client_marshal_info(void *object, const struct pw_client_info *info)
indent
2017-05-26 08:05:01 +02:00
{
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
struct pw_resource *resource = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
indent
2017-05-26 08:05:01 +02:00
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_EVENT_INFO, NULL);
indent
2017-05-26 08:05:01 +02:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
spa_pod_builder_add(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(info->id),
SPA_POD_Long(info->change_mask),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
NULL);
push_dict(b, info->props);
spa_pod_builder_pop(b, &f);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int client_demarshal_info(void *object, const struct pw_protocol_native_message *msg)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
indent
2017-05-26 08:05:01 +02:00
struct pw_proxy *proxy = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
protocol: init spa_dict properly Or else the flags might be wrong.
2019-11-04 17:25:20 +01:00
struct spa_dict props = SPA_DICT_INIT(NULL, 0);
indent
2017-05-26 08:05:01 +02:00
struct pw_client_info info;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&info.id),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
SPA_POD_Long(&info.change_mask), NULL) < 0)
return -EINVAL;
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&props.n_items), NULL) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
info.props = &props;
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
if (parse_dict(&prs, &props) < 0)
return -EINVAL;
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
return pw_proxy_notify(proxy, struct pw_client_events, info, 0, &info);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void client_marshal_permissions(void *object, uint32_t index, uint32_t n_permissions,
interfaces: make permissions const
2019-01-10 12:29:21 +01:00
const struct pw_permission *permissions)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
protocol: fix permission marshal, skip default permissions
2019-01-10 16:35:25 +01:00
uint32_t i, n = 0;
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_EVENT_PERMISSIONS, NULL);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
protocol: fix permission marshal, skip default permissions
2019-01-10 16:35:25 +01:00
for (i = 0; i < n_permissions; i++) {
if (permissions[i].permissions != SPA_ID_INVALID)
n++;
}
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f[0]);
spa_pod_builder_int(b, index);
spa_pod_builder_push_struct(b, &f[1]);
spa_pod_builder_int(b, n);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
for (i = 0; i < n_permissions; i++) {
protocol: fix permission marshal, skip default permissions
2019-01-10 16:35:25 +01:00
if (permissions[i].permissions == SPA_ID_INVALID)
continue;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_int(b, permissions[i].id);
spa_pod_builder_int(b, permissions[i].permissions);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
}
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_pop(b, &f[1]);
spa_pod_builder_pop(b, &f[0]);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int client_demarshal_permissions(void *object, const struct pw_protocol_native_message *msg)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
{
struct pw_proxy *proxy = object;
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
struct pw_permission *permissions;
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
uint32_t i, index, n_permissions;
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_get(&prs,
SPA_POD_Int(&index), NULL) < 0)
return -EINVAL;
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
SPA_POD_Int(&n_permissions), NULL) < 0)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
return -EINVAL;
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
permissions = alloca(n_permissions * sizeof(struct pw_permission));
for (i = 0; i < n_permissions; i++) {
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
if (spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&permissions[i].id),
SPA_POD_Int(&permissions[i].permissions), NULL) < 0)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
return -EINVAL;
}
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
return pw_proxy_notify(proxy, struct pw_client_events, permissions, 0, index, n_permissions, permissions);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int client_marshal_error(void *object, uint32_t id, int res, const char *error)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_METHOD_ERROR, NULL);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
spa_pod_builder_add_struct(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(id),
SPA_POD_Int(res),
SPA_POD_String(error));
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int client_demarshal_error(void *object, const struct pw_protocol_native_message *msg)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
uint32_t id, res;
const char *error;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id),
SPA_POD_Int(&res),
SPA_POD_String(&error)) < 0)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
return -EINVAL;
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
return pw_resource_notify(resource, struct pw_client_methods, error, 0, id, res, error);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int client_marshal_get_permissions(void *object, uint32_t index, uint32_t num)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_METHOD_GET_PERMISSIONS, NULL);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
spa_pod_builder_add_struct(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(index),
SPA_POD_Int(num));
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int client_marshal_update_properties(void *object, const struct spa_dict *props)
interfaces: add method to update properties
2019-01-10 11:55:04 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
interfaces: add method to update properties
2019-01-10 11:55:04 +01:00
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_METHOD_UPDATE_PROPERTIES, NULL);
interfaces: add method to update properties
2019-01-10 11:55:04 +01:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
push_dict(b, props);
spa_pod_builder_pop(b, &f);
interfaces: add method to update properties
2019-01-10 11:55:04 +01:00
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
interfaces: add method to update properties
2019-01-10 11:55:04 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int client_demarshal_update_properties(void *object, const struct pw_protocol_native_message *msg)
interfaces: add method to update properties
2019-01-10 11:55:04 +01:00
{
struct pw_resource *resource = object;
protocol: init spa_dict properly Or else the flags might be wrong.
2019-11-04 17:25:20 +01:00
struct spa_dict props = SPA_DICT_INIT(NULL, 0);
interfaces: add method to update properties
2019-01-10 11:55:04 +01:00
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
interfaces: add method to update properties
2019-01-10 11:55:04 +01:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
SPA_POD_Int(&props.n_items), NULL) < 0)
interfaces: add method to update properties
2019-01-10 11:55:04 +01:00
return -EINVAL;
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
if (parse_dict(&prs, &props) < 0)
return -EINVAL;
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
return pw_resource_notify(resource, struct pw_client_methods, update_properties, 0,
interfaces: add method to update properties
2019-01-10 11:55:04 +01:00
&props);
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int client_demarshal_get_permissions(void *object, const struct pw_protocol_native_message *msg)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
{
struct pw_resource *resource = object;
struct spa_pod_parser prs;
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
uint32_t index, num;
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&index),
SPA_POD_Int(&num)) < 0)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
return -EINVAL;
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
return pw_resource_notify(resource, struct pw_client_methods, get_permissions, 0, index, num);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int client_marshal_update_permissions(void *object, uint32_t n_permissions,
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
const struct pw_permission *permissions)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
fix sign confusion
2019-01-07 15:52:42 +01:00
uint32_t i;
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_METHOD_UPDATE_PERMISSIONS, NULL);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
spa_pod_builder_int(b, n_permissions);
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
for (i = 0; i < n_permissions; i++) {
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_int(b, permissions[i].id);
spa_pod_builder_int(b, permissions[i].permissions);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
}
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_pop(b, &f);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int client_demarshal_update_permissions(void *object, const struct pw_protocol_native_message *msg)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
{
struct pw_resource *resource = object;
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
struct pw_permission *permissions;
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[1];
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
uint32_t i, n_permissions;
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&n_permissions), NULL) < 0)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
return -EINVAL;
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
permissions = alloca(n_permissions * sizeof(struct pw_permission));
for (i = 0; i < n_permissions; i++) {
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
if (spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&permissions[i].id),
SPA_POD_Int(&permissions[i].permissions), NULL) < 0)
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
return -EINVAL;
}
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
return pw_resource_notify(resource, struct pw_client_methods, update_permissions, 0,
permissions: pass pw_permission struct around Use a pw_permission struct to express permissions of object. Improve client permissions, add/remove globals when permissions are changed.
2018-11-05 15:02:08 +01:00
n_permissions, permissions);
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int link_method_marshal_add_listener(void *object,
struct spa_hook *listener,
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
const struct pw_link_events *events,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
void *data)
{
struct pw_proxy *proxy = object;
clean up proxy and resource api Remove override for resources, it can't work in general. Rename method to add_object_listener to add a listener for events/methods from the remote object. Rename some methods to _call to call the interface and _notify to notify the listeners. Remove unused client event to be notified of resource implementations.
2019-05-29 10:39:24 +02:00
pw_proxy_add_object_listener(proxy, listener, events, data);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
return 0;
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void link_marshal_info(void *object, const struct pw_link_info *info)
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
{
struct pw_resource *resource = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f;
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
b = pw_protocol_native_begin_resource(resource, PW_LINK_EVENT_INFO, NULL);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
spa_pod_builder_push_struct(b, &f);
link: improve introspection
2017-08-27 17:58:25 +02:00
spa_pod_builder_add(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(info->id),
SPA_POD_Int(info->output_node_id),
SPA_POD_Int(info->output_port_id),
SPA_POD_Int(info->input_node_id),
SPA_POD_Int(info->input_port_id),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_Long(info->change_mask),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(info->state),
SPA_POD_String(info->error),
SPA_POD_Pod(info->format),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
NULL);
push_dict(b, info->props);
spa_pod_builder_pop(b, &f);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
pw_protocol_native_end_resource(resource, b);
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int link_demarshal_info(void *object, const struct pw_protocol_native_message *msg)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
indent
2017-05-26 08:05:01 +02:00
struct pw_proxy *proxy = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
protocol: init spa_dict properly Or else the flags might be wrong.
2019-11-04 17:25:20 +01:00
struct spa_dict props = SPA_DICT_INIT(NULL, 0);
Improve introspection Move introspectable info to the node and link. Only enumerate the device formats once. Change some field names. Pass link format in introspection
2017-06-02 10:40:43 +02:00
struct pw_link_info info = { 0, };
indent
2017-05-26 08:05:01 +02:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&info.id),
SPA_POD_Int(&info.output_node_id),
SPA_POD_Int(&info.output_port_id),
SPA_POD_Int(&info.input_node_id),
SPA_POD_Int(&info.input_port_id),
channelmix: implement per channel volume Implement per channel volume on channelmix. Extend control on stream to take an array of values when possible. Remove name argument from pw_node_new and pw_device_new. We can pass this as a property instead. Improve properties on nodes to more closely match what pulseaudio does. Don't let the monitor do too much with the udev properties but let the session manager set the description and icon-names. Remove some change_mask flags for things that don't change in introspect. Use the flags to mark changes in -cli and -monitor.
2019-08-12 14:47:16 +02:00
SPA_POD_Long(&info.change_mask),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&info.state),
SPA_POD_String(&info.error),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
SPA_POD_Pod(&info.format), NULL) < 0)
return -EINVAL;
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&props.n_items), NULL) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
link: improve introspection
2017-08-27 17:58:25 +02:00
info.props = &props;
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
if (parse_dict(&prs, &props) < 0)
return -EINVAL;
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
return pw_proxy_notify(proxy, struct pw_link_events, info, 0, &info);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int registry_demarshal_global(void *object, const struct pw_protocol_native_message *msg)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
indent
2017-05-26 08:05:01 +02:00
struct pw_proxy *proxy = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
struct spa_pod_frame f[2];
core: remove parent_id from the global event Remove the parent_id from the global event. Remove the parent and owner from the global object. Use properties instead to mark parents and owners of objects. Properties are easier to control for client exported objects and usually a simple parent/child is not enough. For example, a client exported node has the client as a parent but also the factory that created the node.
2019-08-16 22:11:42 +02:00
uint32_t id, permissions, type, version;
protocol: init spa_dict properly Or else the flags might be wrong.
2019-11-04 17:25:20 +01:00
struct spa_dict props = SPA_DICT_INIT(NULL, 0);
indent
2017-05-26 08:05:01 +02:00
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
if (spa_pod_parser_push_struct(&prs, &f[0]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&id),
SPA_POD_Int(&permissions),
SPA_POD_Id(&type),
pod: improve parser and builder Remove the spa_pod_iter helpers Remove builder/parser vararg recurse option, you have to manually recurse into structures when needed. This simplifies things a lot. Pass spa_pod_frames to builder and parser explicitly, we don't have to keep an internal stack anymore. The parser is now almost a mirror image of the builder. Make the parser safer when iterating over objects, add functions to check and get pod contents in a safe way. Make the builder return errno style results on errors Improve performance of object properties when they are stored and retrieved in the same order. Add many more tests for the builder and parser Add some benchmarks
2019-01-22 17:38:23 +01:00
SPA_POD_Int(&version), NULL) < 0)
return -EINVAL;
if (spa_pod_parser_push_struct(&prs, &f[1]) < 0 ||
spa_pod_parser_get(&prs,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(&props.n_items), NULL) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
global: add properties Add properties to global objects to make it easier to select what nodes and objects to bind too. They can also be used to implement permissions on the globals based on properties. Add more error handling in _register. Make more functions return a result code. Make a separate pw_module_register, like all other objects.
2018-01-19 11:18:17 +01:00
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
props: remove pointers in property values in protocol Mark pointers in property values with pointer: and remove them when sending the properties over the wire to avoid errors.
2019-07-11 12:52:55 +02:00
if (parse_dict(&prs, &props) < 0)
return -EINVAL;
global: add properties Add properties to global objects to make it easier to select what nodes and objects to bind too. They can also be used to implement permissions on the globals based on properties. Add more error handling in _register. Make more functions return a result code. Make a separate pw_module_register, like all other objects.
2018-01-19 11:18:17 +01:00
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
return pw_proxy_notify(proxy, struct pw_registry_events,
core: remove parent_id from the global event Remove the parent_id from the global event. Remove the parent and owner from the global object. Use properties instead to mark parents and owners of objects. Properties are easier to control for client exported objects and usually a simple parent/child is not enough. For example, a client exported node has the client as a parent but also the factory that created the node.
2019-08-16 22:11:42 +02:00
global, 0, id, permissions, type, version,
global: add properties Add properties to global objects to make it easier to select what nodes and objects to bind too. They can also be used to implement permissions on the globals based on properties. Add more error handling in _register. Make more functions return a result code. Make a separate pw_module_register, like all other objects.
2018-01-19 11:18:17 +01:00
props.n_items > 0 ? &props : NULL);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
static int registry_demarshal_global_remove(void *object, const struct pw_protocol_native_message *msg)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
indent
2017-05-26 08:05:01 +02:00
struct pw_proxy *proxy = object;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
struct spa_pod_parser prs;
indent
2017-05-26 08:05:01 +02:00
uint32_t id;
protocol-native: pass a message around Pass a message around to make things more extensible later. Keep fds per message if we ever want to write individual messages. Pass number of fds in the message header. We might need this to close the fds when the proxy is gone.
2019-03-19 16:15:20 +01:00
spa_pod_parser_init(&prs, msg->data, msg->size);
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&id)) < 0)
Use int instead of bool as result Prefer to use an int return from a function instead of bool because it can contain more info about failures.
2017-12-18 11:38:30 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
return pw_proxy_notify(proxy, struct pw_registry_events, global_remove, 0, id);
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static void * registry_marshal_bind(void *object, uint32_t id,
uint32_t type, uint32_t version, size_t user_data_size)
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
{
indent
2017-05-26 08:05:01 +02:00
struct pw_proxy *proxy = object;
Work on unifying client and server Remove context and extensions, make client API also use the core. Make a new pw_remote object that keeps connections with remote instances. Remove introspection API, it's just as easy to connect to the registry and get updates like that. Expand the protocol a little to make it useful for making listeners and connections. Move protocol specific connection to the module. Make some new convenience methods. Make a factory to create nodes from spa objects Add an example of a local pipeline displaying a v4l2 source.
2017-07-11 12:24:03 +02:00
struct spa_pod_builder *b;
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct pw_proxy *res;
uint32_t new_id;
protocol: add v0 compatibility For flatpaks we need to be able to support older v0 protocol clients. To handle this we have: - the connection detects an old client when it receives the first message. It can do this by checking the sequence number, on old versions it contains the message size and is never 0, on new clients the sequence number is 0. - We add a new signal at the start of the connection with the detected version number. This installs the right version of the core proxy. We also move the binding of the client until the hello message is received. This way we can have a new client connect (portal), hand over the connection to an old client, which then removes the client binding again in the hello request with a v0 version. There are some changes to the passing of fds in v0 vs v3 which need to investigated some more. - bump version of our interfaces to 3. This makes it possible to have v0 and v3 protocol marshal functions. - Add version number in the proxy. This is mostly automatically done internally based on the version numbers the library is compiled with. Where the version number was in the API before, it is now actually used to look up the right protocol marshal functions. For Proxies there is usually just 1 version, the current one. It is the server that will support different versions. - Add v0 compat marshal functions to convert from and to v0 format. This has some complications. v0 has a type map it keeps in sync with the server. For this we have a static type map with mappings to our own v3 types. Pods are mostly the same except for objects that used to have arbitrary pods in v0 vs spa_pod_prop in v3. Also convert between v0 spa_pod_prop and v3 spa_pod_choice. Formats and commands are also slightly different so handle those mappings as well. We only have marshal functions for the server side (resource) v0 functions. - Add v0 compatible client-node again. It's a bit tricky to map, v0 client-node basically lets the server to the mixing and teeing and just does the processing of the internal node.
2019-10-08 22:52:25 +02:00
res = pw_proxy_new(object, type, version, user_data_size);
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
if (res == NULL)
return NULL;
new_id = pw_proxy_get_id(res);
Rework serialization Move serialization to the protocol, we now just send blocks of bytes over the connection and let the protocol deserialize them.
2017-03-06 15:48:04 +01:00
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_REGISTRY_METHOD_BIND, NULL);
Add update_uris method and event Add a way to send mapper updates between client and server and a way to map between client and server types.
2017-03-14 20:18:31 +01:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
spa_pod_builder_add_struct(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(id),
SPA_POD_Id(type),
SPA_POD_Int(version),
SPA_POD_Int(new_id));
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
pw_protocol_native_end_proxy(proxy, b);
return (void *) res;
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int registry_marshal_destroy(void *object, uint32_t id)
Add proxy destroy Make the current destroy method on the core for proxies to remove the server side resource. Make a new destroy method on the registry to destroy globals. Remove the destroy method on the client-node media-session: monitor the dsp and device node states to manage the session state
2018-09-21 16:43:11 +02:00
{
struct pw_proxy *proxy = object;
struct spa_pod_builder *b;
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
b = pw_protocol_native_begin_proxy(proxy, PW_REGISTRY_METHOD_DESTROY, NULL);
Add proxy destroy Make the current destroy method on the core for proxies to remove the server side resource. Make a new destroy method on the registry to destroy globals. Remove the destroy method on the client-node media-session: monitor the dsp and device node states to manage the session state
2018-09-21 16:43:11 +02:00
spa_pod_builder_add_struct(b,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_POD_Int(id));
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return pw_protocol_native_end_proxy(proxy, b);
Add proxy destroy Make the current destroy method on the core for proxies to remove the server side resource. Make a new destroy method on the registry to destroy globals. Remove the destroy method on the client-node media-session: monitor the dsp and device node states to manage the session state
2018-09-21 16:43:11 +02:00
}
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
static const struct pw_core_methods pw_protocol_native_core_method_marshal = {
PW_VERSION_CORE_METHODS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.add_listener = &core_method_marshal_add_listener,
.hello = &core_method_marshal_hello,
.sync = &core_method_marshal_sync,
.pong = &core_method_marshal_pong,
.error = &core_method_marshal_error,
.get_registry = &core_method_marshal_get_registry,
.create_object = &core_method_marshal_create_object,
.destroy = &core_method_marshal_destroy,
protocol-native: move to separate file Move protocol-native to separate client and server file
2017-03-03 19:06:54 +01:00
};
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
static const struct pw_protocol_native_demarshal pw_protocol_native_core_method_demarshal[PW_CORE_METHOD_NUM] = {
[PW_CORE_METHOD_ADD_LISTENER] = { NULL, 0, },
[PW_CORE_METHOD_HELLO] = { &core_method_demarshal_hello, 0, },
[PW_CORE_METHOD_SYNC] = { &core_method_demarshal_sync, 0, },
[PW_CORE_METHOD_PONG] = { &core_method_demarshal_pong, 0, },
[PW_CORE_METHOD_ERROR] = { &core_method_demarshal_error, 0, },
[PW_CORE_METHOD_GET_REGISTRY] = { &core_method_demarshal_get_registry, 0, },
[PW_CORE_METHOD_CREATE_OBJECT] = { &core_method_demarshal_create_object, 0, },
[PW_CORE_METHOD_DESTROY] = { &core_method_demarshal_destroy, 0, }
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
static const struct pw_core_events pw_protocol_native_core_event_marshal = {
PW_VERSION_CORE_EVENTS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.info = &core_event_marshal_info,
.done = &core_event_marshal_done,
.ping = &core_event_marshal_ping,
.error = &core_event_marshal_error,
.remove_id = &core_event_marshal_remove_id,
interfaces: add event to notify of global bound id Make it possible to know when a proxy is bound to a global id before the global shows up in the registry. This makes it possible to match locally created objects to the one appearing in the registry and possibly avoid a second bind.
2019-11-28 11:50:17 +01:00
.bound_id = &core_event_marshal_bound_id,
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
.add_mem = &core_event_marshal_add_mem,
.remove_mem = &core_event_marshal_remove_mem,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
pw_protocol_native_core_event_demarshal[PW_CORE_EVENT_NUM] =
{
[PW_CORE_EVENT_INFO] = { &core_event_demarshal_info, 0, },
[PW_CORE_EVENT_DONE] = { &core_event_demarshal_done, 0, },
[PW_CORE_EVENT_PING] = { &core_event_demarshal_ping, 0, },
[PW_CORE_EVENT_ERROR] = { &core_event_demarshal_error, 0, },
[PW_CORE_EVENT_REMOVE_ID] = { &core_event_demarshal_remove_id, 0, },
[PW_CORE_EVENT_BOUND_ID] = { &core_event_demarshal_bound_id, 0, },
[PW_CORE_EVENT_ADD_MEM] = { &core_event_demarshal_add_mem, 0, },
[PW_CORE_EVENT_REMOVE_MEM] = { &core_event_demarshal_remove_mem, 0, },
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
};
static const struct pw_protocol_marshal pw_protocol_native_core_marshal = {
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
PW_TYPE_INTERFACE_Core,
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
PW_VERSION_CORE,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
0,
rename core_proxy -> core Rename core_proxy to core and move the introspect and interface contents to core.h In an effort to promote the proxy API.
2019-12-11 07:46:59 +01:00
PW_CORE_METHOD_NUM,
PW_CORE_EVENT_NUM,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
.client_marshal = &pw_protocol_native_core_method_marshal,
.server_demarshal = pw_protocol_native_core_method_demarshal,
.server_marshal = &pw_protocol_native_core_event_marshal,
.client_demarshal = pw_protocol_native_core_event_demarshal,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
static const struct pw_registry_methods pw_protocol_native_registry_method_marshal = {
PW_VERSION_REGISTRY_METHODS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.add_listener = &registry_method_marshal_add_listener,
.bind = &registry_marshal_bind,
.destroy = &registry_marshal_destroy,
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
pw_protocol_native_registry_method_demarshal[PW_REGISTRY_METHOD_NUM] =
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
{
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
[PW_REGISTRY_METHOD_ADD_LISTENER] = { NULL, 0, },
[PW_REGISTRY_METHOD_BIND] = { &registry_demarshal_bind, 0, },
[PW_REGISTRY_METHOD_DESTROY] = { &registry_demarshal_destroy, 0, },
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
static const struct pw_registry_events pw_protocol_native_registry_event_marshal = {
PW_VERSION_REGISTRY_EVENTS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.global = &registry_marshal_global,
.global_remove = &registry_marshal_global_remove,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
pw_protocol_native_registry_event_demarshal[PW_REGISTRY_EVENT_NUM] =
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
{
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
[PW_REGISTRY_EVENT_GLOBAL] = { &registry_demarshal_global, 0, },
[PW_REGISTRY_EVENT_GLOBAL_REMOVE] = { &registry_demarshal_global_remove, 0, }
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
};
const struct pw_protocol_marshal pw_protocol_native_registry_marshal = {
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
PW_TYPE_INTERFACE_Registry,
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
PW_VERSION_REGISTRY,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
0,
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
PW_REGISTRY_METHOD_NUM,
PW_REGISTRY_EVENT_NUM,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
.client_marshal = &pw_protocol_native_registry_method_marshal,
.server_demarshal = pw_protocol_native_registry_method_demarshal,
.server_marshal = &pw_protocol_native_registry_event_marshal,
.client_demarshal = pw_protocol_native_registry_event_demarshal,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
pw_module_proxy -> pw_module
2019-12-11 15:16:30 +01:00
static const struct pw_module_events pw_protocol_native_module_event_marshal = {
PW_VERSION_MODULE_EVENTS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.info = &module_marshal_info,
};
static const struct pw_protocol_native_demarshal
pw_module_proxy -> pw_module
2019-12-11 15:16:30 +01:00
pw_protocol_native_module_event_demarshal[PW_MODULE_EVENT_NUM] =
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
{
pw_module_proxy -> pw_module
2019-12-11 15:16:30 +01:00
[PW_MODULE_EVENT_INFO] = { &module_demarshal_info, 0, },
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
};
pw_module_proxy -> pw_module
2019-12-11 15:16:30 +01:00
static const struct pw_module_methods pw_protocol_native_module_method_marshal = {
PW_VERSION_MODULE_METHODS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.add_listener = &module_method_marshal_add_listener,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_module_proxy -> pw_module
2019-12-11 15:16:30 +01:00
pw_protocol_native_module_method_demarshal[PW_MODULE_METHOD_NUM] =
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
{
pw_module_proxy -> pw_module
2019-12-11 15:16:30 +01:00
[PW_MODULE_METHOD_ADD_LISTENER] = { NULL, 0, },
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
};
const struct pw_protocol_marshal pw_protocol_native_module_marshal = {
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
PW_TYPE_INTERFACE_Module,
pw_module_proxy -> pw_module
2019-12-11 15:16:30 +01:00
PW_VERSION_MODULE,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
0,
pw_module_proxy -> pw_module
2019-12-11 15:16:30 +01:00
PW_MODULE_METHOD_NUM,
PW_MODULE_EVENT_NUM,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
.client_marshal = &pw_protocol_native_module_method_marshal,
.server_demarshal = pw_protocol_native_module_method_demarshal,
.server_marshal = &pw_protocol_native_module_event_marshal,
.client_demarshal = pw_protocol_native_module_event_demarshal,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
pw_factory_proxy -> pw_factory
2019-12-11 15:06:00 +01:00
static const struct pw_factory_events pw_protocol_native_factory_event_marshal = {
PW_VERSION_FACTORY_EVENTS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.info = &factory_marshal_info,
};
static const struct pw_protocol_native_demarshal
pw_factory_proxy -> pw_factory
2019-12-11 15:06:00 +01:00
pw_protocol_native_factory_event_demarshal[PW_FACTORY_EVENT_NUM] =
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
{
pw_factory_proxy -> pw_factory
2019-12-11 15:06:00 +01:00
[PW_FACTORY_EVENT_INFO] = { &factory_demarshal_info, 0, },
factory: add introspection
2017-09-18 09:35:00 +02:00
};
pw_factory_proxy -> pw_factory
2019-12-11 15:06:00 +01:00
static const struct pw_factory_methods pw_protocol_native_factory_method_marshal = {
PW_VERSION_FACTORY_METHODS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.add_listener = &factory_method_marshal_add_listener,
};
static const struct pw_protocol_native_demarshal
pw_factory_proxy -> pw_factory
2019-12-11 15:06:00 +01:00
pw_protocol_native_factory_method_demarshal[PW_FACTORY_METHOD_NUM] =
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
{
pw_factory_proxy -> pw_factory
2019-12-11 15:06:00 +01:00
[PW_FACTORY_METHOD_ADD_LISTENER] = { NULL, 0, },
factory: add introspection
2017-09-18 09:35:00 +02:00
};
const struct pw_protocol_marshal pw_protocol_native_factory_marshal = {
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
PW_TYPE_INTERFACE_Factory,
pw_factory_proxy -> pw_factory
2019-12-11 15:06:00 +01:00
PW_VERSION_FACTORY,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
0,
pw_factory_proxy -> pw_factory
2019-12-11 15:06:00 +01:00
PW_FACTORY_METHOD_NUM,
PW_FACTORY_EVENT_NUM,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
.client_marshal = &pw_protocol_native_factory_method_marshal,
.server_demarshal = pw_protocol_native_factory_method_demarshal,
.server_marshal = &pw_protocol_native_factory_event_marshal,
.client_demarshal = pw_protocol_native_factory_event_demarshal,
factory: add introspection
2017-09-18 09:35:00 +02:00
};
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
static const struct pw_device_methods pw_protocol_native_device_method_marshal = {
PW_VERSION_DEVICE_METHODS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.add_listener = &device_method_marshal_add_listener,
.enum_params = &device_marshal_enum_params,
.set_param = &device_marshal_set_param,
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
pw_protocol_native_device_method_demarshal[PW_DEVICE_METHOD_NUM] = {
[PW_DEVICE_METHOD_ADD_LISTENER] = { NULL, 0, },
[PW_DEVICE_METHOD_ENUM_PARAMS] = { &device_demarshal_enum_params, 0, },
[PW_DEVICE_METHOD_SET_PARAM] = { &device_demarshal_set_param, PW_PERM_W, },
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
};
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
static const struct pw_device_events pw_protocol_native_device_event_marshal = {
PW_VERSION_DEVICE_EVENTS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.info = &device_marshal_info,
.param = &device_marshal_param,
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
pw_protocol_native_device_event_demarshal[PW_DEVICE_EVENT_NUM] = {
[PW_DEVICE_EVENT_INFO] = { &device_demarshal_info, 0, },
[PW_DEVICE_EVENT_PARAM] = { &device_demarshal_param, 0, }
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
};
static const struct pw_protocol_marshal pw_protocol_native_device_marshal = {
PW_TYPE_INTERFACE_Device,
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
PW_VERSION_DEVICE,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
0,
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
PW_DEVICE_METHOD_NUM,
PW_DEVICE_EVENT_NUM,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
.client_marshal = &pw_protocol_native_device_method_marshal,
.server_demarshal = pw_protocol_native_device_method_demarshal,
.server_marshal = &pw_protocol_native_device_event_marshal,
.client_demarshal = pw_protocol_native_device_event_demarshal,
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
};
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
static const struct pw_node_methods pw_protocol_native_node_method_marshal = {
PW_VERSION_NODE_METHODS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.add_listener = &node_method_marshal_add_listener,
.subscribe_params = &node_marshal_subscribe_params,
.enum_params = &node_marshal_enum_params,
.set_param = &node_marshal_set_param,
.send_command = &node_marshal_send_command,
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
pw_protocol_native_node_method_demarshal[PW_NODE_METHOD_NUM] =
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
{
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
[PW_NODE_METHOD_ADD_LISTENER] = { NULL, 0, },
[PW_NODE_METHOD_SUBSCRIBE_PARAMS] = { &node_demarshal_subscribe_params, 0, },
[PW_NODE_METHOD_ENUM_PARAMS] = { &node_demarshal_enum_params, 0, },
[PW_NODE_METHOD_SET_PARAM] = { &node_demarshal_set_param, PW_PERM_W, },
[PW_NODE_METHOD_SEND_COMMAND] = { &node_demarshal_send_command, PW_PERM_W, },
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
};
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
static const struct pw_node_events pw_protocol_native_node_event_marshal = {
PW_VERSION_NODE_EVENTS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.info = &node_marshal_info,
.param = &node_marshal_param,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
pw_protocol_native_node_event_demarshal[PW_NODE_EVENT_NUM] = {
[PW_NODE_EVENT_INFO] = { &node_demarshal_info, 0, },
[PW_NODE_EVENT_PARAM] = { &node_demarshal_param, 0, }
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
};
static const struct pw_protocol_marshal pw_protocol_native_node_marshal = {
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
PW_TYPE_INTERFACE_Node,
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
PW_VERSION_NODE,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
0,
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
PW_NODE_METHOD_NUM,
PW_NODE_EVENT_NUM,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
.client_marshal = &pw_protocol_native_node_method_marshal,
.server_demarshal = pw_protocol_native_node_method_demarshal,
.server_marshal = &pw_protocol_native_node_event_marshal,
.client_demarshal = pw_protocol_native_node_event_demarshal,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
static const struct pw_port_proxy_methods pw_protocol_native_port_method_marshal = {
PW_VERSION_PORT_PROXY_METHODS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.add_listener = &port_method_marshal_add_listener,
.subscribe_params = &port_marshal_subscribe_params,
.enum_params = &port_marshal_enum_params,
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_protocol_native_port_method_demarshal[PW_PORT_PROXY_METHOD_NUM] =
{
[PW_PORT_PROXY_METHOD_ADD_LISTENER] = { NULL, 0, },
[PW_PORT_PROXY_METHOD_SUBSCRIBE_PARAMS] = { &port_demarshal_subscribe_params, 0, },
[PW_PORT_PROXY_METHOD_ENUM_PARAMS] = { &port_demarshal_enum_params, 0, },
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
};
static const struct pw_port_proxy_events pw_protocol_native_port_event_marshal = {
PW_VERSION_PORT_PROXY_EVENTS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.info = &port_marshal_info,
.param = &port_marshal_param,
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_protocol_native_port_event_demarshal[PW_PORT_PROXY_EVENT_NUM] =
{
[PW_PORT_PROXY_EVENT_INFO] = { &port_demarshal_info, 0, },
[PW_PORT_PROXY_EVENT_PARAM] = { &port_demarshal_param, 0, }
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
};
static const struct pw_protocol_marshal pw_protocol_native_port_marshal = {
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
PW_TYPE_INTERFACE_Port,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
PW_VERSION_PORT_PROXY,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
0,
reorganize some struct members to remove holes
2019-02-08 12:01:50 +01:00
PW_PORT_PROXY_METHOD_NUM,
PW_PORT_PROXY_EVENT_NUM,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
.client_marshal = &pw_protocol_native_port_method_marshal,
.server_demarshal = pw_protocol_native_port_method_demarshal,
.server_marshal = &pw_protocol_native_port_event_marshal,
.client_demarshal = pw_protocol_native_port_event_demarshal,
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
};
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
static const struct pw_client_methods pw_protocol_native_client_method_marshal = {
PW_VERSION_CLIENT_METHODS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.add_listener = &client_method_marshal_add_listener,
.error = &client_marshal_error,
.update_properties = &client_marshal_update_properties,
.get_permissions = &client_marshal_get_permissions,
.update_permissions = &client_marshal_update_permissions,
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
pw_protocol_native_client_method_demarshal[PW_CLIENT_METHOD_NUM] =
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
{
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
[PW_CLIENT_METHOD_ADD_LISTENER] = { NULL, 0, },
[PW_CLIENT_METHOD_ERROR] = { &client_demarshal_error, PW_PERM_W, },
[PW_CLIENT_METHOD_UPDATE_PROPERTIES] = { &client_demarshal_update_properties, PW_PERM_W, },
[PW_CLIENT_METHOD_GET_PERMISSIONS] = { &client_demarshal_get_permissions, 0, },
[PW_CLIENT_METHOD_UPDATE_PERMISSIONS] = { &client_demarshal_update_permissions, PW_PERM_W, },
protocol: add more methods on client Add method to get and set permissions on a client Add method to send error to client.
2018-10-27 17:31:03 +01:00
};
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
static const struct pw_client_events pw_protocol_native_client_event_marshal = {
PW_VERSION_CLIENT_EVENTS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.info = &client_marshal_info,
.permissions = &client_marshal_permissions,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
pw_protocol_native_client_event_demarshal[PW_CLIENT_EVENT_NUM] =
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
{
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
[PW_CLIENT_EVENT_INFO] = { &client_demarshal_info, 0, },
[PW_CLIENT_EVENT_PERMISSIONS] = { &client_demarshal_permissions, 0, }
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
};
static const struct pw_protocol_marshal pw_protocol_native_client_marshal = {
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
PW_TYPE_INTERFACE_Client,
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
PW_VERSION_CLIENT,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
0,
pw_client_proxy -> pw_client
2019-12-11 14:53:39 +01:00
PW_CLIENT_METHOD_NUM,
PW_CLIENT_EVENT_NUM,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
.client_marshal = &pw_protocol_native_client_method_marshal,
.server_demarshal = pw_protocol_native_client_method_demarshal,
.server_marshal = &pw_protocol_native_client_event_marshal,
.client_demarshal = pw_protocol_native_client_event_demarshal,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
static const struct pw_link_methods pw_protocol_native_link_method_marshal = {
PW_VERSION_LINK_METHODS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.add_listener = &link_method_marshal_add_listener,
};
static const struct pw_protocol_native_demarshal
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
pw_protocol_native_link_method_demarshal[PW_LINK_METHOD_NUM] =
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
{
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
[PW_LINK_METHOD_ADD_LISTENER] = { NULL, 0, },
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
};
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
static const struct pw_link_events pw_protocol_native_link_event_marshal = {
PW_VERSION_LINK_EVENTS,
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
.info = &link_marshal_info,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct pw_protocol_native_demarshal
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
pw_protocol_native_link_event_demarshal[PW_LINK_EVENT_NUM] =
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
{
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
[PW_LINK_EVENT_INFO] = { &link_demarshal_info, 0, }
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
};
static const struct pw_protocol_marshal pw_protocol_native_link_marshal = {
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
PW_TYPE_INTERFACE_Link,
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
PW_VERSION_LINK,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
0,
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
PW_LINK_METHOD_NUM,
PW_LINK_EVENT_NUM,
protocol: add flags to protocol marshal Allows us to to select marshallers for implementation and binding.
2019-11-03 10:21:57 +01:00
.client_marshal = &pw_protocol_native_link_method_marshal,
.server_demarshal = pw_protocol_native_link_method_demarshal,
.server_marshal = &pw_protocol_native_link_event_marshal,
.client_demarshal = pw_protocol_native_link_event_demarshal,
Make extensions Make the protocol-native and client-node extensions
2017-06-21 12:11:54 +02:00
};
Implement protocol extensions Add hooks that contain protocol specific interfaces that can be used to extend the protocol. This makes it possible to add new interfaces to the protocol and implement the protocol specific data transport. Move these protocol specific extension to the extensions directory.
2017-07-12 18:04:00 +02:00
void pw_protocol_native_init(struct pw_protocol *protocol)
indent
2017-05-26 08:05:01 +02:00
{
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
pw_protocol_add_marshal(protocol, &pw_protocol_native_core_marshal);
pw_protocol_add_marshal(protocol, &pw_protocol_native_registry_marshal);
pw_protocol_add_marshal(protocol, &pw_protocol_native_module_marshal);
device: add device object Make a device object, let the v4l2 monitor create device objects The device object is responsible for dynamically creating nodes.
2018-11-23 12:43:47 +01:00
pw_protocol_add_marshal(protocol, &pw_protocol_native_device_marshal);
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
pw_protocol_add_marshal(protocol, &pw_protocol_native_node_marshal);
params: make method on node and port to enum params Do not pass the params of the node in the node_info, instead, make a method to enumerate the params. This makes it possible for clients to only enumerate what they need and when they need it. Improve introspection of a port, add the name and properties. Add an enum_param method on the port that can be used to enumerate port formats. Change -monitor and -cli and add support for enum_params on the node and port.
2018-02-20 10:31:55 +01:00
pw_protocol_add_marshal(protocol, &pw_protocol_native_port_marshal);
factory: add introspection
2017-09-18 09:35:00 +02:00
pw_protocol_add_marshal(protocol, &pw_protocol_native_factory_marshal);
API cleanups Fix docs Add some more versions to interfaces Make types for the various proxy object + inline methods that does type checking and create proxys etc. Set owner client of client-nodes in the properties Pass type to bind to in create-node Don't place global id in the info structs Improve registration of marshal functions Pass more types around as ids
2017-07-13 15:21:52 +02:00
pw_protocol_add_marshal(protocol, &pw_protocol_native_client_marshal);
pw_protocol_add_marshal(protocol, &pw_protocol_native_link_marshal);
improve interfaces Make an interface structure to hold methods and events. Move interface setup to protocol
2017-03-09 13:00:56 +01:00
}
Reference in a new issue Copy permalink