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/examples/local-v4l2.c

450 lines
10 KiB
C
Raw Normal View History

treewide: use SPDX tags to specify copyright information SPDX tags make the licensing information easy to understand and clear, and they are machine parseable. See https://spdx.dev for more information.
2023-02-08 18:12:00 +01:00
/* PipeWire */
/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
/* SPDX-License-Identifier: MIT */
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
doc: link examples to Doxygen docs Include examples to the documentation, using Doxygen's example system.
2021-10-09 23:25:29 +03:00
/*
[title]
Using libspa-v4l2
[title]
*/
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 <stdio.h>
#include <sys/mman.h>
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
#define WIDTH 640
#define HEIGHT 480
#define BPP 3
fix use_buffers checks We can set 0 buffers even if there is no format. Return -ENOSPC when too many buffers are set.
2023-01-10 12:30:25 +01:00
#define MAX_BUFFERS 32
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
#include "sdl.h"
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
Reorganise SPA tree Reorganise the SPA includes to make it more extensible later Simplify the naming of the buffer and meta params
2017-11-10 13:36:14 +01:00
#include <spa/param/video/format-utils.h>
#include <spa/param/props.h>
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
#include <spa/pod/filter.h>
node: Add id to set_io Make it possible to configure multiple io areas on a port by giving an id to set_io. Add some types to enumerate the supported ids Make an area to exchange buffers and one to specify pull ranges. The idea is to make more area types for controlable properties. Implement enumeration of IO areas in volume.
2017-11-21 19:34:37 +01:00
#include <spa/node/io.h>
Move implementation helpers to utils
2019-05-20 10:14:00 +02:00
#include <spa/node/utils.h>
remove spalib
2018-08-14 12:33:53 +02:00
#include <spa/debug/format.h>
names: add standard factory name definitions Define a set of standard factory names and document what they contain. This makes it possible to change the implementation by mapping the factory-name to a different shared library.
2019-06-21 13:31:34 +02:00
#include <spa/utils/names.h>
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
move proxy implementations in their own file Rearrange headers
2019-12-11 10:57:10 +01:00
#include <pipewire/impl.h>
move things around
2017-07-11 15:57:20 +02: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
struct data {
SDL_Renderer *renderer;
SDL_Window *window;
SDL_Texture *texture;
Add example to play sine wave Various build fixes and cleanups Move port_add to private and make node ports based on implementation. Improve pull based scheduling on remote nodes
2017-09-07 10:22:32 +02:00
struct pw_main_loop *loop;
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
pw_core -> pw_context The proxy API is the one that we would like to expose for applications and the other API is used internally when implementing modules or factories. The current pw_core object is really a context for all objects so name it that way. It also makes it possible to rename pw_core_proxy to pw_proxy later.
2019-12-10 18:19:56 +01:00
struct pw_context *context;
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
struct pw_core *core;
example: fix v4l2 example We need to emit a port param update to notify of new Buffer parameters.
2020-03-19 18:08:34 +01:00
struct spa_port_info info;
struct spa_param_info params[4];
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
node: always use a spa_node as the implementation Avoid duplicating API, remove implementations from port and node and always use an spa_node as the implementation, it's just as easy to implement a spa node. With the implementation always being a spa_node we will be able to better implement the negotiation of the mixers.
2017-08-25 18:59:01 +02:00
struct spa_node impl_node;
node: Add id to set_io Make it possible to configure multiple io areas on a port by giving an id to set_io. Add some types to enumerate the supported ids Make an area to exchange buffers and one to specify pull ranges. The idea is to make more area types for controlable properties. Implement enumeration of IO areas in volume.
2017-11-21 19:34:37 +01:00
struct spa_io_buffers *io;
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18:54 +02:00
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
struct spa_hook_list hooks;
node: always use a spa_node as the implementation Avoid duplicating API, remove implementations from port and node and always use an spa_node as the implementation, it's just as easy to implement a spa node. With the implementation always being a spa_node we will be able to better implement the negotiation of the mixers.
2017-08-25 18:59:01 +02: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
struct spa_video_info_raw format;
int32_t stride;
fix use_buffers checks We can set 0 buffers even if there is no format. Return -ENOSPC when too many buffers are set.
2023-01-10 12:30:25 +01:00
struct spa_buffer *buffers[MAX_BUFFERS];
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
int n_buffers;
local-v4l2: fix leaks
2020-06-05 12:16:05 +02:00
struct pw_proxy *out, *in, *link;
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
};
static void handle_events(struct data *data)
{
SDL_Event event;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
Add example to play sine wave Various build fixes and cleanups Move port_add to private and make node ports based on implementation. Improve pull based scheduling on remote nodes
2017-09-07 10:22:32 +02:00
pw_main_loop_quit(data->loop);
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
break;
}
}
}
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 impl_set_io(void *object, uint32_t id, void *data, size_t size)
node: Add port_info event Add a port_info event. With this, we get updates to ports pushed to us, which is more convenient and also allows for better dynamic add/remove of ports. We don't need to the PortChanged event anymore We can remove the get_port_ids/get_n_ports/port_get_info methods. Update plugins
2019-02-14 17:08:46 +01: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 impl_send_command(void *object, const struct spa_command *command)
node: always use a spa_node as the implementation Avoid duplicating API, remove implementations from port and node and always use an spa_node as the implementation, it's just as easy to implement a spa node. With the implementation always being a spa_node we will be able to better implement the negotiation of the mixers.
2017-08-25 18:59:01 +02:00
{
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
node: always use a spa_node as the implementation Avoid duplicating API, remove implementations from port and node and always use an spa_node as the implementation, it's just as easy to implement a spa node. With the implementation always being a spa_node we will be able to better implement the negotiation of the mixers.
2017-08-25 18:59: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 impl_add_listener(void *object,
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
struct spa_hook *listener,
const struct spa_node_events *events,
void *data)
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18: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
struct data *d = object;
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
struct spa_hook_list save;
node: always use a spa_node as the implementation Avoid duplicating API, remove implementations from port and node and always use an spa_node as the implementation, it's just as easy to implement a spa node. With the implementation always being a spa_node we will be able to better implement the negotiation of the mixers.
2017-08-25 18:59:01 +02:00
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
spa_hook_list_isolate(&d->hooks, &save, listener, events, data);
Add example to play sine wave Various build fixes and cleanups Move port_add to private and make node ports based on implementation. Improve pull based scheduling on remote nodes
2017-09-07 10:22:32 +02:00
example: fix v4l2 example We need to emit a port param update to notify of new Buffer parameters.
2020-03-19 18:08:34 +01:00
spa_node_emit_port_info(&d->hooks, SPA_DIRECTION_INPUT, 0, &d->info);
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
spa_hook_list_join(&d->hooks, &save);
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 impl_set_callbacks(void *object,
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
const struct spa_node_callbacks *callbacks, void *data)
{
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
Add example to play sine wave Various build fixes and cleanups Move port_add to private and make node ports based on implementation. Improve pull based scheduling on remote nodes
2017-09-07 10:22:32 +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 impl_port_set_io(void *object, enum spa_direction direction, uint32_t port_id,
Add control properties to audiotestsrc Add control properties to audiotestsrc for frequency and volume and add a test program. Add size parameter to set_io for additional checks and to make it easy to know how much control data we can write.
2017-11-22 14:30:04 +01:00
uint32_t id, void *data, size_t size)
node: always use a spa_node as the implementation Avoid duplicating API, remove implementations from port and node and always use an spa_node as the implementation, it's just as easy to implement a spa node. With the implementation always being a spa_node we will be able to better implement the negotiation of the mixers.
2017-08-25 18:59: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
struct data *d = object;
node: Add id to set_io Make it possible to configure multiple io areas on a port by giving an id to set_io. Add some types to enumerate the supported ids Make an area to exchange buffers and one to specify pull ranges. The idea is to make more area types for controlable properties. Implement enumeration of IO areas in volume.
2017-11-21 19:34:37 +01:00
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
if (id == SPA_IO_Buffers)
Add control properties to audiotestsrc Add control properties to audiotestsrc for frequency and volume and add a test program. Add size parameter to set_io for additional checks and to make it easy to know how much control data we can write.
2017-11-22 14:30:04 +01:00
d->io = data;
node: Add id to set_io Make it possible to configure multiple io areas on a port by giving an id to set_io. Add some types to enumerate the supported ids Make an area to exchange buffers and one to specify pull ranges. The idea is to make more area types for controlable properties. Implement enumeration of IO areas in volume.
2017-11-21 19:34:37 +01:00
else
return -ENOENT;
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18: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 impl_port_enum_params(void *object, int seq,
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
enum spa_direction direction, uint32_t port_id,
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
uint32_t id, uint32_t start, uint32_t num,
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
const struct spa_pod *filter)
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
{
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 data *d = object;
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
struct spa_pod *param;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
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
struct spa_result_node_params result;
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
uint32_t count = 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
result.id = id;
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
result.next = start;
next:
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
result.index = result.next++;
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
spa_pod_builder_init(&b, buffer, sizeof(buffer));
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
switch (id) {
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_PARAM_EnumFormat:
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
{
SDL_RendererInfo info;
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
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
if (result.index > 0)
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
return 0;
SDL_GetRendererInfo(d->renderer, &info);
param = sdl_build_formats(&info, &b);
break;
}
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_PARAM_Buffers:
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
if (result.index > 0)
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +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
param = spa_pod_builder_add_object(&b,
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
SPA_TYPE_OBJECT_ParamBuffers, 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_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 1, 32),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(d->stride * d->format.size.height),
buffers: make alignment optional Make the alignment parameter optional when negotiating buffers. Default to a 16 bytes alignment and adjust for the max cpu alignment. Remove the useless align buffer parameter in plugins, we always set it to 16 anyway.
2022-01-03 12:32:26 +01:00
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(d->stride));
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_PARAM_Meta:
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
if (result.index > 0)
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +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
param = spa_pod_builder_add_object(&b,
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
SPA_TYPE_OBJECT_ParamMeta, 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_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
default:
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -ENOENT;
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
}
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +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
if (spa_pod_filter(&b, &result.param, param, filter) < 0)
goto next;
spa: add result type We need this to know the type of result, especially when serializing.
2019-05-28 13:59:48 +02:00
spa_node_emit_result(&d->hooks, seq, 0, SPA_RESULT_TYPE_NODE_PARAMS, &result);
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
if (++count != num)
goto next;
return 0;
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39: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
static int port_set_format(void *object, enum spa_direction direction, uint32_t port_id,
Improve enum_param Add an argument to pass the result param to the caller instead of having the caller have to pick it up from the builder. Improve docs for node, clock and monitor Pass spa_pod everywhere instead of spa_pod_object. Pass result argument to spa_pod_filter to make things a little nicer.
2017-11-13 17:57:38 +01:00
uint32_t flags, const struct spa_pod *format)
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39: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
struct data *d = 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
Uint32 sdl_format;
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18:54 +02:00
void *dest;
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
Add some more format checks The format parse functions don't really check if the parsed values make any sense so we need to to this ourselves.
2022-11-03 13:10:32 +01:00
if (format == NULL) {
spa_zero(d->format);
SDL_DestroyTexture(d->texture);
d->texture = NULL;
} else {
spa_debug_format(0, NULL, format);
spa_format_video_raw_parse(format, &d->format);
sdl_format = id_to_sdl_format(d->format.format);
if (sdl_format == SDL_PIXELFORMAT_UNKNOWN)
return -EINVAL;
if (d->format.size.width == 0 ||
d->format.size.height == 0)
return -EINVAL;
d->texture = SDL_CreateTexture(d->renderer,
sdl_format,
SDL_TEXTUREACCESS_STREAMING,
d->format.size.width,
d->format.size.height);
SDL_LockTexture(d->texture, NULL, &dest, &d->stride);
SDL_UnlockTexture(d->texture);
}
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18:54 +02:00
example: fix v4l2 example We need to emit a port param update to notify of new Buffer parameters.
2020-03-19 18:08:34 +01:00
d->info.change_mask = SPA_PORT_CHANGE_MASK_PARAMS;
Add some more format checks The format parse functions don't really check if the parsed values make any sense so we need to to this ourselves.
2022-11-03 13:10:32 +01:00
if (format) {
d->params[1] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_READWRITE);
d->params[2] = SPA_PARAM_INFO(SPA_PARAM_Buffers, SPA_PARAM_INFO_READ);
} else {
d->params[1] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
d->params[2] = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
}
example: fix v4l2 example We need to emit a port param update to notify of new Buffer parameters.
2020-03-19 18:08:34 +01:00
spa_node_emit_port_info(&d->hooks, SPA_DIRECTION_INPUT, 0, &d->info);
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
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
}
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 impl_port_set_param(void *object,
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t flags,
Improve enum_param Add an argument to pass the result param to the caller instead of having the caller have to pick it up from the builder. Improve docs for node, clock and monitor Pass spa_pod everywhere instead of spa_pod_object. Pass result argument to spa_pod_filter to make things a little nicer.
2017-11-13 17:57:38 +01:00
const struct spa_pod *param)
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
{
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
if (id == SPA_PARAM_Format) {
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 port_set_format(object, direction, port_id, flags, param);
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
}
else
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -ENOENT;
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
}
Add support for client fd memory Remove the node buffers reply again. We don't need it. Instead add a new method to the client-node to upload an array of buffer datas. This method is called after the client has allocated buffer mem. It will update the buffers on the server side with the client allocated memory. Wait for the async reply of use_buffers when doing alloc_buffers so that we can get the updated buffer mem before we continue. Let the link follow the states of the ports. Add some error code to the port error states. Add PW_STREAM_FLAG_ALLOC_BUFFERS flag to make the client alloc buffer memory.
2019-07-26 15:53:26 +02:00
static int impl_port_use_buffers(void *object,
enum spa_direction direction, uint32_t port_id,
node: add flags to port_use_buffer Remove the CAN_USE_BUFFERS flag, it is redundant. We can know this because of the IO params and buffer params. Add flags to the port_use_buffer call. We also want this call to replace port_alloc_buffer. Together with a new result event we can ask the node to (a)synchronously fill up the buffer data for us. This is part of a plan to let remote nodes provide buffer data.
2019-07-25 13:19:39 +02:00
uint32_t flags, struct spa_buffer **buffers, uint32_t n_buffers)
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
{
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 data *d = object;
fix some signed vs unsigned comparisons
2018-02-20 18:19:11 +01:00
uint32_t i;
fix use_buffers checks We can set 0 buffers even if there is no format. Return -ENOSPC when too many buffers are set.
2023-01-10 12:30:25 +01:00
if (n_buffers > MAX_BUFFERS)
return -ENOSPC;
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
for (i = 0; i < n_buffers; i++)
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18:54 +02:00
d->buffers[i] = buffers[i];
d->n_buffers = n_buffers;
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
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
}
SDL examples: all SDL operations in one thread Fix video in SDL examples by invoking rendering in the same thread (pw_loop) that created the window, renderer and texture. At least on some systems, no video is shown without this patch. In those error cases, SDL_RenderPresent triggers an SDL error "The specified window has not been made current". That, in turn, has to do with how SDL uses the current thread for determing the current window. In general, the page linked to below states that the SDL API is not designed to be used from multiple threads. Reference: https://wiki.libsdl.org/CategoryRender
2018-01-12 13:40:01 +01:00
static int do_render(struct spa_loop *loop, bool async, uint32_t seq,
const void *_data, size_t size, void *user_data)
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
{
SDL examples: all SDL operations in one thread Fix video in SDL examples by invoking rendering in the same thread (pw_loop) that created the window, renderer and texture. At least on some systems, no video is shown without this patch. In those error cases, SDL_RenderPresent triggers an SDL error "The specified window has not been made current". That, in turn, has to do with how SDL uses the current thread for determing the current window. In general, the page linked to below states that the SDL API is not designed to be used from multiple threads. Reference: https://wiki.libsdl.org/CategoryRender
2018-01-12 13:40:01 +01:00
struct data *d = user_data;
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_buffer *buf;
uint8_t *map;
void *sdata, *ddata;
int sstride, dstride, ostride;
fix some signed vs unsigned comparisons
2018-02-20 18:19:11 +01:00
uint32_t i;
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
uint8_t *src, *dst;
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18:54 +02:00
buf = d->buffers[d->io->buffer_id];
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
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
if (buf->datas[0].type == SPA_DATA_MemFd ||
buf->datas[0].type == SPA_DATA_DmaBuf) {
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
map = mmap(NULL, buf->datas[0].maxsize + buf->datas[0].mapoffset, PROT_READ,
MAP_PRIVATE, buf->datas[0].fd, 0);
spa/buffer: rename SPA_MEMBER to SPA_PTROFF SPA_MEMBER is misleading, all we're doing here is pointer+offset and a type-casting the result. Rename to SPA_PTROFF which is more expressive (and has the same number of characters so we don't need to re-indent).
2021-05-06 13:41:44 +10:00
sdata = SPA_PTROFF(map, buf->datas[0].mapoffset, uint8_t);
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
} else if (buf->datas[0].type == SPA_DATA_MemPtr) {
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
map = NULL;
sdata = buf->datas[0].data;
} else
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EINVAL;
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
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18:54 +02:00
if (SDL_LockTexture(d->texture, NULL, &ddata, &dstride) < 0) {
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
fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError());
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EIO;
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
}
sstride = buf->datas[0].chunk->stride;
ostride = SPA_MIN(sstride, dstride);
src = sdata;
dst = ddata;
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18:54 +02:00
for (i = 0; i < d->format.size.height; i++) {
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
memcpy(dst, src, ostride);
src += sstride;
dst += dstride;
}
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18:54 +02:00
SDL_UnlockTexture(d->texture);
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
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18:54 +02:00
SDL_RenderClear(d->renderer);
SDL_RenderCopy(d->renderer, d->texture, NULL, NULL);
SDL_RenderPresent(d->renderer);
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
if (map)
examples: fix some leaks
2017-08-16 13:32:08 +02:00
munmap(map, buf->datas[0].maxsize + buf->datas[0].mapoffset);
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
SDL examples: all SDL operations in one thread Fix video in SDL examples by invoking rendering in the same thread (pw_loop) that created the window, renderer and texture. At least on some systems, no video is shown without this patch. In those error cases, SDL_RenderPresent triggers an SDL error "The specified window has not been made current". That, in turn, has to do with how SDL uses the current thread for determing the current window. In general, the page linked to below states that the SDL API is not designed to be used from multiple threads. Reference: https://wiki.libsdl.org/CategoryRender
2018-01-12 13:40:01 +01: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 impl_node_process(void *object)
SDL examples: all SDL operations in one thread Fix video in SDL examples by invoking rendering in the same thread (pw_loop) that created the window, renderer and texture. At least on some systems, no video is shown without this patch. In those error cases, SDL_RenderPresent triggers an SDL error "The specified window has not been made current". That, in turn, has to do with how SDL uses the current thread for determing the current window. In general, the page linked to below states that the SDL API is not designed to be used from multiple threads. Reference: https://wiki.libsdl.org/CategoryRender
2018-01-12 13:40:01 +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
struct data *d = object;
SDL examples: all SDL operations in one thread Fix video in SDL examples by invoking rendering in the same thread (pw_loop) that created the window, renderer and texture. At least on some systems, no video is shown without this patch. In those error cases, SDL_RenderPresent triggers an SDL error "The specified window has not been made current". That, in turn, has to do with how SDL uses the current thread for determing the current window. In general, the page linked to below states that the SDL API is not designed to be used from multiple threads. Reference: https://wiki.libsdl.org/CategoryRender
2018-01-12 13:40:01 +01:00
int res;
if ((res = pw_loop_invoke(pw_main_loop_get_loop(d->loop), do_render,
SPA_ID_INVALID, NULL, 0, true, d)) < 0)
return res;
Make structure private Make structs private. Expose methods for things we need. Signals only work on exposed structures so make a new callback helper to signal events.
2017-08-04 10:18:54 +02:00
handle_events(d);
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
rename HAVE/NEED_BUFFER -> HAVE/NEED_DATA It is more generic and works with control-only ports as well
2019-09-16 12:55:23 +02:00
d->io->status = SPA_STATUS_NEED_DATA;
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
rename HAVE/NEED_BUFFER -> HAVE/NEED_DATA It is more generic and works with control-only ports as well
2019-09-16 12:55:23 +02:00
return SPA_STATUS_NEED_DATA;
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
}
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 spa_node_methods impl_node = {
SPA_VERSION_NODE_METHODS,
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
.add_listener = impl_add_listener,
.set_callbacks = impl_set_callbacks,
node: Add port_info event Add a port_info event. With this, we get updates to ports pushed to us, which is more convenient and also allows for better dynamic add/remove of ports. We don't need to the PortChanged event anymore We can remove the get_port_ids/get_n_ports/port_get_info methods. Update plugins
2019-02-14 17:08:46 +01:00
.set_io = impl_set_io,
node: always use a spa_node as the implementation Avoid duplicating API, remove implementations from port and node and always use an spa_node as the implementation, it's just as easy to implement a spa node. With the implementation always being a spa_node we will be able to better implement the negotiation of the mixers.
2017-08-25 18:59:01 +02:00
.send_command = impl_send_command,
.port_set_io = impl_port_set_io,
.port_enum_params = impl_port_enum_params,
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
.port_set_param = impl_port_set_param,
node: always use a spa_node as the implementation Avoid duplicating API, remove implementations from port and node and always use an spa_node as the implementation, it's just as easy to implement a spa node. With the implementation always being a spa_node we will be able to better implement the negotiation of the mixers.
2017-08-25 18:59:01 +02:00
.port_use_buffers = impl_port_use_buffers,
simplify things with just 1 process function Make just one process function in spa node. With the io area states we can do more complicated io patterns.
2018-03-16 16:55:25 +01:00
.process = impl_node_process,
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
};
monitor: return factory_name in the object_info Pass a factory_name in the object_info of monitor and device. Restructure the factory name to mean something functionaly. With the factory to library mapping this then means that the implementation of certain factories can be configured in the config file.
2019-05-31 15:06:44 +02:00
static int make_nodes(struct data *data)
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 pw_properties *props;
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
data->impl_node.iface = SPA_INTERFACE_INIT(
SPA_TYPE_INTERFACE_Node,
SPA_VERSION_NODE,
&impl_node, data);
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
example: fix v4l2 example We need to emit a port param update to notify of new Buffer parameters.
2020-03-19 18:08:34 +01:00
data->info = SPA_PORT_INFO_INIT();
data->info.change_mask =
SPA_PORT_CHANGE_MASK_FLAGS |
SPA_PORT_CHANGE_MASK_PARAMS;
data->info.flags = 0;
data->params[0] = SPA_PARAM_INFO(SPA_PARAM_EnumFormat, SPA_PARAM_INFO_READ);
data->params[1] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
data->params[2] = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
data->params[3] = SPA_PARAM_INFO(SPA_PARAM_Meta, SPA_PARAM_INFO_READ);
data->info.params = data->params;
data->info.n_params = SPA_N_ELEMENTS(data->params);
local-v4l2: fix leaks
2020-06-05 12:16:05 +02:00
data->in = pw_core_export(data->core,
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
SPA_TYPE_INTERFACE_Node,
NULL,
&data->impl_node,
0);
props = pw_properties_new(
SPA_KEY_LIBRARY_NAME, "v4l2/libspa-v4l2",
SPA_KEY_FACTORY_NAME, SPA_NAME_API_V4L2_SOURCE,
NULL);
local-v4l2: fix leaks
2020-06-05 12:16:05 +02:00
data->out = pw_core_create_object(data->core,
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
"spa-node-factory",
PW_TYPE_INTERFACE_Node,
pw_node_proxy -> pw_node
2019-12-11 15:26:11 +01:00
PW_VERSION_NODE,
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
&props->dict, 0);
while (true) {
local-v4l2: fix leaks
2020-06-05 12:16:05 +02:00
if (pw_proxy_get_bound_id(data->out) != SPA_ID_INVALID &&
pw_proxy_get_bound_id(data->in) != SPA_ID_INVALID)
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
break;
pw_loop_iterate(pw_main_loop_get_loop(data->loop), -1);
}
pw_properties_clear(props);
pw_properties_setf(props,
local-v4l2: fix leaks
2020-06-05 12:16:05 +02:00
PW_KEY_LINK_OUTPUT_NODE, "%d", pw_proxy_get_bound_id(data->out));
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
pw_properties_setf(props,
local-v4l2: fix leaks
2020-06-05 12:16:05 +02:00
PW_KEY_LINK_INPUT_NODE, "%d", pw_proxy_get_bound_id(data->in));
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
local-v4l2: fix leaks
2020-06-05 12:16:05 +02:00
data->link = pw_core_create_object(data->core,
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
"link-factory",
PW_TYPE_INTERFACE_Link,
pw_link_proxy -> pw_link
2019-12-11 15:11:56 +01:00
PW_VERSION_LINK,
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
&props->dict, 0);
pw_properties_free(props);
monitor: return factory_name in the object_info Pass a factory_name in the object_info of monitor and device. Restructure the factory name to mean something functionaly. With the factory to library mapping this then means that the implementation of certain factories can be configured in the config file.
2019-05-31 15:06:44 +02:00
return 0;
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
}
int main(int argc, char *argv[])
{
struct data data = { 0, };
pw_init(&argc, &argv);
Add example to play sine wave Various build fixes and cleanups Move port_add to private and make node ports based on implementation. Improve pull based scheduling on remote nodes
2017-09-07 10:22:32 +02:00
data.loop = pw_main_loop_new(NULL);
pw_core -> pw_context The proxy API is the one that we would like to expose for applications and the other API is used internally when implementing modules or factories. The current pw_core object is really a context for all objects so name it that way. It also makes it possible to rename pw_core_proxy to pw_proxy later.
2019-12-10 18:19:56 +01:00
data.context = pw_context_new(
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
pw_main_loop_get_loop(data.loop),
pw_properties_new(
use true and false for boolean properties So that it's easier to convert them to booleans in introspection code later.
2020-03-03 18:17:46 +01:00
PW_KEY_CORE_DAEMON, "false",
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
NULL), 0);
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
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
spa_hook_list_init(&data.hooks);
pw_impl_module_load -> pw_context_load_module
2019-12-11 17:40:32 +01:00
pw_context_load_module(data.context, "libpipewire-module-spa-node-factory", NULL, NULL);
pw_context_load_module(data.context, "libpipewire-module-link-factory", NULL, NULL);
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
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("can't initialize SDL: %s\n", SDL_GetError());
return -1;
}
if (SDL_CreateWindowAndRenderer
(WIDTH, HEIGHT, SDL_WINDOW_RESIZABLE, &data.window, &data.renderer)) {
printf("can't create window: %s\n", SDL_GetError());
return -1;
}
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
data.core = pw_context_connect_self(data.context, NULL, 0);
if (data.core == NULL) {
local-v4l2: implement with core-proxy Implement the local-v4l2 example with a core-proxy connected to a local instance. We can export and instantiate objects and link nodes and ports without having to touch the implementations.
2019-12-10 16:36:53 +01:00
printf("can't connect to core: %m\n");
return -1;
}
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
make_nodes(&data);
Add example to play sine wave Various build fixes and cleanups Move port_add to private and make node ports based on implementation. Improve pull based scheduling on remote nodes
2017-09-07 10:22:32 +02:00
pw_main_loop_run(data.loop);
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
local-v4l2: fix leaks
2020-06-05 12:16:05 +02:00
pw_proxy_destroy(data.link);
pw_proxy_destroy(data.in);
pw_proxy_destroy(data.out);
pw_core -> pw_context The proxy API is the one that we would like to expose for applications and the other API is used internally when implementing modules or factories. The current pw_core object is really a context for all objects so name it that way. It also makes it possible to rename pw_core_proxy to pw_proxy later.
2019-12-10 18:19:56 +01:00
pw_context_destroy(data.context);
Add example to play sine wave Various build fixes and cleanups Move port_add to private and make node ports based on implementation. Improve pull based scheduling on remote nodes
2017-09-07 10:22:32 +02:00
pw_main_loop_destroy(data.loop);
local-v4l2: fix leaks
2020-06-05 12:16:05 +02:00
pw_deinit();
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
return 0;
}
Reference in a new issue Copy permalink