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

1292 lines
32 KiB
C
Raw Normal View History

add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
/* PipeWire
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* Copyright © 2018 Wim Taymans
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
*/
#include <string.h>
#include <stddef.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <sys/socket.h>
#include <sys/mman.h>
#include <sys/eventfd.h>
#include <spa/node/node.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/node/utils.h>
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
#include <spa/buffer/alloc.h>
#include <spa/pod/parser.h>
client-stream: implement enum_param and set_param better Make it possible to enumerate the parameters and get/set properties when available on the adapter.
2018-10-18 12:59:31 +02:00
#include <spa/pod/filter.h>
client-stream: improvements
2018-04-19 22:02:11 +02:00
#include <spa/param/audio/format-utils.h>
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
#include "pipewire/pipewire.h"
#include "pipewire/interfaces.h"
client-stream: Also link controls Improve registration of the node, set the media.class
2018-07-03 21:47:53 +02:00
#include "pipewire/control.h"
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
#include "pipewire/private.h"
#include "modules/spa/spa-node.h"
#include "client-node.h"
#include "client-stream.h"
client-stream: there is always an adapter
2018-10-03 19:27:46 +02:00
#include "pipewire/core.h"
#define NAME "client-stream"
#undef spa_debug
client-stream: run the driver graph
2018-10-02 07:11:45 +02:00
#include <spa/debug/pod.h>
#include <spa/debug/format.h>
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
/** \cond */
struct node {
struct spa_node node;
struct impl *impl;
struct spa_log *log;
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;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
};
struct impl {
struct pw_client_stream this;
struct pw_core *core;
struct node node;
client-stream: add started variable
2018-10-04 15:53:49 +02:00
bool started;
client-stream: just stop feeding the graph in paused Stop feeding the graph in paused instead of going to idle. We might want to idle in the future when we can get the clock resume as well.
2018-10-09 16:34:37 +02:00
bool active;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
struct spa_hook node_listener;
struct spa_hook client_node_listener;
enum spa_direction direction;
struct spa_node *cnode;
struct spa_node *adapter;
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 adapter_listener;
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
struct spa_node *adapter_mix;
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
uint32_t adapter_mix_flags;
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
uint32_t adapter_mix_port;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
client-stream: improvements
2018-04-19 22:02:11 +02:00
bool use_converter;
client-stream: Also link controls Improve registration of the node, set the media.class
2018-07-03 21:47:53 +02:00
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
struct pw_client_node *client_node;
struct pw_port *client_port;
struct pw_port_mix client_port_mix;
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
struct spa_io_buffers *io;
Implement control streams spa_io_control_range -> spa_io_range Add helpers for sequence and control pod objects Implement control properties in audiotestsrc, update test example.
2018-08-28 18:16:41 +02:00
struct spa_io_range range;
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
struct spa_buffer **buffers;
uint32_t n_buffers;
struct pw_memblock *mem;
};
/** \endcond */
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
static int impl_node_enum_params(struct spa_node *node, int seq,
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)
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
{
client-stream: enum_params works to the client node
2018-10-04 16:32:42 +02:00
struct node *this;
struct impl *impl;
client-stream: implement enum_param and set_param better Make it possible to enumerate the parameters and get/set properties when available on the adapter.
2018-10-18 12:59:31 +02: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;
int res;
client-stream: enum_params works to the client node
2018-10-04 16:32:42 +02:00
spa_return_val_if_fail(node != NULL, -EINVAL);
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_return_val_if_fail(num != 0, -EINVAL);
client-stream: enum_params works to the client node
2018-10-04 16:32:42 +02:00
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
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;
client-stream: implement enum_param and set_param better Make it possible to enumerate the parameters and get/set properties when available on the adapter.
2018-10-18 12:59:31 +02:00
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++;
client-stream: implement enum_param and set_param better Make it possible to enumerate the parameters and get/set properties when available on the adapter.
2018-10-18 12:59:31 +02:00
spa_pod_builder_init(&b, buffer, sizeof(buffer));
switch (id) {
case SPA_PARAM_Props:
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 (impl->adapter == impl->cnode)
return 0;
if ((res = spa_node_enum_params_sync(impl->adapter,
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
id, &start, filter, &param, &b)) != 1)
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
return res;
break;
client-stream: implement enum_param and set_param better Make it possible to enumerate the parameters and get/set properties when available on the adapter.
2018-10-18 12:59:31 +02:00
case SPA_PARAM_EnumFormat:
case SPA_PARAM_Format:
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 ((res = spa_node_port_enum_params_sync(impl->cnode,
client-stream: enum_params works to the client node
2018-10-04 16:32:42 +02:00
impl->direction, 0,
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
id, &start, filter, &param, &b)) != 1)
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
return res;
break;
client-stream: implement enum_param and set_param better Make it possible to enumerate the parameters and get/set properties when available on the adapter.
2018-10-18 12:59:31 +02:00
default:
return -ENOENT;
}
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)
client-stream: implement enum_param and set_param better Make it possible to enumerate the parameters and get/set properties when available on the adapter.
2018-10-18 12:59:31 +02:00
goto next;
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_node_emit_result(&this->hooks, seq, 0, &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;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
client-stream: link controls after profile was set
2018-10-08 18:19:59 +02:00
static void try_link_controls(struct impl *impl)
{
struct pw_control *cin, *cout;
struct pw_port *target, *port;
int res;
if (!impl->use_converter)
return;
target = pw_node_find_port(impl->this.node, impl->direction, 0);
if (target == NULL) {
pw_log_warn("client-stream %p: can't link controls", &impl->this);
return;
}
port = impl->client_port;
pw_log_debug(NAME " %p: trying controls", impl);
spa_list_for_each(cout, &port->control_list[SPA_DIRECTION_OUTPUT], port_link) {
spa_list_for_each(cin, &target->control_list[SPA_DIRECTION_INPUT], port_link) {
if ((res = pw_control_link(cout, cin)) < 0)
pw_log_error("failed to link controls: %s", spa_strerror(res));
}
}
spa_list_for_each(cin, &port->control_list[SPA_DIRECTION_INPUT], port_link) {
spa_list_for_each(cout, &target->control_list[SPA_DIRECTION_OUTPUT], port_link) {
if ((res = pw_control_link(cout, cin)) < 0)
pw_log_error("failed to link controls: %s", spa_strerror(res));
}
}
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flags,
const struct spa_pod *param)
{
spa: add profile param Make a profile param that can be used to configure a node with a certain profile. Use the profile to configure the ports on splitter and merger and get rid of the dynamic ports. Use the profile to configure the client-node and audio-dsp. Don't try to link more ports than available between client-node and dsp.
2018-10-08 11:45:52 +02:00
int res = 0;
struct node *this;
struct impl *impl;
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
switch (id) {
case SPA_PARAM_Profile:
if (impl->started)
return -EIO;
link: handle the right port in the callback
2019-02-21 10:30:40 +01:00
pw_log_debug("set profile %d", id);
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
if (impl->adapter && impl->adapter != impl->cnode) {
improve debug and error handling
2018-10-17 10:02:44 +02:00
if ((res = spa_node_set_param(impl->adapter, id, flags, param)) < 0)
return res;
spa: add profile param Make a profile param that can be used to configure a node with a certain profile. Use the profile to configure the ports on splitter and merger and get rid of the dynamic ports. Use the profile to configure the client-node and audio-dsp. Don't try to link more ports than available between client-node and dsp.
2018-10-08 11:45:52 +02:00
client-stream: link controls after profile was set
2018-10-08 18:19:59 +02:00
try_link_controls(impl);
spa: add profile param Make a profile param that can be used to configure a node with a certain profile. Use the profile to configure the ports on splitter and merger and get rid of the dynamic ports. Use the profile to configure the client-node and audio-dsp. Don't try to link more ports than available between client-node and dsp.
2018-10-08 11:45:52 +02:00
}
break;
client-stream: implement enum_param and set_param better Make it possible to enumerate the parameters and get/set properties when available on the adapter.
2018-10-18 12:59:31 +02:00
case SPA_PARAM_Props:
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
if (impl->adapter && impl->adapter != impl->cnode) {
client-stream: implement enum_param and set_param better Make it possible to enumerate the parameters and get/set properties when available on the adapter.
2018-10-18 12:59:31 +02:00
if ((res = spa_node_set_param(impl->adapter, id, flags, param)) < 0)
return res;
}
break;
spa: add profile param Make a profile param that can be used to configure a node with a certain profile. Use the profile to configure the ports on splitter and merger and get rid of the dynamic ports. Use the profile to configure the client-node and audio-dsp. Don't try to link more ports than available between client-node and dsp.
2018-10-08 11:45:52 +02:00
default:
res = -ENOTSUP;
break;
}
return res;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
add node set_io function Also allow setting io areas on nodes. We need this to set the graph clock and period size on the nodes.
2018-10-23 12:31:41 +02:00
static int impl_node_set_io(struct spa_node *node, uint32_t id, void *data, size_t size)
{
node: allocate shared mem for activation Allocate a per node a piece of shared memory where we place the activation structure with the graph state and io_position. We can then give this info to nodes so that they can get the position in the graph directly but also later, activate the next node in the graph.
2019-02-07 12:34:54 +01:00
struct node *this;
struct impl *impl;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
return spa_node_set_io(impl->cnode, id, data, size);
add node set_io function Also allow setting io areas on nodes. We need this to set the graph clock and period size on the nodes.
2018-10-23 12:31:41 +02:00
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
static int impl_node_send_command(struct spa_node *node, const struct spa_command *command)
{
struct node *this;
struct impl *impl;
int res;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
client-stream: add started variable
2018-10-04 15:53:49 +02:00
switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_NODE_COMMAND_Start:
impl->started = true;
break;
case SPA_NODE_COMMAND_Pause:
impl->started = false;
break;
default:
break;
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
if ((res = spa_node_send_command(impl->adapter, command)) < 0)
return res;
client-stream: improve debug
2018-06-15 11:29:38 +02:00
if (impl->adapter != impl->cnode) {
if ((res = spa_node_send_command(impl->cnode, command)) < 0)
return res;
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return res;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void adapter_port_info(void *data,
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
enum spa_direction direction, uint32_t port_id,
const struct spa_port_info *info)
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
{
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
struct impl *impl = data;
struct node *this = &impl->node;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +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
if (direction == impl->direction)
spa_node_emit_port_info(&this->hooks, direction, port_id, info);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
interfaces: make events return void Events are dispatched with hooks and have no return value. Make it possible to get the last resource and proxy sender value for where we need it.
2019-03-01 14:04:05 +01:00
static void adapter_result(void *data, int seq, int res, const void *result)
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 impl *impl = data;
struct node *this = &impl->node;
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
pw_log_debug("%p: result %d %d", this, seq, res);
spa_node_emit_result(&this->hooks, seq, res, result);
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
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +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
static const struct spa_node_events adapter_node_events = {
SPA_VERSION_NODE_EVENTS,
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
.port_info = adapter_port_info,
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 = adapter_result,
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
};
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
static void emit_node_info(struct node *this)
{
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_node_info info;
struct spa_param_info params[4];
info = SPA_NODE_INFO_INIT();
info.max_input_ports = 0;
info.max_output_ports = 0;
info.change_mask |= SPA_NODE_CHANGE_MASK_PARAMS;
params[0] = SPA_PARAM_INFO(SPA_PARAM_EnumFormat, SPA_PARAM_INFO_READ);
params[1] = SPA_PARAM_INFO(SPA_PARAM_Props, SPA_PARAM_INFO_READWRITE);
params[2] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_READ);
params[3] = SPA_PARAM_INFO(SPA_PARAM_Profile, SPA_PARAM_INFO_WRITE);
info.params = params;
info.n_params = 4;
spa_node_emit_info(&this->hooks, &info);
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
}
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
static int impl_node_add_listener(struct spa_node *node,
struct spa_hook *listener,
const struct spa_node_events *events,
void *data)
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
{
struct node *this;
struct impl *impl;
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 l;
struct spa_hook_list save;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
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
pw_log_debug("%p: add listener %p", this, listener);
spa_hook_list_isolate(&this->hooks, &save, listener, events, data);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
emit_node_info(this);
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
if (impl->adapter && impl->adapter != impl->cnode) {
spa_zero(l);
spa_node_add_listener(impl->adapter, &l, &adapter_node_events, impl);
spa_hook_remove(&l);
}
spa_hook_list_join(&this->hooks, &save);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +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
return spa_node_sync(impl->cnode, 0);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +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
static int
impl_node_set_callbacks(struct spa_node *node,
const struct spa_node_callbacks *callbacks,
void *data)
{
return 0;
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int
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
impl_node_sync(struct spa_node *node, int seq)
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
{
struct node *this;
struct impl *impl;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
return spa_node_sync(impl->cnode, seq);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
static int
node: add props to add_port
2019-02-18 13:22:46 +01:00
impl_node_add_port(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
const struct spa_dict *props)
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
{
struct node *this;
struct impl *impl;
node: add driver position struct Pass driver info to client use current buffersize and samplerate in client update the buffer size dynamically based on session
2018-05-11 10:13:37 +02:00
int res;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
if (direction != impl->direction)
return -EINVAL;
node: add props to add_port
2019-02-18 13:22:46 +01:00
if ((res = spa_node_add_port(impl->adapter_mix, direction, port_id, props)) < 0)
node: add driver position struct Pass driver info to client use current buffersize and samplerate in client update the buffer size dynamically based on session
2018-05-11 10:13:37 +02:00
return res;
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
if ((res = spa_node_port_set_io(impl->adapter_mix,
node: add driver position struct Pass driver info to client use current buffersize and samplerate in client update the buffer size dynamically based on session
2018-05-11 10:13:37 +02:00
direction, port_id,
Implement control streams spa_io_control_range -> spa_io_range Add helpers for sequence and control pod objects Implement control properties in audiotestsrc, update test example.
2018-08-28 18:16:41 +02:00
SPA_IO_Range,
&impl->range,
sizeof(&impl->range))) < 0)
node: add driver position struct Pass driver info to client use current buffersize and samplerate in client update the buffer size dynamically based on session
2018-05-11 10:13:37 +02:00
return res;
return res;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
static int
impl_node_remove_port(struct spa_node *node, enum spa_direction direction, uint32_t port_id)
{
struct node *this;
struct impl *impl;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
if (direction != this->impl->direction)
return -EINVAL;
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
return spa_node_remove_port(impl->adapter_mix, direction, port_id);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
static int
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
impl_node_port_enum_params(struct spa_node *node, int seq,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02: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)
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
{
struct node *this;
struct impl *impl;
spa_return_val_if_fail(node != NULL, -EINVAL);
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_return_val_if_fail(num != 0, -EINVAL);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
if (direction != impl->direction)
return -EINVAL;
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
pw_log_debug("%p: %d %u", this, seq, id);
return spa_node_port_enum_params(impl->adapter, seq, direction, port_id, id,
start, num, filter);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
client-stream: improve debug
2018-06-15 11:29:38 +02:00
static int debug_params(struct impl *impl, struct spa_node *node,
enum spa_direction direction, uint32_t port_id, uint32_t id, struct spa_pod *filter)
{
struct node *this = &impl->node;
struct spa_pod_builder b = { 0 };
uint8_t buffer[4096];
remove spalib
2018-08-14 12:33:53 +02:00
uint32_t state;
struct spa_pod *param;
client-stream: improve debug
2018-06-15 11:29:38 +02:00
int res;
debug: allow custom type root
2018-08-30 12:01:52 +02:00
spa_log_error(this->log, "params %s:", spa_debug_type_find_name(spa_type_param, id));
client-stream: improve debug
2018-06-15 11:29:38 +02:00
state = 0;
while (true) {
spa_pod_builder_init(&b, buffer, sizeof(buffer));
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
res = spa_node_port_enum_params_sync(node,
client-stream: improve debug
2018-06-15 11:29:38 +02:00
direction, port_id,
id, &state,
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
NULL, &param, &b);
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
if (res != 1) {
client-stream: trigger client-node manually Don't let the graph scheduler trigger the client-node, instead do it ourselves when the need a buffer for the next quantum.
2018-06-22 17:37:21 +02:00
if (res < 0)
spa_log_error(this->log, " error: %s", spa_strerror(res));
client-stream: improve debug
2018-06-15 11:29:38 +02:00
break;
client-stream: trigger client-node manually Don't let the graph scheduler trigger the client-node, instead do it ourselves when the need a buffer for the next quantum.
2018-06-22 17:37:21 +02:00
}
debug: allow custom type root
2018-08-30 12:01:52 +02:00
spa_debug_pod(2, NULL, param);
client-stream: improve debug
2018-06-15 11:29:38 +02:00
}
spa_log_error(this->log, "failed filter:");
if (filter)
debug: allow custom type root
2018-08-30 12:01:52 +02:00
spa_debug_pod(2, NULL, filter);
client-stream: improve debug
2018-06-15 11:29:38 +02:00
return 0;
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
static int negotiate_format(struct impl *impl)
{
struct node *this = &impl->node;
uint32_t state;
struct spa_pod *format;
uint8_t buffer[4096];
struct spa_pod_builder b = { 0 };
int res;
spa_pod_builder_init(&b, buffer, sizeof(buffer));
client-stream: there is always an adapter
2018-10-03 19:27:46 +02:00
spa_log_debug(this->log, NAME "%p: negiotiate", impl);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
state = 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
if ((res = spa_node_port_enum_params_sync(impl->adapter_mix,
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
SPA_DIRECTION_REVERSE(impl->direction),
impl->adapter_mix_port,
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
SPA_PARAM_EnumFormat, &state,
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
NULL, &format, &b)) != 1) {
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
debug_params(impl, impl->adapter_mix,
SPA_DIRECTION_REVERSE(impl->direction),
impl->adapter_mix_port,
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
SPA_PARAM_EnumFormat, NULL);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
return -ENOTSUP;
client-stream: improve debug
2018-06-15 11:29:38 +02:00
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
state = 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
if ((res = spa_node_port_enum_params_sync(impl->cnode,
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
impl->direction, 0,
SPA_PARAM_EnumFormat, &state,
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
format, &format, &b)) != 1) {
client-stream: fix format and buffers for capture
2018-06-22 17:36:26 +02:00
debug_params(impl, impl->cnode, impl->direction, 0,
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
SPA_PARAM_EnumFormat, format);
client-stream: improve debug
2018-06-15 11:29:38 +02:00
return -ENOTSUP;
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
spa_pod_fixate(format);
improve some debug
2018-09-24 09:32:27 +02:00
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_format(0, NULL, format);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
if ((res = spa_node_port_set_param(impl->adapter_mix,
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
SPA_DIRECTION_REVERSE(impl->direction),
impl->adapter_mix_port,
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
SPA_PARAM_Format, 0,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
format)) < 0)
return res;
if ((res = spa_node_port_set_param(impl->cnode,
client-stream: fix format and buffers for capture
2018-06-22 17:36:26 +02:00
impl->direction, 0,
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
SPA_PARAM_Format, 0,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
format)) < 0)
return res;
return res;
}
static int negotiate_buffers(struct impl *impl)
{
struct node *this = &impl->node;
uint8_t buffer[4096];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
uint32_t state;
struct spa_pod *param = NULL;
int res, i;
bool in_alloc, out_alloc;
int32_t size, buffers, blocks, align, flags;
alloc: improve alignment in alloactor link: use buffer allocator Add more tests
2019-01-25 13:28:56 +01:00
uint32_t *aligns;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
struct spa_data *datas;
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
uint32_t in_flags, out_flags;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
struct spa_buffer_alloc_info info = { 0, };
void *skel;
small cleanups
2018-05-10 11:23:51 +02:00
spa_log_debug(this->log, "%p: %d", impl, impl->n_buffers);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
if (impl->n_buffers > 0)
return 0;
state = 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
if ((res = spa_node_port_enum_params_sync(impl->adapter_mix,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
SPA_DIRECTION_REVERSE(impl->direction),
impl->adapter_mix_port,
SPA_PARAM_Buffers, &state,
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
param, &param, &b)) != 1) {
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
debug_params(impl, impl->adapter_mix,
SPA_DIRECTION_REVERSE(impl->direction),
impl->adapter_mix_port,
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
SPA_PARAM_Buffers, param);
client-stream: prefer client buffer params
2018-06-26 16:54:48 +02:00
return -ENOTSUP;
client-stream: improve debug
2018-06-15 11:29:38 +02: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 (res != 1)
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
param = NULL;
state = 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
if ((res = spa_node_port_enum_params_sync(impl->cnode,
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
impl->direction, 0,
SPA_PARAM_Buffers, &state,
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
param, &param, &b)) < 0) {
client-stream: prefer client buffer params
2018-06-26 16:54:48 +02:00
debug_params(impl, impl->cnode, impl->direction, 0,
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
SPA_PARAM_Buffers, param);
client-stream: prefer client buffer params
2018-06-26 16:54:48 +02:00
return res;
client-stream: improve debug
2018-06-15 11:29:38 +02:00
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
spa_pod_fixate(param);
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
in_flags = impl->client_port->spa_flags;
out_flags = impl->adapter_mix_flags;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
node: add max_ports to node info
2019-02-14 17:40:01 +01:00
in_alloc = SPA_FLAG_CHECK(in_flags, SPA_PORT_FLAG_CAN_ALLOC_BUFFERS);
out_alloc = SPA_FLAG_CHECK(out_flags, SPA_PORT_FLAG_CAN_ALLOC_BUFFERS);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
flags = 0;
if (out_alloc || in_alloc) {
flags |= SPA_BUFFER_ALLOC_FLAG_NO_DATA;
if (out_alloc)
in_alloc = false;
}
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
if (spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamBuffers, NULL,
SPA_PARAM_BUFFERS_buffers, SPA_POD_Int(&buffers),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(&blocks),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(&size),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(&align)) < 0)
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
return -EINVAL;
client-stream: improve debug
2018-06-15 11:29:38 +02:00
spa_log_debug(this->log, "%p: buffers %d, blocks %d, size %d, align %d",
impl, buffers, blocks, size, align);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
datas = alloca(sizeof(struct spa_data) * blocks);
memset(datas, 0, sizeof(struct spa_data) * blocks);
aligns = alloca(sizeof(uint32_t) * blocks);
for (i = 0; i < blocks; i++) {
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
datas[i].type = SPA_DATA_MemPtr;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
datas[i].maxsize = size;
aligns[i] = align;
}
spa_buffer_alloc_fill_info(&info, 0, NULL, blocks, datas, aligns);
free() can handle NULL just fine so skip the check Fixes #117
2018-12-19 17:47:25 +01:00
free(impl->buffers);
client-stream: allocate the right number of buffers
2018-06-15 11:30:20 +02:00
impl->buffers = calloc(buffers, sizeof(struct spa_buffer *) + info.skel_size);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
if (impl->buffers == NULL)
return -ENOMEM;
client-stream: allocate the right number of buffers
2018-06-15 11:30:20 +02:00
skel = SPA_MEMBER(impl->buffers, sizeof(struct spa_buffer *) * buffers, void);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
pipewire: improve memory cleanup Add method to unload a spa interface. Various other memory cleanups
2018-04-20 16:27:19 +02:00
if (impl->mem) {
pw_memblock_free(impl->mem);
impl->mem = NULL;
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
if ((res = pw_memblock_alloc(PW_MEMBLOCK_FLAG_WITH_FD |
PW_MEMBLOCK_FLAG_MAP_READWRITE |
alloc: improve alignment in alloactor link: use buffer allocator Add more tests
2019-01-25 13:28:56 +01:00
PW_MEMBLOCK_FLAG_SEAL, buffers * info.mem_size,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
&impl->mem)) < 0)
return res;
client-stream: allocate the right number of buffers
2018-06-15 11:30:20 +02:00
impl->n_buffers = buffers;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
spa_buffer_alloc_layout_array(&info, impl->n_buffers, impl->buffers,
skel, impl->mem->ptr);
if (in_alloc) {
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
if ((res = spa_node_port_alloc_buffers(impl->adapter_mix,
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
SPA_DIRECTION_REVERSE(impl->direction),
impl->adapter_mix_port,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
NULL, 0,
impl->buffers, &impl->n_buffers)) < 0)
return res;
}
else {
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
if ((res = spa_node_port_use_buffers(impl->adapter_mix,
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
SPA_DIRECTION_REVERSE(impl->direction),
impl->adapter_mix_port,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
impl->buffers, impl->n_buffers)) < 0)
return res;
}
if (out_alloc) {
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
if ((res = spa_node_port_alloc_buffers(impl->client_port->mix,
client-stream: fix format and buffers for capture
2018-06-22 17:36:26 +02:00
impl->direction, 0,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
NULL, 0,
impl->buffers, &impl->n_buffers)) < 0)
return res;
}
else {
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
if ((res = spa_node_port_use_buffers(impl->client_port->mix,
client-stream: fix format and buffers for capture
2018-06-22 17:36:26 +02:00
impl->direction, 0,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
impl->buffers, impl->n_buffers)) < 0)
return res;
}
return 0;
}
static int
impl_node_port_set_param(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t flags,
const struct spa_pod *param)
{
struct node *this;
struct impl *impl;
int res;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
if (direction != impl->direction)
return -EINVAL;
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
if ((res = spa_node_port_set_param(impl->adapter_mix, direction, port_id, id,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
flags, param)) < 0)
return res;
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 && impl->use_converter) {
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
if (param == NULL) {
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
if ((res = spa_node_port_set_param(impl->adapter_mix,
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
SPA_DIRECTION_REVERSE(direction),
impl->adapter_mix_port,
id, 0, NULL)) < 0)
client-stream: reset format on adapter
2018-05-17 17:38:13 +02:00
return res;
impl->n_buffers = 0;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
else {
if (port_id == 0)
res = negotiate_format(impl);
}
}
return res;
}
static int
impl_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *data, size_t size)
{
struct node *this;
struct impl *impl;
client-node: fix port implementation Make the port forward the port methods to the node. Fix io area when not using adapter
2018-07-31 14:28:15 +02:00
int res = 0;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
spa_log_debug(this->log, "set io %d %d %d %d", port_id, id, direction, impl->direction);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
if (impl->use_converter) {
if (direction != impl->direction && id != SPA_IO_Control)
return -EINVAL;
client-node: fix port implementation Make the port forward the port methods to the node. Fix io area when not using adapter
2018-07-31 14:28:15 +02:00
res = spa_node_port_set_io(impl->adapter_mix, direction, port_id, id, data, size);
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
}
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
else {
if (direction != impl->direction)
return -EINVAL;
if (id == SPA_IO_Buffers && size >= sizeof(struct spa_io_buffers))
impl->io = data;
}
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
return res;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
static int
impl_node_port_use_buffers(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_buffer **buffers,
uint32_t n_buffers)
{
struct node *this;
struct impl *impl;
int res;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
if (direction != impl->direction)
return -EINVAL;
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
if ((res = spa_node_port_use_buffers(impl->adapter_mix,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
direction, port_id, buffers, n_buffers)) < 0)
return res;
small cleanups
2018-05-10 11:23:51 +02:00
spa_log_debug(this->log, "%p: %d %d", impl, n_buffers, port_id);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
client-stream: improvements
2018-04-19 22:02:11 +02:00
if (n_buffers > 0 && impl->use_converter) {
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
if (port_id == 0)
res = negotiate_buffers(impl);
}
return res;
}
static int
impl_node_port_alloc_buffers(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_pod **params,
uint32_t n_params,
struct spa_buffer **buffers,
uint32_t *n_buffers)
{
struct node *this;
struct impl *impl;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
if (direction != impl->direction)
return -EINVAL;
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
return spa_node_port_alloc_buffers(impl->adapter_mix, direction, port_id,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
params, n_params, buffers, n_buffers);
}
static int
impl_node_port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32_t buffer_id)
{
struct node *this;
struct impl *impl;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct node, node);
impl = this->impl;
return spa_node_port_reuse_buffer(impl->adapter, port_id, buffer_id);
}
static int impl_node_process(struct spa_node *node)
{
struct node *this = SPA_CONTAINER_OF(node, struct node, node);
struct impl *impl = this->impl;
client-node: use spa_io_position Remove old internal structure
2018-10-24 10:33:52 +02:00
struct spa_io_position *q = impl->this.node->driver_node->rt.position;
client-stream: improve scheduling
2018-07-02 12:06:22 +02:00
int status, trigger;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
client-stream: just stop feeding the graph in paused Stop feeding the graph in paused instead of going to idle. We might want to idle in the future when we can get the clock resume as well.
2018-10-09 16:34:37 +02:00
if (!impl->active)
return SPA_STATUS_HAVE_BUFFER;
Implement control streams spa_io_control_range -> spa_io_range Add helpers for sequence and control pod objects Implement control properties in audiotestsrc, update test example.
2018-08-28 18:16:41 +02:00
impl->range.min_size = impl->range.max_size = q->size * sizeof(float);
node: add driver position struct Pass driver info to client use current buffersize and samplerate in client update the buffer size dynamically based on session
2018-05-11 10:13:37 +02:00
Implement control streams spa_io_control_range -> spa_io_range Add helpers for sequence and control pod objects Implement control properties in audiotestsrc, update test example.
2018-08-28 18:16:41 +02:00
spa_log_trace(this->log, "%p: process %d", this, impl->range.max_size);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
node: add driver position struct Pass driver info to client use current buffersize and samplerate in client update the buffer size dynamically based on session
2018-05-11 10:13:37 +02:00
if (impl->use_converter) {
client-stream: improvements
2018-04-19 22:02:11 +02:00
status = spa_node_process(impl->adapter);
client-stream: improve scheduling
2018-07-02 12:06:22 +02:00
}
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
else {
client-stream: swap local and remote io area
2018-06-25 14:33:00 +02:00
struct spa_io_buffers tmp;
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
spa_log_trace(this->log, "%p: process %d/%d %d/%d", this,
impl->io->status, impl->io->buffer_id,
impl->client_port_mix.io->status,
impl->client_port_mix.io->buffer_id);
client-stream: improvements
2018-04-19 22:02:11 +02:00
client-stream: swap local and remote io area
2018-06-25 14:33:00 +02:00
tmp = *impl->io;
*impl->io = *impl->client_port_mix.io;
*impl->client_port_mix.io = tmp;
client-stream: trigger client-node manually Don't let the graph scheduler trigger the client-node, instead do it ourselves when the need a buffer for the next quantum.
2018-06-22 17:37:21 +02:00
client-stream: improve scheduling
2018-07-02 12:06:22 +02:00
status = impl->client_port_mix.io->status | impl->io->status;
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
}
client-stream: improvements
2018-04-19 22:02:11 +02:00
spa_log_trace(this->log, "%p: process %d", this, status);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
client-stream: improve scheduling
2018-07-02 12:06:22 +02:00
if (impl->direction == SPA_DIRECTION_OUTPUT) {
if (!(status & SPA_STATUS_HAVE_BUFFER))
spa_log_warn(this->log, "%p: process underrun", this);
trigger = status & SPA_STATUS_NEED_BUFFER;
}
else
trigger = status & SPA_STATUS_HAVE_BUFFER;
client-stream: don't run the driver The driver will take the initiative to run the graph
2018-07-11 20:09:32 +02:00
if (trigger && !impl->this.node->driver)
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
spa_graph_node_process(&impl->client_node->node->rt.root);
client-node: make it possible to skip signal Add an option to not signal the remote implementation when we still have enough data.
2018-04-26 09:49:29 +02:00
client-stream: improvements
2018-04-19 22:02:11 +02:00
return status;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
static const struct spa_node impl_node = {
SPA_VERSION_NODE,
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_node_add_listener,
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
.set_callbacks = impl_node_set_callbacks,
.sync = impl_node_sync,
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
.enum_params = impl_node_enum_params,
.set_param = impl_node_set_param,
.set_io = impl_node_set_io,
.send_command = impl_node_send_command,
.add_port = impl_node_add_port,
.remove_port = impl_node_remove_port,
.port_enum_params = impl_node_port_enum_params,
.port_set_param = impl_node_port_set_param,
.port_use_buffers = impl_node_port_use_buffers,
.port_alloc_buffers = impl_node_port_alloc_buffers,
.port_set_io = impl_node_port_set_io,
.port_reuse_buffer = impl_node_port_reuse_buffer,
.process = impl_node_process,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
};
static int
node_init(struct node *this,
struct spa_dict *info,
const struct spa_support *support,
uint32_t n_support)
{
uint32_t i;
for (i = 0; i < n_support; i++) {
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
if (support[i].type == SPA_TYPE_INTERFACE_Log)
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
this->log = support[i].data;
}
this->node = impl_node;
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(&this->hooks);
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;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
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
static int do_port_info(void *data, struct pw_port *port)
{
struct impl *impl = data;
struct node *node = &impl->node;
struct spa_port_info info;
info = SPA_PORT_INFO_INIT();
info.change_mask = SPA_PORT_CHANGE_MASK_FLAGS | SPA_PORT_CHANGE_MASK_PROPS;
info.flags = port->spa_flags;
info.props = &port->properties->dict;
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_node_emit_port_info(&node->hooks,
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
impl->direction, port->port_id, &info);
return 0;
}
static void emit_port_info(struct impl *impl)
{
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
pw_node_for_each_port(impl->client_node->node,
impl->direction,
do_port_info, impl);
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
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
static void client_node_initialized(void *data)
{
struct impl *impl = data;
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
uint32_t state;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
uint32_t media_type, media_subtype;
struct spa_pod *format;
uint8_t buffer[4096];
struct spa_pod_builder b;
int res;
stream: add exclusive flag With the exclusive flag we don't go through the audio-dsp.
2018-05-08 10:47:18 +02:00
const struct pw_properties *props;
client-stream: Also link controls Improve registration of the node, set the media.class
2018-07-03 21:47:53 +02:00
const char *str, *dir, *type;
char media_class[64];
client-stream: activate peaks resampler when monitoring
2018-12-05 16:00:52 +01:00
bool exclusive, monitor;
client-stream: add media.class on node Add the media.class property on the node as well.
2018-10-18 12:56:10 +02:00
struct spa_dict_item items[1];
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
const struct pw_node_info *info;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
pw_log_debug("client-stream %p: initialized", &impl->this);
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
info = pw_node_get_info(impl->client_node->node);
if (info == NULL)
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
return;
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
if (info->n_output_ports == 0) {
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
impl->direction = SPA_DIRECTION_INPUT;
client-stream: Also link controls Improve registration of the node, set the media.class
2018-07-03 21:47:53 +02:00
dir = "Input";
}
else {
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
impl->direction = SPA_DIRECTION_OUTPUT;
client-stream: Also link controls Improve registration of the node, set the media.class
2018-07-03 21:47:53 +02:00
dir = "Output";
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
pw_log_debug("client-stream %p: in %d/%d out %d/%d -> %s", &impl->this,
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
info->n_input_ports, info->max_input_ports,
info->n_output_ports, info->max_output_ports,
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
dir);
client-stream: fix capture case Setup the processing order differently for capture, we first want to schedule the converters and then the client-node.
2018-06-18 12:24:20 +02:00
props = pw_node_get_properties(impl->client_node->node);
if (props != NULL && (str = pw_properties_get(props, PW_NODE_PROP_EXCLUSIVE)) != NULL)
exclusive = pw_properties_parse_bool(str);
else
exclusive = false;
client-stream: activate peaks resampler when monitoring
2018-12-05 16:00:52 +01:00
if (props != NULL && (str = pw_properties_get(props, "pipewire.monitor")) != NULL)
monitor = pw_properties_parse_bool(str);
else
monitor = false;
client-stream: fix capture case Setup the processing order differently for capture, we first want to schedule the converters and then the client-node.
2018-06-18 12:24:20 +02:00
remote-node: handle driver nodes
2019-03-04 17:55:43 +01:00
impl->client_node->node->driver_node = impl->this.node;
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
impl->client_port = pw_node_find_port(impl->client_node->node, impl->direction, 0);
if (impl->client_port == NULL)
return;
if ((res = pw_port_init_mix(impl->client_port, &impl->client_port_mix)) < 0)
return;
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
if ((res = spa_node_port_set_io(impl->client_port->mix,
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
impl->direction, 0,
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
SPA_IO_Buffers,
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
impl->client_port_mix.io,
sizeof(impl->client_port_mix.io))) < 0)
return;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
state = 0;
spa_pod_builder_init(&b, buffer, sizeof(buffer));
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 ((res = spa_node_port_enum_params_sync(impl->cnode,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
impl->direction, 0,
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
SPA_PARAM_EnumFormat, &state,
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
NULL, &format, &b)) != 1) {
client-node: small cleanups
2018-06-01 11:19:22 +02:00
pw_log_warn("client-stream %p: no format given", &impl->this);
impl->adapter = impl->cnode;
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
impl->adapter_mix = impl->client_port->mix;
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
impl->adapter_mix_port = 0;
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
impl->adapter_mix_flags = impl->client_port->spa_flags;
client-node: small cleanups
2018-06-01 11:19:22 +02:00
impl->use_converter = false;
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
emit_port_info(impl);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
return;
client-node: small cleanups
2018-06-01 11:19:22 +02:00
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
format: make helper function to parse media type
2018-08-29 14:50:58 +02:00
if (spa_format_parse(format, &media_type, &media_subtype) < 0)
return;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
pw_log_debug("client-stream %p: %s/%s", &impl->this,
debug: allow custom type root
2018-08-30 12:01:52 +02:00
spa_debug_type_find_name(spa_type_media_type, media_type),
spa_debug_type_find_name(spa_type_media_subtype, media_subtype));
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
audio: remove layout from audio Make special format types for planar and interleaved instead of having a field. Add enum for audio channel positions Add some default audio channel layouts Place the channel layout in the audio format when possible alsa: place audio channel positions in format Add sse optimized channel mixing for some common cases Remove name from port info, it's not mandatory and in the properties Add direction to port info
2018-09-13 17:03:56 +02:00
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_format(2, NULL, format);
stream: add exclusive flag With the exclusive flag we don't go through the audio-dsp.
2018-05-08 10:47:18 +02:00
if (!exclusive &&
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
media_type == SPA_MEDIA_TYPE_audio &&
media_subtype == SPA_MEDIA_SUBTYPE_raw) {
client-stream: activate peaks resampler when monitoring
2018-12-05 16:00:52 +01:00
struct spa_dict_item items[2];
audioconvert: use splitter/merger Remove the split/merge functionality from fmtconvert. Make audioconvert use the splitter/merger. Let client-stream decide what mode to configure audioconvert in.
2018-10-04 15:56:54 +02:00
const char *mode;
if (impl->direction == SPA_DIRECTION_OUTPUT)
mode = "split";
else
mode = "merge";
items[0] = SPA_DICT_ITEM_INIT("factory.mode", mode);
client-stream: activate peaks resampler when monitoring
2018-12-05 16:00:52 +01:00
items[1] = SPA_DICT_ITEM_INIT("resample.peaks", monitor ? "1" : "0");
audioconvert: use splitter/merger Remove the split/merge functionality from fmtconvert. Make audioconvert use the splitter/merger. Let client-stream decide what mode to configure audioconvert in.
2018-10-04 15:56:54 +02:00
client-stream: improvements
2018-04-19 22:02:11 +02:00
if ((impl->adapter = pw_load_spa_interface("audioconvert/libspa-audioconvert",
client-stream: activate peaks resampler when monitoring
2018-12-05 16:00:52 +01:00
"audioconvert",
SPA_TYPE_INTERFACE_Node,
&SPA_DICT_INIT(items, 2),
0, NULL)) == NULL)
client-stream: improvements
2018-04-19 22:02:11 +02:00
return;
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
client-node: fix port implementation Make the port forward the port methods to the node. Fix io area when not using adapter
2018-07-31 14:28:15 +02:00
impl->adapter_mix = impl->adapter;
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
impl->adapter_mix_port = 0;
client-stream: improvements
2018-04-19 22:02:11 +02:00
impl->use_converter = true;
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_node_add_listener(impl->adapter, &impl->adapter_listener,
&adapter_node_events, impl);
client-stream: improvements
2018-04-19 22:02:11 +02:00
}
else {
impl->adapter = impl->cnode;
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
impl->adapter_mix = impl->client_port->mix;
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
impl->adapter_mix_port = 0;
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
impl->adapter_mix_flags = impl->client_port->spa_flags;
client-stream: improvements
2018-04-19 22:02:11 +02:00
impl->use_converter = false;
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
emit_port_info(impl);
client-stream: improvements
2018-04-19 22:02:11 +02:00
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
if (impl->use_converter) {
work on separating port mixers Make it possible to assign an arbitary node as the port mixer. Also remove dynamically added ports. Improve negotiation and allocation on the mixer ports Add some more SSE optimisations Move float mixer from the audio dsp to the port Remove pw_node_get_free_port() and do things more explicitly. Handle mixer ports in client-node
2018-07-31 12:23:35 +02:00
if ((res = spa_node_port_set_io(impl->adapter_mix,
client-stream: make adapter port variable We need this to add control ports later
2018-10-01 11:15:12 +02:00
SPA_DIRECTION_REVERSE(impl->direction),
impl->adapter_mix_port,
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
SPA_IO_Buffers,
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
impl->client_port_mix.io,
sizeof(impl->client_port_mix.io))) < 0)
return;
spa: add profile param Make a profile param that can be used to configure a node with a certain profile. Use the profile to configure the ports on splitter and merger and get rid of the dynamic ports. Use the profile to configure the client-node and audio-dsp. Don't try to link more ports than available between client-node and dsp.
2018-10-08 11:45:52 +02:00
if ((res = spa_node_port_set_io(impl->adapter_mix,
impl->direction, 0,
SPA_IO_Range,
&impl->range,
sizeof(&impl->range))) < 0)
return;
client-stream: improve case without adapter Handle the case where we don't have/need an adapter. Add the adapter and client-node to the graph
2018-04-25 15:56:39 +02:00
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
small cleanups
2018-09-11 10:24:48 +02:00
switch (media_type) {
case SPA_MEDIA_TYPE_audio:
client-stream: Also link controls Improve registration of the node, set the media.class
2018-07-03 21:47:53 +02:00
type = "Audio";
small cleanups
2018-09-11 10:24:48 +02:00
break;
case SPA_MEDIA_TYPE_video:
client-stream: Also link controls Improve registration of the node, set the media.class
2018-07-03 21:47:53 +02:00
type = "Video";
small cleanups
2018-09-11 10:24:48 +02:00
break;
default:
client-stream: Also link controls Improve registration of the node, set the media.class
2018-07-03 21:47:53 +02:00
type = "Generic";
small cleanups
2018-09-11 10:24:48 +02:00
break;
}
client-stream: Also link controls Improve registration of the node, set the media.class
2018-07-03 21:47:53 +02:00
snprintf(media_class, sizeof(media_class), "Stream/%s/%s", dir, type);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
client-stream: add media.class on node Add the media.class property on the node as well.
2018-10-18 12:56:10 +02:00
items[0] = SPA_DICT_ITEM_INIT("media.class", media_class);
pw_node_update_properties(impl->this.node, &SPA_DICT_INIT(items, 1));
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
pipewire: improve memory cleanup Add method to unload a spa interface. Various other memory cleanups
2018-04-20 16:27:19 +02:00
static void cleanup(struct impl *impl)
{
client-stream: fix cleanup first let the client-stream node cleanup and then destroy our client-node.
2018-12-04 16:20:57 +01:00
pw_log_debug("client-stream %p: cleanup", &impl->this);
pipewire: improve memory cleanup Add method to unload a spa interface. Various other memory cleanups
2018-04-20 16:27:19 +02:00
if (impl->use_converter) {
if (impl->adapter)
pw_unload_spa_interface(impl->adapter);
}
free() can handle NULL just fine so skip the check Fixes #117
2018-12-19 17:47:25 +01:00
free(impl->buffers);
if (impl->mem)
pipewire: improve memory cleanup Add method to unload a spa interface. Various other memory cleanups
2018-04-20 16:27:19 +02:00
pw_memblock_free(impl->mem);
free(impl);
}
client-stream: improvements
2018-04-19 22:02:11 +02:00
static void client_node_destroy(void *data)
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
{
struct impl *impl = data;
client-stream: improvements
2018-04-19 22:02:11 +02:00
pw_log_debug("client-stream %p: destroy", &impl->this);
node: keep better track of driver node When a session disappears, try to move nodes to another session.
2018-05-17 17:40:08 +02:00
pw_node_set_driver(impl->client_node->node, NULL);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
client-stream: improvements
2018-04-19 22:02:11 +02:00
spa_hook_remove(&impl->node_listener);
pw_node_destroy(impl->this.node);
client-node: improve cleanup
2019-03-06 09:52:07 +01:00
}
static void client_node_free(void *data)
{
struct impl *impl = data;
pw_log_debug("client-stream %p: free", &impl->this);
spa_hook_remove(&impl->client_node_listener);
pipewire: improve memory cleanup Add method to unload a spa interface. Various other memory cleanups
2018-04-20 16:27:19 +02:00
cleanup(impl);
client-stream: improvements
2018-04-19 22:02:11 +02:00
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +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
static void client_node_result(void *data, int seq, int res, const void *result)
{
struct impl *impl = data;
struct node *node = &impl->node;
pw_log_debug("client-stream %p: result %d %d", &impl->this, seq, res);
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_node_emit_result(&node->hooks, seq, res, result);
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
}
client-stream: improvements
2018-04-19 22:02:11 +02:00
static void client_node_active_changed(void *data, bool active)
{
struct impl *impl = data;
pw_log_debug("client-stream %p: active %d", &impl->this, active);
client-stream: just stop feeding the graph in paused Stop feeding the graph in paused instead of going to idle. We might want to idle in the future when we can get the clock resume as well.
2018-10-09 16:34:37 +02:00
impl->active = active;
client-stream: improvements
2018-04-19 22:02:11 +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
static void client_node_info_changed(void *data, const struct pw_node_info *info)
client-stream: update properties when client info changes
2018-10-16 09:52:47 +02:00
{
struct impl *impl = data;
struct pw_client_stream *this = &impl->this;
pw_log_debug("client-stream %p: info changed", this);
pw_node_update_properties(this->node, info->props);
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
static const struct pw_node_events client_node_events = {
PW_VERSION_NODE_EVENTS,
client-stream: improvements
2018-04-19 22:02:11 +02:00
.destroy = client_node_destroy,
client-node: improve cleanup
2019-03-06 09:52:07 +01:00
.free = client_node_free,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
.initialized = client_node_initialized,
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 = client_node_result,
client-stream: improvements
2018-04-19 22:02:11 +02:00
.active_changed = client_node_active_changed,
client-stream: update properties when client info changes
2018-10-16 09:52:47 +02:00
.info_changed = client_node_info_changed,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
};
client-node: improve cleanup
2019-03-06 09:52:07 +01:00
static void node_destroy(void *data)
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
{
struct impl *impl = data;
client-node: improve cleanup
2019-03-06 09:52:07 +01:00
pw_log_debug("client-stream %p: destroy", &impl->this);
spa_hook_remove(&impl->client_node_listener);
pw_client_node_destroy(impl->client_node);
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
client-node: improve cleanup
2019-03-06 09:52:07 +01:00
static void node_free(void *data)
{
struct impl *impl = data;
client-stream: fix cleanup first let the client-stream node cleanup and then destroy our client-node.
2018-12-04 16:20:57 +01:00
pw_log_debug("client-stream %p: free", &impl->this);
node: keep better track of driver node When a session disappears, try to move nodes to another session.
2018-05-17 17:40:08 +02:00
spa_hook_remove(&impl->node_listener);
pipewire: improve memory cleanup Add method to unload a spa interface. Various other memory cleanups
2018-04-20 16:27:19 +02:00
cleanup(impl);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
}
client-stream: Also link controls Improve registration of the node, set the media.class
2018-07-03 21:47:53 +02:00
static void node_initialized(void *data)
{
struct impl *impl = data;
pw_client_node_registered(impl->client_node, impl->this.node->global->id);
}
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
static void node_peer_added(void *data, struct pw_node *peer)
{
struct impl *impl = data;
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
pw_node_emit_peer_added(impl->client_node->node, peer);
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
}
static void node_peer_removed(void *data, struct pw_node *peer)
{
struct impl *impl = data;
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
pw_node_emit_peer_removed(impl->client_node->node, peer);
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
}
static void node_driver_changed(void *data, struct pw_node *old, struct pw_node *driver)
node: keep better track of driver node When a session disappears, try to move nodes to another session.
2018-05-17 17:40:08 +02:00
{
struct impl *impl = data;
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
pw_log_debug("client-stream %p: driver changed %p->%p", &impl->this, old, driver);
node: keep better track of driver node When a session disappears, try to move nodes to another session.
2018-05-17 17:40:08 +02:00
impl->client_node->node->driver_node = driver;
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
pw_node_emit_driver_changed(impl->client_node->node, old, driver);
node: keep better track of driver node When a session disappears, try to move nodes to another session.
2018-05-17 17:40:08 +02:00
}
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
static const struct pw_node_events node_events = {
PW_VERSION_NODE_EVENTS,
client-node: improve cleanup
2019-03-06 09:52:07 +01:00
.destroy = node_destroy,
client-stream: fix cleanup first let the client-stream node cleanup and then destroy our client-node.
2018-12-04 16:20:57 +01:00
.free = node_free,
client-stream: Also link controls Improve registration of the node, set the media.class
2018-07-03 21:47:53 +02:00
.initialized = node_initialized,
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
.peer_added = node_peer_added,
.peer_removed = node_peer_removed,
node: keep better track of driver node When a session disappears, try to move nodes to another session.
2018-05-17 17:40:08 +02:00
.driver_changed = node_driver_changed,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
};
/** Create a new client stream
* \param client an owner \ref pw_client
* \param id an id
* \param name a name
* \param properties extra properties
* \return a newly allocated client stream
*
* Create a new \ref pw_stream.
*
* \memberof pw_client_stream
*/
struct pw_client_stream *pw_client_stream_new(struct pw_resource *resource,
client-node: set parent id and owner Make sure we set the right parent id and owner for the client node and client-stream Move the remote id in the proxy object and use it in the stream to get the node id.
2018-07-03 21:43:21 +02:00
struct pw_global *parent,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
struct pw_properties *properties)
{
struct impl *impl;
struct pw_client_stream *this;
struct pw_client *client = pw_resource_get_client(resource);
struct pw_core *core = pw_client_get_core(client);
const struct spa_support *support;
uint32_t n_support;
const char *name;
impl = calloc(1, sizeof(struct impl));
if (impl == NULL)
return NULL;
this = &impl->this;
impl->core = core;
client-stream: improvements
2018-04-19 22:02:11 +02:00
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
pw_log_debug("client-stream %p: new", impl);
client-stream: improvements
2018-04-19 22:02:11 +02:00
impl->client_node = pw_client_node_new(
resource,
client-node: set parent id and owner Make sure we set the right parent id and owner for the client node and client-stream Move the remote id in the proxy object and use it in the stream to get the node id.
2018-07-03 21:43:21 +02:00
parent,
client-stream: improvements
2018-04-19 22:02:11 +02:00
pw_properties_copy(properties),
false);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
if (impl->client_node == NULL)
goto error_no_node;
node: allocate shared mem for activation Allocate a per node a piece of shared memory where we place the activation structure with the graph state and io_position. We can then give this info to nodes so that they can get the position in the graph directly but also later, activate the next node in the graph.
2019-02-07 12:34:54 +01:00
impl->cnode = pw_node_get_implementation(impl->client_node->node);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
support = pw_core_get_support(impl->core, &n_support);
node_init(&impl->node, NULL, support, n_support);
impl->node.impl = impl;
if ((name = pw_properties_get(properties, "node.name")) == NULL)
name = "client-stream";
this->node = pw_spa_node_new(core,
client,
client-node: set parent id and owner Make sure we set the right parent id and owner for the client node and client-stream Move the remote id in the proxy object and use it in the stream to get the node id.
2018-07-03 21:43:21 +02:00
parent,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
name,
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
PW_SPA_NODE_FLAG_ACTIVATE,
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
&impl->node.node,
NULL,
properties, 0);
if (this->node == NULL)
goto error_no_node;
this->node->remote = true;
client-stream: improvements
2018-04-19 22:02:11 +02:00
pw_node_add_listener(impl->client_node->node,
&impl->client_node_listener,
&client_node_events, impl);
add client-stream A client stream is a more specialized way to send 1 stream to pipewire. On the client side and receiver side it can do conversion and the buffer size of the client can be choosen arbitrarily.
2018-04-13 20:06:37 +02:00
pw_node_add_listener(this->node, &impl->node_listener, &node_events, impl);
return this;
error_no_node:
pw_resource_destroy(resource);
free(impl);
return NULL;
}
/** Destroy a client stream
* \param stream the client stream to destroy
* \memberof pw_client_stream
*/
void pw_client_stream_destroy(struct pw_client_stream *stream)
{
struct impl *impl = SPA_CONTAINER_OF(stream, struct impl, this);
pw_client_node_destroy(impl->client_node);
}
Reference in a new issue Copy permalink