mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-29 05:40:27 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
pipewire/spa/plugins/alsa/alsa-pcm-sink.c

991 lines
26 KiB
C
Raw Permalink Normal View History

treewide: use SPDX tags to specify copyright information SPDX tags make the licensing information easy to understand and clear, and they are machine parseable. See https://spdx.dev for more information.
2023-02-08 18:12:00 +01:00
/* Spa ALSA Sink */
/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
/* SPDX-License-Identifier: MIT */
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
#include <stddef.h>
alsa: handle alsa-lib 1.1.9 alsa-lib 1.1.9 removed /usr/include/alsa from the include path, we must include <alsa/asoundlib.h>
2019-05-23 09:25:51 +02:00
#include <alsa/asoundlib.h>
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
Reorganise SPA tree Reorganise the SPA includes to make it more extensible later Simplify the naming of the buffer and meta params
2017-11-10 13:36:14 +01:00
#include <spa/node/node.h>
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
#include <spa/node/utils.h>
spa: add keys for properties Define and document property keys
2019-06-03 16:48:01 +02:00
#include <spa/utils/keys.h>
names: add standard factory name definitions Define a set of standard factory names and document what they contain. This makes it possible to change the implementation by mapping the factory-name to a different shared library.
2019-06-21 13:31:34 +02:00
#include <spa/utils/names.h>
treewide: replace strcmp() == 0 with spa_streq() This change is only done in source files for now, header files will be done separately.
2021-05-18 11:36:13 +10:00
#include <spa/utils/string.h>
Reorganise SPA tree Reorganise the SPA includes to make it more extensible later Simplify the naming of the buffer and meta params
2017-11-10 13:36:14 +01:00
#include <spa/param/audio/format.h>
pod: move compare and filter functions out of the library
2018-08-13 17:17:23 +02:00
#include <spa/pod/filter.h>
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
#include <spa/pod/dynamic.h>
Port: Add tag param The tag param has a list of arbitrary key/value pairs. Like the Latency param, it travels up and downstream. Mixers will append the info dictionaries or do some more fancy merging. The purpose is to transport arbirary metadata, out-of-band, through the graph and it's used for stream metadata and other stream properties.
2023-08-24 16:41:21 +02:00
#include <spa/debug/log.h>
#include <spa/debug/pod.h>
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
improve properties on node and port Rename some alsa filenames.
2019-09-23 20:51:34 +02:00
#include "alsa-pcm.h"
alsa: aad alsa source and monitor
2016-09-19 09:16:58 +02:00
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
#define CHECK_PORT(this,d,p) ((d) == SPA_DIRECTION_INPUT && (p) == 0)
Debug: remove logger Make a default logger and mapper in a .h file to be used by examples Remove logger and mapper from libs Make method to set the default mapper for the debug methods
2017-06-06 13:30:34 +02:00
static const char default_device[] = "hw:0";
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
indent
2017-05-26 08:05:01 +02:00
static void reset_props(struct props *props)
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
{
indent
2017-05-26 08:05:01 +02:00
strncpy(props->device, default_device, 64);
alsa: add option do use chmap from alsa, disable by default This should be more in line with what PulseAudio does and so lead to less surprises. See #289
2020-09-14 20:15:48 +02:00
props->use_chmap = DEFAULT_USE_CHMAP;
spa: acp: get and emit UCM information for SplitPCM devices When api.alsa.split-enable=true for ACP device, instruct UCM to not use alsa-lib plugins for SplitPCM devices. Grab the information from UCM for the intended channel remapping, and add the splitting information to the nodes emitted. Session manager can then look at that, and load nodes to do the channel splitting.
2024-12-07 13:27:09 +02:00
spa_scnprintf(props->media_class, sizeof(props->media_class), "%s", "Audio/Sink");
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int impl_node_enum_params(void *object, 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)
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
struct spa_pod *param;
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
spa_auto(spa_pod_dynamic_builder) b = { 0 };
struct spa_pod_builder_state state;
Increase pod buffer size The props of a 64 channel node are at least 2048 bytes long so make sure we can build and filter them. Fixes #1574
2021-09-06 15:07:28 +02:00
uint8_t buffer[4096];
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;
indent
2017-05-26 08:05:01 +02:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(this != 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);
indent
2017-05-26 08:05:01 +02:00
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
spa_pod_dynamic_builder_init(&b, buffer, sizeof(buffer), 4096);
spa_pod_builder_get_state(&b.b, &state);
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;
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +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++;
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
spa_pod_builder_reset(&b.b, &state);
Improve pod filter Reset the builder when the filter failed. Make the plugins create their params in a temporary buffer, we don't want to do in-place filtering because that is not always possible. Because the filter now resets on error, we can remove the reset from the plugins.
2017-11-14 10:17:45 +01:00
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
switch (id) {
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_PARAM_PropInfo:
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
{
props: improve property introspection Make a new PropInfo parameter that allows us to iterate all properties. Make some new fields to set labels and names for properties. We will be able to add more things to describe the properties this way. Use the Props param to simply query or set properties. We can now make int enum properties and describe all possible values with labels, we don't need to register types anymore. This then makes it possible to enumerate the v4l2 controls and make them available as control params.
2017-12-15 16:30:56 +01:00
struct props *p = &this->props;
Various fixes and improvements to enum_params
2017-11-08 11:22:42 +01: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
switch (result.index) {
props: improve property introspection Make a new PropInfo parameter that allows us to iterate all properties. Make some new fields to set labels and names for properties. We will be able to add more things to describe the properties this way. Use the Props param to simply query or set properties. We can now make int enum properties and describe all possible values with labels, we don't need to register types anymore. This then makes it possible to enumerate the v4l2 controls and make them available as control params.
2017-12-15 16:30:56 +01:00
case 0:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_pod_builder_add_object(&b.b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_PropInfo, id,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_device),
alsa: expose all config options as params Add PropInfo for all the params that we can configure at construct time and also add them as PROP_params. This way you can configure the headroom at runtime with this: pw-cli s <id> Props '{ params = [ "api.alsa.headroom" 1024 ] }'
2021-11-30 17:43:07 +01:00
SPA_PROP_INFO_name, SPA_POD_String(SPA_KEY_API_ALSA_PATH),
SPA_PROP_INFO_description, SPA_POD_String("The ALSA device"),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_PROP_INFO_type, SPA_POD_Stringn(p->device, sizeof(p->device)));
props: improve property introspection Make a new PropInfo parameter that allows us to iterate all properties. Make some new fields to set labels and names for properties. We will be able to add more things to describe the properties this way. Use the Props param to simply query or set properties. We can now make int enum properties and describe all possible values with labels, we don't need to register types anymore. This then makes it possible to enumerate the v4l2 controls and make them available as control params.
2017-12-15 16:30:56 +01:00
break;
case 1:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_pod_builder_add_object(&b.b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_PropInfo, id,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_deviceName),
alsa: expose all config options as params Add PropInfo for all the params that we can configure at construct time and also add them as PROP_params. This way you can configure the headroom at runtime with this: pw-cli s <id> Props '{ params = [ "api.alsa.headroom" 1024 ] }'
2021-11-30 17:43:07 +01:00
SPA_PROP_INFO_description, SPA_POD_String("The ALSA device name"),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_PROP_INFO_type, SPA_POD_Stringn(p->device_name, sizeof(p->device_name)));
props: improve property introspection Make a new PropInfo parameter that allows us to iterate all properties. Make some new fields to set labels and names for properties. We will be able to add more things to describe the properties this way. Use the Props param to simply query or set properties. We can now make int enum properties and describe all possible values with labels, we don't need to register types anymore. This then makes it possible to enumerate the v4l2 controls and make them available as control params.
2017-12-15 16:30:56 +01:00
break;
case 2:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_pod_builder_add_object(&b.b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_PropInfo, id,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_cardName),
alsa: expose all config options as params Add PropInfo for all the params that we can configure at construct time and also add them as PROP_params. This way you can configure the headroom at runtime with this: pw-cli s <id> Props '{ params = [ "api.alsa.headroom" 1024 ] }'
2021-11-30 17:43:07 +01:00
SPA_PROP_INFO_description, SPA_POD_String("The ALSA card name"),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_PROP_INFO_type, SPA_POD_Stringn(p->card_name, sizeof(p->card_name)));
props: improve property introspection Make a new PropInfo parameter that allows us to iterate all properties. Make some new fields to set labels and names for properties. We will be able to add more things to describe the properties this way. Use the Props param to simply query or set properties. We can now make int enum properties and describe all possible values with labels, we don't need to register types anymore. This then makes it possible to enumerate the v4l2 controls and make them available as control params.
2017-12-15 16:30:56 +01:00
break;
case 3:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_pod_builder_add_object(&b.b,
alsa: hook up latencyOffsetNsec in ALSA sink/source This property is exposed on the device Route and forwarded to the nodes. It then configured the process_latency.ns field, which influences the reported port latency. This makes it possible to change the internal port latency on the sink and source with pavucontrol and tweak the synchronization to compensate for internal latencies in the device.
2021-08-17 11:57:12 +02:00
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_latencyOffsetNsec),
alsa: expose all config options as params Add PropInfo for all the params that we can configure at construct time and also add them as PROP_params. This way you can configure the headroom at runtime with this: pw-cli s <id> Props '{ params = [ "api.alsa.headroom" 1024 ] }'
2021-11-30 17:43:07 +01:00
SPA_PROP_INFO_description, SPA_POD_String("Latency offset (ns)"),
alsa: set better ranges on properties
2022-03-04 17:17:31 +01:00
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Long(0LL, 0LL, 2 * SPA_NSEC_PER_SEC));
alsa: hook up latencyOffsetNsec in ALSA sink/source This property is exposed on the device Route and forwarded to the nodes. It then configured the process_latency.ns field, which influences the reported port latency. This makes it possible to change the internal port latency on the sink and source with pavucontrol and tweak the synchronization to compensate for internal latencies in the device.
2021-08-17 11:57:12 +02:00
break;
alsa: remove unused properties and hardcoded values
2022-01-12 17:51:49 +01:00
case 4:
alsa: handle extra propinfo in all cases When we don't have iec codecs, increment the result.index to iterate the remaining properties.
2022-01-03 16:12:41 +01:00
if (!this->is_iec958 && !this->is_hdmi)
goto next;
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_pod_builder_add_object(&b.b,
alsa: handle extra propinfo in all cases When we don't have iec codecs, increment the result.index to iterate the remaining properties.
2022-01-03 16:12:41 +01:00
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_iec958Codecs),
SPA_PROP_INFO_name, SPA_POD_String("iec958.codecs"),
SPA_PROP_INFO_description, SPA_POD_String("Enabled IEC958 (S/PDIF) codecs"),
SPA_PROP_INFO_type, SPA_POD_Id(SPA_AUDIO_IEC958_CODEC_UNKNOWN),
SPA_PROP_INFO_params, SPA_POD_Bool(true),
SPA_PROP_INFO_container, SPA_POD_Id(SPA_TYPE_Array));
break;
props: improve property introspection Make a new PropInfo parameter that allows us to iterate all properties. Make some new fields to set labels and names for properties. We will be able to add more things to describe the properties this way. Use the Props param to simply query or set properties. We can now make int enum properties and describe all possible values with labels, we don't need to register types anymore. This then makes it possible to enumerate the v4l2 controls and make them available as control params.
2017-12-15 16:30:56 +01:00
default:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_alsa_enum_propinfo(this, result.index - 5, &b.b);
alsa: expose all config options as params Add PropInfo for all the params that we can configure at construct time and also add them as PROP_params. This way you can configure the headroom at runtime with this: pw-cli s <id> Props '{ params = [ "api.alsa.headroom" 1024 ] }'
2021-11-30 17:43:07 +01:00
if (param == NULL)
return 0;
props: improve property introspection Make a new PropInfo parameter that allows us to iterate all properties. Make some new fields to set labels and names for properties. We will be able to add more things to describe the properties this way. Use the Props param to simply query or set properties. We can now make int enum properties and describe all possible values with labels, we don't need to register types anymore. This then makes it possible to enumerate the v4l2 controls and make them available as control params.
2017-12-15 16:30:56 +01:00
}
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
Various fixes and improvements to enum_params
2017-11-08 11:22:42 +01:00
}
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_PARAM_Props:
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
{
Various fixes and improvements to enum_params
2017-11-08 11:22:42 +01:00
struct props *p = &this->props;
alsa: add enumeration of iec958 format For hdmi and iec958 devices, enumerate the iec958 formats and codecs. Initially only PCM is supported as a codec but with a property or an init option, the list of codecs can be dynamically configured.
2021-08-12 14:08:20 +02:00
struct spa_pod_frame f;
uint32_t codecs[16], n_codecs;
Various fixes and improvements to enum_params
2017-11-08 11:22:42 +01: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
switch (result.index) {
props: improve property introspection Make a new PropInfo parameter that allows us to iterate all properties. Make some new fields to set labels and names for properties. We will be able to add more things to describe the properties this way. Use the Props param to simply query or set properties. We can now make int enum properties and describe all possible values with labels, we don't need to register types anymore. This then makes it possible to enumerate the v4l2 controls and make them available as control params.
2017-12-15 16:30:56 +01:00
case 0:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
spa_pod_builder_push_object(&b.b, &f,
alsa: add enumeration of iec958 format For hdmi and iec958 devices, enumerate the iec958 formats and codecs. Initially only PCM is supported as a codec but with a property or an init option, the list of codecs can be dynamically configured.
2021-08-12 14:08:20 +02:00
SPA_TYPE_OBJECT_Props, id);
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
spa_pod_builder_add(&b.b,
alsa: add option do use chmap from alsa, disable by default This should be more in line with what PulseAudio does and so lead to less surprises. See #289
2020-09-14 20:15:48 +02:00
SPA_PROP_device, SPA_POD_Stringn(p->device, sizeof(p->device)),
SPA_PROP_deviceName, SPA_POD_Stringn(p->device_name, sizeof(p->device_name)),
SPA_PROP_cardName, SPA_POD_Stringn(p->card_name, sizeof(p->card_name)),
alsa: add enumeration of iec958 format For hdmi and iec958 devices, enumerate the iec958 formats and codecs. Initially only PCM is supported as a codec but with a property or an init option, the list of codecs can be dynamically configured.
2021-08-12 14:08:20 +02:00
SPA_PROP_latencyOffsetNsec, SPA_POD_Long(this->process_latency.ns),
0);
alsa: always list PCM as iec958 codec Always put PCM as the supported format for iec958. Only accept iec958codecs for iec958 capable nodes.
2021-09-01 11:16:38 +02:00
if (this->is_iec958 || this->is_hdmi) {
n_codecs = spa_alsa_get_iec958_codecs(this, codecs, SPA_N_ELEMENTS(codecs));
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
spa_pod_builder_prop(&b.b, SPA_PROP_iec958Codecs, 0);
spa_pod_builder_array(&b.b, sizeof(uint32_t), SPA_TYPE_Id,
alsa: add enumeration of iec958 format For hdmi and iec958 devices, enumerate the iec958 formats and codecs. Initially only PCM is supported as a codec but with a property or an init option, the list of codecs can be dynamically configured.
2021-08-12 14:08:20 +02:00
n_codecs, codecs);
}
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
spa_alsa_add_prop_params(this, &b.b);
param = spa_pod_builder_pop(&b.b, &f);
props: improve property introspection Make a new PropInfo parameter that allows us to iterate all properties. Make some new fields to set labels and names for properties. We will be able to add more things to describe the properties this way. Use the Props param to simply query or set properties. We can now make int enum properties and describe all possible values with labels, we don't need to register types anymore. This then makes it possible to enumerate the v4l2 controls and make them available as control params.
2017-12-15 16:30:56 +01:00
break;
default:
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
props: improve property introspection Make a new PropInfo parameter that allows us to iterate all properties. Make some new fields to set labels and names for properties. We will be able to add more things to describe the properties this way. Use the Props param to simply query or set properties. We can now make int enum properties and describe all possible values with labels, we don't need to register types anymore. This then makes it possible to enumerate the v4l2 controls and make them available as control params.
2017-12-15 16:30:56 +01:00
}
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
}
alsa: advertize node params correctly
2019-08-21 13:05:52 +02:00
case SPA_PARAM_IO:
switch (result.index) {
case 0:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_pod_builder_add_object(&b.b,
alsa: advertize node params correctly
2019-08-21 13:05:52 +02:00
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Clock),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_clock)));
break;
case 1:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_pod_builder_add_object(&b.b,
alsa: advertize node params correctly
2019-08-21 13:05:52 +02:00
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Position),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_position)));
break;
default:
return 0;
}
break;
alsa: use ProcessLatency param to get and set internal latency
2021-08-17 09:14:40 +02:00
case SPA_PARAM_ProcessLatency:
switch (result.index) {
case 0:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_process_latency_build(&b.b, id, &this->process_latency);
alsa: use ProcessLatency param to get and set internal latency
2021-08-17 09:14:40 +02:00
break;
default:
return 0;
}
break;
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
default:
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -ENOENT;
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
}
indent
2017-05-26 08:05:01 +02:00
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
if (spa_pod_filter(&b.b, &result.param, param, filter) < 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
goto next;
spa: add result type We need this to know the type of result, especially when serializing.
2019-05-28 13:59:48 +02:00
spa_node_emit_result(&this->hooks, seq, 0, SPA_RESULT_TYPE_NODE_PARAMS, &result);
Various fixes and improvements to enum_params
2017-11-08 11:22:42 +01:00
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
if (++count != num)
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
goto next;
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
return 0;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int impl_node_set_io(void *object, uint32_t id, void *data, size_t 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
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
alsa: implement set_io and handle position io Use position io for deciding the size of the output buffers in alsasrc
2018-10-24 10:27:57 +02:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(this != NULL, -EINVAL);
alsa: implement set_io and handle position io Use position io for deciding the size of the output buffers in alsasrc
2018-10-24 10:27:57 +02:00
switch (id) {
case SPA_IO_Clock:
alsa: update the clock name when we can Update the clock name as soon as we get a io_clock. This way we can use it to compare the clock name against the driver right away.
2023-09-14 17:15:06 +02:00
if (size > 0 && size < sizeof(struct spa_io_clock))
return -EINVAL;
alsa: implement set_io and handle position io Use position io for deciding the size of the output buffers in alsasrc
2018-10-24 10:27:57 +02:00
this->clock = data;
break;
case SPA_IO_Position:
alsa: update the clock name when we can Update the clock name as soon as we get a io_clock. This way we can use it to compare the clock name against the driver right away.
2023-09-14 17:15:06 +02:00
if (size > 0 && size < sizeof(struct spa_io_position))
return -EINVAL;
alsa: implement set_io and handle position io Use position io for deciding the size of the output buffers in alsasrc
2018-10-24 10:27:57 +02:00
this->position = data;
break;
default:
return -ENOENT;
}
slave -> follower We use master/follower terminology everywhere.
2020-02-21 10:47:32 +01:00
spa_alsa_reassign_follower(this);
alsa: handle master/slave changes
2019-04-24 15:38:06 +02:00
alsa: implement set_io and handle position io Use position io for deciding the size of the output buffers in alsasrc
2018-10-24 10:27:57 +02:00
return 0;
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
}
alsa: hook up latencyOffsetNsec in ALSA sink/source This property is exposed on the device Route and forwarded to the nodes. It then configured the process_latency.ns field, which influences the reported port latency. This makes it possible to change the internal port latency on the sink and source with pavucontrol and tweak the synchronization to compensate for internal latencies in the device.
2021-08-17 11:57:12 +02:00
static void handle_process_latency(struct state *this,
const struct spa_process_latency_info *info)
{
bool ns_changed = this->process_latency.ns != info->ns;
if (this->process_latency.quantum == info->quantum &&
this->process_latency.rate == info->rate &&
!ns_changed)
return;
this->process_latency = *info;
this->info.change_mask |= SPA_NODE_CHANGE_MASK_PARAMS;
if (ns_changed)
alsa: emit param changes correctly Use the param user field to tag changes in the params. codec changes emits an EnumFormat and Props change. Accumulate various param changes and emit them together.
2021-09-01 12:57:47 +02:00
this->params[NODE_Props].user++;
this->params[NODE_ProcessLatency].user++;
alsa: hook up latencyOffsetNsec in ALSA sink/source This property is exposed on the device Route and forwarded to the nodes. It then configured the process_latency.ns field, which influences the reported port latency. This makes it possible to change the internal port latency on the sink and source with pavucontrol and tweak the synchronization to compensate for internal latencies in the device.
2021-08-17 11:57:12 +02:00
this->port_info.change_mask |= SPA_PORT_CHANGE_MASK_PARAMS;
alsa: emit param changes correctly Use the param user field to tag changes in the params. codec changes emits an EnumFormat and Props change. Accumulate various param changes and emit them together.
2021-09-01 12:57:47 +02:00
this->port_params[PORT_Latency].user++;
alsa: hook up latencyOffsetNsec in ALSA sink/source This property is exposed on the device Route and forwarded to the nodes. It then configured the process_latency.ns field, which influences the reported port latency. This makes it possible to change the internal port latency on the sink and source with pavucontrol and tweak the synchronization to compensate for internal latencies in the device.
2021-08-17 11:57:12 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int impl_node_set_param(void *object, uint32_t id, uint32_t flags,
Improve enum_param Add an argument to pass the result param to the caller instead of having the caller have to pick it up from the builder. Improve docs for node, clock and monitor Pass spa_pod everywhere instead of spa_pod_object. Pass result argument to spa_pod_filter to make things a little nicer.
2017-11-13 17:57:38 +01:00
const struct spa_pod *param)
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
alsa: use ProcessLatency param to get and set internal latency
2021-08-17 09:14:40 +02:00
int res;
indent
2017-05-26 08:05:01 +02:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(this != NULL, -EINVAL);
Various fixes and improvements to enum_params
2017-11-08 11:22:42 +01:00
alsa: use ProcessLatency param to get and set internal latency
2021-08-17 09:14:40 +02:00
switch (id) {
case SPA_PARAM_Props:
{
Various fixes and improvements to enum_params
2017-11-08 11:22:42 +01:00
struct props *p = &this->props;
alsa: expose all config options as params Add PropInfo for all the params that we can configure at construct time and also add them as PROP_params. This way you can configure the headroom at runtime with this: pw-cli s <id> Props '{ params = [ "api.alsa.headroom" 1024 ] }'
2021-11-30 17:43:07 +01:00
struct spa_pod *iec958_codecs = NULL, *params = NULL;
alsa: improve latency update
2022-03-04 17:20:04 +01:00
int64_t lat_ns = -1;
indent
2017-05-26 08:05:01 +02:00
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
if (param == NULL) {
Various fixes and improvements to enum_params
2017-11-08 11:22:42 +01:00
reset_props(p);
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
}
alsa: hook up latencyOffsetNsec in ALSA sink/source This property is exposed on the device Route and forwarded to the nodes. It then configured the process_latency.ns field, which influences the reported port latency. This makes it possible to change the internal port latency on the sink and source with pavucontrol and tweak the synchronization to compensate for internal latencies in the device.
2021-08-17 11:57:12 +02:00
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_Props, NULL,
alsa: add option do use chmap from alsa, disable by default This should be more in line with what PulseAudio does and so lead to less surprises. See #289
2020-09-14 20:15:48 +02:00
SPA_PROP_device, SPA_POD_OPT_Stringn(p->device, sizeof(p->device)),
alsa: improve latency update
2022-03-04 17:20:04 +01:00
SPA_PROP_latencyOffsetNsec, SPA_POD_OPT_Long(&lat_ns),
alsa: expose all config options as params Add PropInfo for all the params that we can configure at construct time and also add them as PROP_params. This way you can configure the headroom at runtime with this: pw-cli s <id> Props '{ params = [ "api.alsa.headroom" 1024 ] }'
2021-11-30 17:43:07 +01:00
SPA_PROP_iec958Codecs, SPA_POD_OPT_Pod(&iec958_codecs),
SPA_PROP_params, SPA_POD_OPT_Pod(&params));
alsa: add enumeration of iec958 format For hdmi and iec958 devices, enumerate the iec958 formats and codecs. Initially only PCM is supported as a codec but with a property or an init option, the list of codecs can be dynamically configured.
2021-08-12 14:08:20 +02:00
alsa: always list PCM as iec958 codec Always put PCM as the supported format for iec958. Only accept iec958codecs for iec958 capable nodes.
2021-09-01 11:16:38 +02:00
if ((this->is_iec958 || this->is_hdmi) && iec958_codecs != NULL) {
alsa: add enumeration of iec958 format For hdmi and iec958 devices, enumerate the iec958 formats and codecs. Initially only PCM is supported as a codec but with a property or an init option, the list of codecs can be dynamically configured.
2021-08-12 14:08:20 +02:00
uint32_t i, codecs[16], n_codecs;
n_codecs = spa_pod_copy_array(iec958_codecs, SPA_TYPE_Id,
codecs, SPA_N_ELEMENTS(codecs));
alsa: always list PCM as iec958 codec Always put PCM as the supported format for iec958. Only accept iec958codecs for iec958 capable nodes.
2021-09-01 11:16:38 +02:00
this->iec958_codecs = 1ULL << SPA_AUDIO_IEC958_CODEC_PCM;
alsa: add enumeration of iec958 format For hdmi and iec958 devices, enumerate the iec958 formats and codecs. Initially only PCM is supported as a codec but with a property or an init option, the list of codecs can be dynamically configured.
2021-08-12 14:08:20 +02:00
for (i = 0; i < n_codecs; i++)
this->iec958_codecs |= 1ULL << codecs[i];
alsa: emit param changes correctly Use the param user field to tag changes in the params. codec changes emits an EnumFormat and Props change. Accumulate various param changes and emit them together.
2021-09-01 12:57:47 +02:00
this->info.change_mask |= SPA_NODE_CHANGE_MASK_PARAMS;
this->params[NODE_Props].user++;
this->port_info.change_mask |= SPA_PORT_CHANGE_MASK_PARAMS;
this->port_params[PORT_EnumFormat].user++;
alsa: add enumeration of iec958 format For hdmi and iec958 devices, enumerate the iec958 formats and codecs. Initially only PCM is supported as a codec but with a property or an init option, the list of codecs can be dynamically configured.
2021-08-12 14:08:20 +02:00
}
alsa: expose all config options as params Add PropInfo for all the params that we can configure at construct time and also add them as PROP_params. This way you can configure the headroom at runtime with this: pw-cli s <id> Props '{ params = [ "api.alsa.headroom" 1024 ] }'
2021-11-30 17:43:07 +01:00
spa_alsa_parse_prop_params(this, params);
alsa: improve latency update
2022-03-04 17:20:04 +01:00
if (lat_ns != -1) {
struct spa_process_latency_info info;
info = this->process_latency;
info.ns = lat_ns;
handle_process_latency(this, &info);
}
alsa: Share node/port info emission code between sink and source It's mostly the same, and it allows us to trigger this code in the shared alsa-pcm.c code as well.
2023-11-07 13:01:52 -05:00
spa_alsa_emit_node_info(this, false);
spa_alsa_emit_port_info(this, false);
alsa: use ProcessLatency param to get and set internal latency
2021-08-17 09:14:40 +02:00
break;
indent
2017-05-26 08:05:01 +02:00
}
alsa: use ProcessLatency param to get and set internal latency
2021-08-17 09:14:40 +02:00
case SPA_PARAM_ProcessLatency:
{
struct spa_process_latency_info info;
alsa: don't crash on NULL params
2022-05-25 15:33:18 +02:00
if (param == NULL)
spa_zero(info);
else if ((res = spa_process_latency_parse(param, &info)) < 0)
alsa: use ProcessLatency param to get and set internal latency
2021-08-17 09:14:40 +02:00
return res;
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
alsa: hook up latencyOffsetNsec in ALSA sink/source This property is exposed on the device Route and forwarded to the nodes. It then configured the process_latency.ns field, which influences the reported port latency. This makes it possible to change the internal port latency on the sink and source with pavucontrol and tweak the synchronization to compensate for internal latencies in the device.
2021-08-17 11:57:12 +02:00
handle_process_latency(this, &info);
alsa: emit param changes correctly Use the param user field to tag changes in the params. codec changes emits an EnumFormat and Props change. Accumulate various param changes and emit them together.
2021-09-01 12:57:47 +02:00
alsa: Share node/port info emission code between sink and source It's mostly the same, and it allows us to trigger this code in the shared alsa-pcm.c code as well.
2023-11-07 13:01:52 -05:00
spa_alsa_emit_node_info(this, false);
spa_alsa_emit_port_info(this, false);
alsa: use ProcessLatency param to get and set internal latency
2021-08-17 09:14:40 +02:00
break;
}
default:
return -ENOENT;
}
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int impl_node_send_command(void *object, const struct spa_command *command)
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
spa: simplify start/pause Use the sync option in invoke to implement stop.
2018-01-18 11:57:23 +01:00
int res;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(this != NULL, -EINVAL);
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
spa_return_val_if_fail(command != NULL, -EINVAL);
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
types: work on types Move static pod types to type system work on type info for types Move the event and command ids to an enum to make it easier to extend later.
2018-08-24 10:53:09 +02:00
switch (SPA_NODE_COMMAND_ID(command)) {
node: Add ParamBegin/End Use these commands to mark the begin and end of a series of Param enumerations and configuration, like when doing format negotiation. The idea is that the device can remain open while we do this. Use this in adapter when negotiating a format.
2020-12-09 17:10:52 +01:00
case SPA_NODE_COMMAND_ParamBegin:
alsa: pass AES bits to S/PDIF devices This is the right thing to do and might even fix output to some devices.
2021-09-14 12:42:03 +02:00
if ((res = spa_alsa_open(this, NULL)) < 0)
node: Add ParamBegin/End Use these commands to mark the begin and end of a series of Param enumerations and configuration, like when doing format negotiation. The idea is that the device can remain open while we do this. Use this in adapter when negotiating a format.
2020-12-09 17:10:52 +01:00
return res;
break;
case SPA_NODE_COMMAND_ParamEnd:
if (this->have_format)
return 0;
if ((res = spa_alsa_close(this)) < 0)
return res;
break;
types: work on types Move static pod types to type system work on type info for types Move the event and command ids to an enum to make it easier to extend later.
2018-08-24 10:53:09 +02:00
case SPA_NODE_COMMAND_Start:
indent
2017-05-26 08:05:01 +02:00
if (!this->have_format)
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EIO;
indent
2017-05-26 08:05:01 +02:00
if (this->n_buffers == 0)
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EIO;
v4l2: continue work on the capture device Remove activate and deactivate commands. Add STEP property range type for v4l2 frame sizes later v4l2: implement negotiation and data capture
2016-07-06 19:43:37 +02:00
alsa: handle the case where the driver is destroyed When the driver node is destroyed (like when unplugging the cable) it will drop/pause all of the follower ALSA nodes. This is something that happens internally because of how the ALSA nodes work together, on the PipeWire level, the nodes are still running and they will just be moved to another driver. The problem is that nothing will then start the nodes again after moving it to the new driver. Fix this by keeping track of the desired target state of the ALSA node and restoring that state when we detect that we are paused when moved to a new driver. Fixes #4401
2024-11-15 16:09:36 +01:00
this->want_started = true;
alsa: rework timing Use a DLL to track the hardware pointer and use this to set the timer. Handle XRUN and recover.
2018-11-16 17:00:40 +01:00
if ((res = spa_alsa_start(this)) < 0)
spa: simplify start/pause Use the sync option in invoke to implement stop.
2018-01-18 11:57:23 +01:00
return res;
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
pcm: don't complain on Suspend
2019-10-22 12:20:29 +02:00
case SPA_NODE_COMMAND_Suspend:
types: work on types Move static pod types to type system work on type info for types Move the event and command ids to an enum to make it easier to extend later.
2018-08-24 10:53:09 +02:00
case SPA_NODE_COMMAND_Pause:
alsa: handle the case where the driver is destroyed When the driver node is destroyed (like when unplugging the cable) it will drop/pause all of the follower ALSA nodes. This is something that happens internally because of how the ALSA nodes work together, on the PipeWire level, the nodes are still running and they will just be moved to another driver. The problem is that nothing will then start the nodes again after moving it to the new driver. Fix this by keeping track of the desired target state of the ALSA node and restoring that state when we detect that we are paused when moved to a new driver. Fixes #4401
2024-11-15 16:09:36 +01:00
this->want_started = false;
alsa: rework timing Use a DLL to track the hardware pointer and use this to set the timer. Handle XRUN and recover.
2018-11-16 17:00:40 +01:00
if ((res = spa_alsa_pause(this)) < 0)
spa: simplify start/pause Use the sync option in invoke to implement stop.
2018-01-18 11:57:23 +01:00
return res;
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
default:
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -ENOTSUP;
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
}
spa: simplify start/pause Use the sync option in invoke to implement stop.
2018-01-18 11:57:23 +01:00
return 0;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
}
node: remove info from node interface Replace with info event emited when callbacks are set. This makes it easier to implement dynamic changes.
2018-11-26 12:41:40 +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
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
impl_node_add_listener(void *object,
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
struct spa_hook *listener,
const struct spa_node_events *events,
void *data)
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
struct spa_hook_list save;
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(this != NULL, -EINVAL);
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
spa_hook_list_isolate(&this->hooks, &save, listener, events, data);
alsa: Share node/port info emission code between sink and source It's mostly the same, and it allows us to trigger this code in the shared alsa-pcm.c code as well.
2023-11-07 13:01:52 -05:00
spa_alsa_emit_node_info(this, true);
spa_alsa_emit_port_info(this, 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_hook_list_join(&this->hooks, &save);
return 0;
}
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
static int
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
impl_node_set_callbacks(void *object,
Add user_data to callbacks Add user data to callbacks, it's more flexible and natural
2017-06-18 19:48:31 +02:00
const struct spa_node_callbacks *callbacks,
Cleanups Only pass data to callbacks. Rename some structs Provide methods to access structs
2017-08-06 06:42:26 +02:00
void *data)
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(this != NULL, -EINVAL);
Work on memory allocation We now only allow per port preallocated buffers. We exchange the index into the array instead of passing the buffers around. We still use the refcount to track when a buffer can be reused. Improve API a little, allow passing the node as the first argument of the interface call. Implement alloc_buffer in v4l2 and improve the test.
2016-07-30 20:35:34 +02:00
hook: separate spa_callbacks from the hook Make a spa_callbacks with just the functions and data and use this in the hook and objects.
2019-05-15 12:17:52 +02:00
this->callbacks = SPA_CALLBACKS_INIT(callbacks, data);
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
}
spa: implement node sync
2019-05-28 14:01:18 +02:00
static int
impl_node_sync(void *object, int seq)
{
struct state *this = object;
spa_return_val_if_fail(this != NULL, -EINVAL);
spa_node_emit_result(&this->hooks, seq, 0, 0, NULL);
return 0;
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int impl_node_add_port(void *object, enum spa_direction direction, uint32_t port_id,
node: add props to add_port
2019-02-18 13:22:46 +01:00
const struct spa_dict *props)
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
{
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -ENOTSUP;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int impl_node_remove_port(void *object, enum spa_direction direction, uint32_t port_id)
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
{
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -ENOTSUP;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
}
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
static int
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
impl_node_port_enum_params(void *object, int seq,
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
enum spa_direction direction, uint32_t port_id,
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
uint32_t id, uint32_t start, uint32_t num,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
const struct spa_pod *filter)
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
{
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
struct spa_pod *param;
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
spa_auto(spa_pod_dynamic_builder) b = { 0 };
struct spa_pod_builder_state state;
Improve pod filter Reset the builder when the filter failed. Make the plugins create their params in a temporary buffer, we don't want to do in-place filtering because that is not always possible. Because the filter now resets on error, we can remove the reset from the plugins.
2017-11-14 10:17:45 +01:00
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;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(this != 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);
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
spa_pod_dynamic_builder_init(&b, buffer, sizeof(buffer), 4096);
spa_pod_builder_get_state(&b.b, &state);
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;
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01: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++;
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
spa_pod_builder_reset(&b.b, &state);
Improve pod filter Reset the builder when the filter failed. Make the plugins create their params in a temporary buffer, we don't want to do in-place filtering because that is not always possible. Because the filter now resets on error, we can remove the reset from the plugins.
2017-11-14 10:17:45 +01:00
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
switch (id) {
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_PARAM_EnumFormat:
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_alsa_enum_format(this, seq, start, num, filter);
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
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_PARAM_Format:
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
if (!this->have_format)
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EIO;
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
if (result.index > 0)
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
alsa: add set_format for iec958 formats
2021-08-12 15:16:27 +02:00
switch (this->current_format.media_subtype) {
case SPA_MEDIA_SUBTYPE_raw:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_format_audio_raw_build(&b.b, id,
alsa: add set_format for iec958 formats
2021-08-12 15:16:27 +02:00
&this->current_format.info.raw);
break;
case SPA_MEDIA_SUBTYPE_iec958:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_format_audio_iec958_build(&b.b, id,
alsa: add set_format for iec958 formats
2021-08-12 15:16:27 +02:00
&this->current_format.info.iec958);
break;
alsa: add enumeration of DSD formats
2021-09-10 12:15:43 +02:00
case SPA_MEDIA_SUBTYPE_dsd:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_format_audio_dsd_build(&b.b, id,
alsa: add enumeration of DSD formats
2021-09-10 12:15:43 +02:00
&this->current_format.info.dsd);
break;
alsa: add set_format for iec958 formats
2021-08-12 15:16:27 +02:00
default:
return -EIO;
}
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_PARAM_Buffers:
alsa: increase buffers when using small buffer We can increase the MAX_LATENCY again if we increase the amount of buffers when we are using a small buffer. Normally we ask for 4 * quantum-limit as the buffer. This should be good to use 1 buffer and quantum-limit as the quantum with enough headroom to not run out of buffers. If we are however using less buffer-frames we need to be careful and allocate an extra buffer. Imagine using a buffer of 4096 frames, we can support a quantum of up to 2048 frames if we use 2 buffers. See #3744
2024-01-22 12:10:51 +01:00
{
uint32_t min_buffers;
Various fixes and improvements to enum_params
2017-11-08 11:22:42 +01:00
if (!this->have_format)
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EIO;
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
if (result.index > 0)
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
alsa: increase buffers when using small buffer We can increase the MAX_LATENCY again if we increase the amount of buffers when we are using a small buffer. Normally we ask for 4 * quantum-limit as the buffer. This should be good to use 1 buffer and quantum-limit as the quantum with enough headroom to not run out of buffers. If we are however using less buffer-frames we need to be careful and allocate an extra buffer. Imagine using a buffer of 4096 frames, we can support a quantum of up to 2048 frames if we use 2 buffers. See #3744
2024-01-22 12:10:51 +01:00
min_buffers = (this->quantum_limit * 4 * this->frame_scale) > this->buffer_frames ? 2 : 1;
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_pod_builder_add_object(&b.b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_ParamBuffers, id,
alsa: increase buffers when using small buffer We can increase the MAX_LATENCY again if we increase the amount of buffers when we are using a small buffer. Normally we ask for 4 * quantum-limit as the buffer. This should be good to use 1 buffer and quantum-limit as the quantum with enough headroom to not run out of buffers. If we are however using less buffer-frames we need to be careful and allocate an extra buffer. Imagine using a buffer of 4096 frames, we can support a quantum of up to 2048 frames if we use 2 buffers. See #3744
2024-01-22 12:10:51 +01:00
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(min_buffers, min_buffers, MAX_BUFFERS),
alsa: support planar formats
2020-07-01 11:42:10 +02:00
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(this->blocks),
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
pw-cat: fix DSF playback again Make the DSD buffers a little bigger because we scale down the rate. Read an interleaved number of samples to fill one quantum.
2022-04-28 12:32:08 +02:00
this->quantum_limit * this->frame_size * this->frame_scale,
16 * this->frame_size * this->frame_scale,
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
INT32_MAX),
buffers: make alignment optional Make the alignment parameter optional when negotiating buffers. Default to a 16 bytes alignment and adjust for the max cpu alignment. Remove the useless align buffer parameter in plugins, we always set it to 16 anyway.
2022-01-03 12:32:26 +01:00
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(this->frame_size));
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
alsa: increase buffers when using small buffer We can increase the MAX_LATENCY again if we increase the amount of buffers when we are using a small buffer. Normally we ask for 4 * quantum-limit as the buffer. This should be good to use 1 buffer and quantum-limit as the quantum with enough headroom to not run out of buffers. If we are however using less buffer-frames we need to be careful and allocate an extra buffer. Imagine using a buffer of 4096 frames, we can support a quantum of up to 2048 frames if we use 2 buffers. See #3744
2024-01-22 12:10:51 +01:00
}
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_PARAM_Meta:
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
switch (result.index) {
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
case 0:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_pod_builder_add_object(&b.b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_ParamMeta, id,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
break;
default:
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
}
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_PARAM_IO:
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
switch (result.index) {
spa: use clock info Use the port clock io area to get timing info and use this as the time in the graph when we wake up.
2018-07-17 17:37:55 +02:00
case 0:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_pod_builder_add_object(&b.b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_ParamIO, id,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
spa: use clock info Use the port clock io area to get timing info and use this as the time in the graph when we wake up.
2018-07-17 17:37:55 +02:00
break;
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
case 1:
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_pod_builder_add_object(&b.b,
alsa: rework timing Use a DLL to track the hardware pointer and use this to set the timer. Handle XRUN and recover.
2018-11-16 17:00:40 +01:00
SPA_TYPE_OBJECT_ParamIO, id,
Improve rate matching and clock slaving Use a new rate_match io area to exhange rate matching info between sink/source and resampler. Compensate for the rate match delay when scheduling timeouts. Let the resampler notify the source of how many samples it needs to produce the desired quantum. Make sure we keep an extra buffer in the device to be able to make this possible. Let the adapter directly call the slave node process function.
2019-07-09 16:56:05 +02:00
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_RateMatch),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_rate_match)));
alsa: rework timing Use a DLL to track the hardware pointer and use this to set the timer. Handle XRUN and recover.
2018-11-16 17:00:40 +01:00
break;
spa: use clock info Use the port clock io area to get timing info and use this as the time in the graph when we wake up.
2018-07-17 17:37:55 +02:00
default:
return 0;
}
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
spa: Implement latency reporting Implement latency reporting in alsa Implement latency reporting on audioconf by passing on the latency from the follower to outside of the adapter.
2021-05-21 10:01:37 +02:00
case SPA_PARAM_Latency:
switch (result.index) {
alsa: rename indexes into port and node params
2021-06-24 10:01:56 +02:00
case 0: case 1:
alsa: use ProcessLatency param to get and set internal latency
2021-08-17 09:14:40 +02:00
{
struct spa_latency_info latency = this->latency[result.index];
if (latency.direction == SPA_DIRECTION_INPUT)
spa_process_latency_info_add(&this->process_latency, &latency);
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
param = spa_latency_build(&b.b, id, &latency);
spa: Implement latency reporting Implement latency reporting in alsa Implement latency reporting on audioconf by passing on the latency from the follower to outside of the adapter.
2021-05-21 10:01:37 +02:00
break;
alsa: use ProcessLatency param to get and set internal latency
2021-08-17 09:14:40 +02:00
}
spa: Implement latency reporting Implement latency reporting in alsa Implement latency reporting on audioconf by passing on the latency from the follower to outside of the adapter.
2021-05-21 10:01:37 +02:00
default:
return 0;
}
break;
alsa: add Tag set and enum support So that we can see the tags on the sinks and sources.
2023-10-11 15:56:52 +02:00
case SPA_PARAM_Tag:
switch (result.index) {
case 0: case 1:
if ((param = this->tag[result.index]) == NULL)
goto next;
break;
default:
return 0;
}
break;
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
default:
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -ENOENT;
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
}
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
spa: use dynamic builder where we can With the spa_auto support this becomes feasable and avoids problems when the pod size is unknown and ends up larger than our stack buffer.
2023-10-11 18:04:17 +02:00
if (spa_pod_filter(&b.b, &result.param, param, filter) < 0)
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
goto next;
spa: add result type We need this to know the type of result, especially when serializing.
2019-05-28 13:59:48 +02:00
spa_node_emit_result(&this->hooks, seq, 0, SPA_RESULT_TYPE_NODE_PARAMS, &result);
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
if (++count != num)
goto next;
return 0;
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
}
static int clear_buffers(struct state *this)
{
if (this->n_buffers > 0) {
spa_list_init(&this->ready);
this->n_buffers = 0;
}
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int port_set_format(void *object,
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
enum spa_direction direction, uint32_t port_id,
uint32_t flags,
Improve enum_param Add an argument to pass the result param to the caller instead of having the caller have to pick it up from the builder. Improve docs for node, clock and monitor Pass spa_pod everywhere instead of spa_pod_object. Pass result argument to spa_pod_filter to make things a little nicer.
2017-11-13 17:57:38 +01:00
const struct spa_pod *format)
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
alsa: handle driver bugs better Use the NEAREST flag when setting a format. This only works for raw formats and will update the format with the nearest accepted rate or channels. We can then query the real configured format and use that for the converter. This makes things work when a driver tells us it can do 44100Hz but then refuses and changes the rate to 48000. See #2197, #2457, #2455, rhbz#2096193
2022-06-23 10:20:49 +02:00
int err = 0;
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
indent
2017-05-26 08:05:01 +02:00
if (format == NULL) {
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
if (!this->have_format)
return 0;
small cleanups
2018-05-10 11:23:51 +02:00
spa_log_debug(this->log, "clear format");
indent
2017-05-26 08:05:01 +02:00
spa_alsa_close(this);
alsa: refactor a bit Make spa_alsa_close() do spa_alsa_pause() first and also clear the format.
2021-11-23 12:20:27 +01:00
clear_buffers(this);
indent
2017-05-26 08:05:01 +02:00
} else {
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
struct spa_audio_info info = { 0 };
format: make helper function to parse media type
2018-08-29 14:50:58 +02:00
if ((err = spa_format_parse(format, &info.media_type, &info.media_subtype)) < 0)
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
return err;
format: improve format parsing
2017-03-24 18:11:11 +01:00
alsa: add set_format for iec958 formats
2021-08-12 15:16:27 +02:00
if (info.media_type != SPA_MEDIA_TYPE_audio)
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EINVAL;
format: improve format parsing
2017-03-24 18:11:11 +01:00
alsa: add set_format for iec958 formats
2021-08-12 15:16:27 +02:00
switch (info.media_subtype) {
case SPA_MEDIA_SUBTYPE_raw:
if (spa_format_audio_raw_parse(format, &info.info.raw) < 0)
return -EINVAL;
break;
case SPA_MEDIA_SUBTYPE_iec958:
if (spa_format_audio_iec958_parse(format, &info.info.iec958) < 0)
return -EINVAL;
break;
alsa: add enumeration of DSD formats
2021-09-10 12:15:43 +02:00
case SPA_MEDIA_SUBTYPE_dsd:
if (spa_format_audio_dsd_parse(format, &info.info.dsd) < 0)
return -EINVAL;
break;
alsa: add set_format for iec958 formats
2021-08-12 15:16:27 +02:00
default:
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EINVAL;
alsa: add set_format for iec958 formats
2021-08-12 15:16:27 +02:00
}
format: improve format parsing
2017-03-24 18:11:11 +01:00
Small fixes for error handling
2017-10-26 15:13:33 +02:00
if ((err = spa_alsa_set_format(this, &info, flags)) < 0)
return err;
format: improve format parsing
2017-03-24 18:11:11 +01:00
indent
2017-05-26 08:05:01 +02:00
this->current_format = info;
}
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
alsa: reconfigure max latency based on buffer size We can't ever support a latency larger than half the buffer size. Take a fourth of the buffer size to have some extre headroom. See #724
2021-03-02 10:34:41 +01:00
this->info.change_mask |= SPA_NODE_CHANGE_MASK_PROPS;
alsa: Share node/port info emission code between sink and source It's mostly the same, and it allows us to trigger this code in the shared alsa-pcm.c code as well.
2023-11-07 13:01:52 -05:00
spa_alsa_emit_node_info(this, false);
alsa: reconfigure max latency based on buffer size We can't ever support a latency larger than half the buffer size. Take a fourth of the buffer size to have some extre headroom. See #724
2021-03-02 10:34:41 +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
this->port_info.change_mask |= SPA_PORT_CHANGE_MASK_RATE;
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
this->port_info.rate = SPA_FRACTION(1, this->rate);
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
this->port_info.change_mask |= SPA_PORT_CHANGE_MASK_PARAMS;
indent
2017-05-26 08:05:01 +02:00
if (this->have_format) {
alsa: rename indexes into port and node params
2021-06-24 10:01:56 +02:00
this->port_params[PORT_Format] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_READWRITE);
this->port_params[PORT_Buffers] = SPA_PARAM_INFO(SPA_PARAM_Buffers, SPA_PARAM_INFO_READ);
alsa: emit param changes correctly Use the param user field to tag changes in the params. codec changes emits an EnumFormat and Props change. Accumulate various param changes and emit them together.
2021-09-01 12:57:47 +02:00
this->port_params[PORT_Latency].user++;
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
} else {
alsa: rename indexes into port and node params
2021-06-24 10:01:56 +02:00
this->port_params[PORT_Format] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
this->port_params[PORT_Buffers] = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
indent
2017-05-26 08:05:01 +02:00
}
alsa: Share node/port info emission code between sink and source It's mostly the same, and it allows us to trigger this code in the shared alsa-pcm.c code as well.
2023-11-07 13:01:52 -05:00
spa_alsa_emit_port_info(this, false);
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
alsa: handle driver bugs better Use the NEAREST flag when setting a format. This only works for raw formats and will update the format with the nearest accepted rate or channels. We can then query the real configured format and use that for the converter. This makes things work when a driver tells us it can do 44100Hz but then refuses and changes the rate to 48000. See #2197, #2457, #2455, rhbz#2096193
2022-06-23 10:20:49 +02:00
return err;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
}
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
static int
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
impl_node_port_set_param(void *object,
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t flags,
Improve enum_param Add an argument to pass the result param to the caller instead of having the caller have to pick it up from the builder. Improve docs for node, clock and monitor Pass spa_pod everywhere instead of spa_pod_object. Pass result argument to spa_pod_filter to make things a little nicer.
2017-11-13 17:57:38 +01:00
const struct spa_pod *param)
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
Port: Add tag param The tag param has a list of arbitrary key/value pairs. Like the Latency param, it travels up and downstream. Mixers will append the info dictionaries or do some more fancy merging. The purpose is to transport arbirary metadata, out-of-band, through the graph and it's used for stream metadata and other stream properties.
2023-08-24 16:41:21 +02:00
int res = 0;
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(this != NULL, -EINVAL);
indent
2017-05-26 08:05:01 +02:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
indent
2017-05-26 08:05:01 +02:00
alsa,bluez5: handle SPA_PARAM_Latency in port_set_param Simply return 0 instead of -ENOENT. Fixes #1262
2021-06-05 02:21:10 +08:00
switch (id) {
case SPA_PARAM_Format:
res = port_set_format(this, direction, port_id, flags, param);
break;
case SPA_PARAM_Latency:
alsa: keep track of input and output latency track and report both input and output latency.
2021-06-24 09:43:58 +02:00
{
alsa: clean up some latency param handling
2023-10-11 15:55:57 +02:00
enum spa_direction other = SPA_DIRECTION_REVERSE(direction);
alsa: keep track of input and output latency track and report both input and output latency.
2021-06-24 09:43:58 +02:00
struct spa_latency_info info;
alsa: don't crash on NULL params
2022-05-25 15:33:18 +02:00
if (param == NULL)
alsa: clean up some latency param handling
2023-10-11 15:55:57 +02:00
info = SPA_LATENCY_INFO(other);
alsa: don't crash on NULL params
2022-05-25 15:33:18 +02:00
else if ((res = spa_latency_parse(param, &info)) < 0)
alsa: keep track of input and output latency track and report both input and output latency.
2021-06-24 09:43:58 +02:00
return res;
alsa: clean up some latency param handling
2023-10-11 15:55:57 +02:00
if (info.direction != other)
alsa: keep track of input and output latency track and report both input and output latency.
2021-06-24 09:43:58 +02:00
return -EINVAL;
this->latency[info.direction] = info;
this->port_info.change_mask |= SPA_PORT_CHANGE_MASK_PARAMS;
alsa: emit param changes correctly Use the param user field to tag changes in the params. codec changes emits an EnumFormat and Props change. Accumulate various param changes and emit them together.
2021-09-01 12:57:47 +02:00
this->port_params[PORT_Latency].user++;
alsa: Share node/port info emission code between sink and source It's mostly the same, and it allows us to trigger this code in the shared alsa-pcm.c code as well.
2023-11-07 13:01:52 -05:00
spa_alsa_emit_port_info(this, false);
alsa,bluez5: handle SPA_PARAM_Latency in port_set_param Simply return 0 instead of -ENOENT. Fixes #1262
2021-06-05 02:21:10 +08:00
break;
alsa: keep track of input and output latency track and report both input and output latency.
2021-06-24 09:43:58 +02:00
}
Port: Add tag param The tag param has a list of arbitrary key/value pairs. Like the Latency param, it travels up and downstream. Mixers will append the info dictionaries or do some more fancy merging. The purpose is to transport arbirary metadata, out-of-band, through the graph and it's used for stream metadata and other stream properties.
2023-08-24 16:41:21 +02:00
case SPA_PARAM_Tag:
alsa: add Tag set and enum support So that we can see the tags on the sinks and sources.
2023-10-11 15:56:52 +02:00
{
enum spa_direction other = SPA_DIRECTION_REVERSE(direction);
if (param != NULL) {
struct spa_tag_info info;
void *state = NULL;
if (spa_tag_parse(param, &info, &state) < 0 ||
info.direction != other)
return -EINVAL;
}
if (spa_tag_compare(param, this->tag[other]) != 0) {
free(this->tag[other]);
this->tag[other] = param ? spa_pod_copy(param) : NULL;
this->port_info.change_mask |= SPA_PORT_CHANGE_MASK_PARAMS;
this->port_params[PORT_Tag].user++;
alsa: Share node/port info emission code between sink and source It's mostly the same, and it allows us to trigger this code in the shared alsa-pcm.c code as well.
2023-11-07 13:01:52 -05:00
spa_alsa_emit_port_info(this, false);
alsa: add Tag set and enum support So that we can see the tags on the sinks and sources.
2023-10-11 15:56:52 +02:00
}
Port: Add tag param The tag param has a list of arbitrary key/value pairs. Like the Latency param, it travels up and downstream. Mixers will append the info dictionaries or do some more fancy merging. The purpose is to transport arbirary metadata, out-of-band, through the graph and it's used for stream metadata and other stream properties.
2023-08-24 16:41:21 +02:00
break;
alsa: add Tag set and enum support So that we can see the tags on the sinks and sources.
2023-10-11 15:56:52 +02:00
}
alsa,bluez5: handle SPA_PARAM_Latency in port_set_param Simply return 0 instead of -ENOENT. Fixes #1262
2021-06-05 02:21:10 +08:00
default:
res = -ENOENT;
break;
indent
2017-05-26 08:05:01 +02:00
}
alsa,bluez5: handle SPA_PARAM_Latency in port_set_param Simply return 0 instead of -ENOENT. Fixes #1262
2021-06-05 02:21:10 +08:00
return res;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
}
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
static int
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
impl_node_port_use_buffers(void *object,
node: add flags to port_use_buffer Remove the CAN_USE_BUFFERS flag, it is redundant. We can know this because of the IO params and buffer params. Add flags to the port_use_buffer call. We also want this call to replace port_alloc_buffer. Together with a new result event we can ask the node to (a)synchronously fill up the buffer data for us. This is part of a plan to let remote nodes provide buffer data.
2019-07-25 13:19:39 +02:00
enum spa_direction direction, uint32_t port_id,
uint32_t flags,
struct spa_buffer **buffers, uint32_t n_buffers)
v4l2: add support for buffer import Add support for buffer import Rename some methods
2016-07-08 20:12:56 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
fix sign confusion
2019-01-07 15:52:42 +01:00
uint32_t i;
fix use_buffers checks We can set 0 buffers even if there is no format. Return -ENOSPC when too many buffers are set.
2023-01-10 12:30:25 +01:00
int res;
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(this != NULL, -EINVAL);
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
plugins: use macros for input checks That way we can compile them out if we want
2017-04-04 09:00:49 +02:00
alsa: don't prefix NAME, log topics are enough
2021-10-03 08:05:40 +02:00
spa_log_debug(this->log, "%p: use %d buffers", this, n_buffers);
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
fix use_buffers checks We can set 0 buffers even if there is no format. Return -ENOSPC when too many buffers are set.
2023-01-10 12:30:25 +01:00
if (this->n_buffers > 0) {
alsa: rework timing Use a DLL to track the hardware pointer and use this to set the timer. Handle XRUN and recover.
2018-11-16 17:00:40 +01:00
spa_alsa_pause(this);
fix use_buffers checks We can set 0 buffers even if there is no format. Return -ENOSPC when too many buffers are set.
2023-01-10 12:30:25 +01:00
if ((res = clear_buffers(this)) < 0)
return res;
indent
2017-05-26 08:05:01 +02:00
}
fix use_buffers checks We can set 0 buffers even if there is no format. Return -ENOSPC when too many buffers are set.
2023-01-10 12:30:25 +01:00
if (n_buffers > 0 && !this->have_format)
return -EIO;
if (n_buffers > MAX_BUFFERS)
return -ENOSPC;
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
indent
2017-05-26 08:05:01 +02:00
for (i = 0; i < n_buffers; i++) {
struct buffer *b = &this->buffers[i];
alsa: adjust latency based on buffer size
2018-04-30 09:27:20 +02:00
struct spa_data *d = buffers[i]->datas;
buffer: make data and meta types dynamic Use dynamic types for the data and meta types. Move the meta into a separate header. Remove port state, we can keep track of that ourselves. Add size to MetaDataEnable params
2017-04-26 18:42:50 +02:00
alsa: cleanups Use a periodic timer to catch underruns Small cleanups
2018-05-11 09:56:46 +02:00
b->buf = buffers[i];
buffer: remove buffer id The buffer id is not needed/used, we use the index of the buffer in the buffer array when configuring the port.
2019-01-07 17:57:03 +01:00
b->id = i;
alsa: small cleanups Use flags for buffers
2018-03-08 11:02:21 +01:00
b->flags = BUFFER_FLAG_OUT;
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
b->h = spa_buffer_find_meta_data(b->buf, SPA_META_Header, sizeof(*b->h));
buffer: make data and meta types dynamic Use dynamic types for the data and meta types. Move the meta into a separate header. Remove port state, we can keep track of that ourselves. Add size to MetaDataEnable params
2017-04-26 18:42:50 +02:00
plugins: just check the data pointer We don't need to look at the data type, we just just be happy when the data pointer is filled in.
2019-10-16 12:23:42 +02:00
if (d[0].data == NULL) {
alsa: don't prefix NAME, log topics are enough
2021-10-03 08:05:40 +02:00
spa_log_error(this->log, "%p: need mapped memory", this);
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
}
alsa: don't prefix NAME, log topics are enough
2021-10-03 08:05:40 +02:00
spa_log_debug(this->log, "%p: %d %p data:%p", this, i, b->buf, d[0].data);
indent
2017-05-26 08:05:01 +02:00
}
this->n_buffers = n_buffers;
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
v4l2: add support for buffer import Add support for buffer import Rename some methods
2016-07-08 20:12:56 +02:00
}
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
static int
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
impl_node_port_set_io(void *object,
node: Add id to set_io Make it possible to configure multiple io areas on a port by giving an id to set_io. Add some types to enumerate the supported ids Make an area to exchange buffers and one to specify pull ranges. The idea is to make more area types for controlable properties. Implement enumeration of IO areas in volume.
2017-11-21 19:34:37 +01:00
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
Add control properties to audiotestsrc Add control properties to audiotestsrc for frequency and volume and add a test program. Add size parameter to set_io for additional checks and to make it easy to know how much control data we can write.
2017-11-22 14:30:04 +01:00
void *data, size_t size)
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(this != NULL, -EINVAL);
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
alsa: don't prefix NAME, log topics are enough
2021-10-03 08:05:40 +02:00
spa_log_debug(this->log, "%p: io %d %p %zd", this, id, data, size);
Improve debug and small cleanups
2019-07-02 17:11:45 +02:00
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
switch (id) {
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_IO_Buffers:
Add control properties to audiotestsrc Add control properties to audiotestsrc for frequency and volume and add a test program. Add size parameter to set_io for additional checks and to make it easy to know how much control data we can write.
2017-11-22 14:30:04 +01:00
this->io = data;
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
Improve rate matching and clock slaving Use a new rate_match io area to exhange rate matching info between sink/source and resampler. Compensate for the rate match delay when scheduling timeouts. Let the resampler notify the source of how many samples it needs to produce the desired quantum. Make sure we keep an extra buffer in the device to be able to make this possible. Let the adapter directly call the slave node process function.
2019-07-09 16:56:05 +02:00
case SPA_IO_RateMatch:
this->rate_match = data;
spa: alsa: Add a NULL check before updating rate match The RateMatch IO might be NULL for the driver, and trying to update rate matching with state->rate_match crashes in this case.
2024-12-05 13:08:04 -05:00
if (this->rate_match)
spa_alsa_update_rate_match(this);
alsa: rework timing Use a DLL to track the hardware pointer and use this to set the timer. Handle XRUN and recover.
2018-11-16 17:00:40 +01:00
break;
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
default:
node: Add id to set_io Make it possible to configure multiple io areas on a port by giving an id to set_io. Add some types to enumerate the supported ids Make an area to exchange buffers and one to specify pull ranges. The idea is to make more area types for controlable properties. Implement enumeration of IO areas in volume.
2017-11-21 19:34:37 +01:00
return -ENOENT;
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
}
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
Work on memory allocation We now only allow per port preallocated buffers. We exchange the index into the array instead of passing the buffers around. We still use the refcount to track when a buffer can be reused. Improve API a little, allow passing the node as the first argument of the interface call. Implement alloc_buffer in v4l2 and improve the test.
2016-07-30 20:35:34 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int impl_node_port_reuse_buffer(void *object, uint32_t port_id, uint32_t buffer_id)
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
{
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -ENOTSUP;
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int impl_node_process(void *object)
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = object;
spa: clean up some port io checks We should not generate a warning.
2022-09-01 15:39:34 +02:00
struct spa_io_buffers *io;
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
spa_return_val_if_fail(this != NULL, -EINVAL);
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
spa: clean up some port io checks We should not generate a warning.
2022-09-01 15:39:34 +02:00
if ((io = this->io) == NULL)
return -EIO;
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
spa: clean up some port io checks We should not generate a warning.
2022-09-01 15:39:34 +02:00
spa_log_trace_fp(this->log, "%p: process %d %d/%d", this, io->status,
io->buffer_id, this->n_buffers);
alsa: pause/resume when entering/exiting freewheel When we start freewheeling, pause the device and resume when we finish freewheel. In freewheel mode, just discard samples in the sink and produce silence in the source.
2021-05-07 11:51:22 +02:00
spa: make a new FREEWHEEL clock flag When freewheeling, the clock is going faster than real time. When freewheeling, skip samples in alsa sink/source.
2021-05-06 18:14:07 +02:00
if (this->position && this->position->clock.flags & SPA_IO_CLOCK_FLAG_FREEWHEEL) {
spa: clean up some port io checks We should not generate a warning.
2022-09-01 15:39:34 +02:00
io->status = SPA_STATUS_NEED_DATA;
alsa: pause/resume when entering/exiting freewheel When we start freewheeling, pause the device and resume when we finish freewheel. In freewheel mode, just discard samples in the sink and produce silence in the source.
2021-05-07 11:51:22 +02:00
return SPA_STATUS_HAVE_DATA;
}
spa: clean up some port io checks We should not generate a warning.
2022-09-01 15:39:34 +02:00
if (io->status == SPA_STATUS_HAVE_DATA &&
io->buffer_id < this->n_buffers) {
struct buffer *b = &this->buffers[io->buffer_id];
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
flags: change flag macros SPA_FLAG_CHECK -> SPA_FLAG_IS_SET SPA_FLAG_UNSET -> SPA_FLAG_CLEAR Add SPA_FLAG_UPDATE
2019-10-02 17:58:04 +02:00
if (!SPA_FLAG_IS_SET(b->flags, BUFFER_FLAG_OUT)) {
alsa: don't prefix NAME, log topics are enough
2021-10-03 08:05:40 +02:00
spa_log_warn(this->log, "%p: buffer %u in use",
spa: clean up some port io checks We should not generate a warning.
2022-09-01 15:39:34 +02:00
this, io->buffer_id);
io->status = -EINVAL;
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
}
spa: clean up some port io checks We should not generate a warning.
2022-09-01 15:39:34 +02:00
spa_log_trace_fp(this->log, "%p: queue buffer %u", this, io->buffer_id);
use spa_list_append when we can
2017-10-24 12:58:10 +02:00
spa_list_append(&this->ready, &b->link);
flags: change flag macros SPA_FLAG_CHECK -> SPA_FLAG_IS_SET SPA_FLAG_UNSET -> SPA_FLAG_CLEAR Add SPA_FLAG_UPDATE
2019-10-02 17:58:04 +02:00
SPA_FLAG_CLEAR(b->flags, BUFFER_FLAG_OUT);
spa: clean up some port io checks We should not generate a warning.
2022-09-01 15:39:34 +02:00
io->buffer_id = SPA_ID_INVALID;
indent
2017-05-26 08:05:01 +02:00
}
alsa: small cleanup We always try to write when we have data so we can make this code path common.
2023-09-08 12:19:52 +02:00
if (!spa_list_is_empty(&this->ready)) {
alsa: improve audio output to multiple devices There are currently several issues when multiple alsa devices are involved. For alsa devices that are followers, all data is written via impl_node_process(). Currently spa_alsa_write() is only called if a new buffer was queued. It can happen that all buffers are in the ready list (queued by previous calls but not yet written because there was no free space in the kernel ring buffer). In this case writing stalls indefinitely. To fix this, also call spa_alsa_write() if no new buffer is queued but there are still buffers in the ready list. If the ready list of the primary device is not empty then only this device is handled because spa_alsa_write() is called directly. The other devices make no progress during this interval. The clock drift calculation works by comparing the alsa delay with the expected delay since the last wakeup. This only work if the alsa ringbuffer was filled completly. If the ready list contains a partial buffer then the ringbuffer is not filled and the timing calculation during the next wakeup is incorrect. To fix all this, remove the special case for the non-empty ready list and just call spa_node_call_ready() every time.
2023-06-21 11:18:43 +02:00
spa_alsa_write(this);
io->status = SPA_STATUS_OK;
}
rename HAVE/NEED_BUFFER -> HAVE/NEED_DATA It is more generic and works with control-only ports as well
2019-09-16 12:55:23 +02:00
return SPA_STATUS_HAVE_DATA;
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct spa_node_methods impl_node = {
SPA_VERSION_NODE_METHODS,
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
.add_listener = impl_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,
spa: implement node sync
2019-05-28 14:01:18 +02:00
.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_set_io = impl_node_port_set_io,
.port_reuse_buffer = impl_node_port_reuse_buffer,
.process = impl_node_process,
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
};
Make interface types a string This is more in line with wayland and it allows us to create new interfaces in modules without having to add anything to the type enum. It also removes some lookups to map type_id to readable name in debug.
2019-12-19 13:15:10 +01:00
static int impl_get_interface(struct spa_handle *handle, const char *type, void **interface)
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
{
indent
2017-05-26 08:05:01 +02:00
struct state *this;
Work on memory allocation We now only allow per port preallocated buffers. We exchange the index into the array instead of passing the buffers around. We still use the refcount to track when a buffer can be reused. Improve API a little, allow passing the node as the first argument of the interface call. Implement alloc_buffer in v4l2 and improve the test.
2016-07-30 20:35:34 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
spa_return_val_if_fail(handle != NULL, -EINVAL);
spa_return_val_if_fail(interface != NULL, -EINVAL);
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
indent
2017-05-26 08:05:01 +02:00
this = (struct state *) handle;
Work on memory allocation We now only allow per port preallocated buffers. We exchange the index into the array instead of passing the buffers around. We still use the refcount to track when a buffer can be reused. Improve API a little, allow passing the node as the first argument of the interface call. Implement alloc_buffer in v4l2 and improve the test.
2016-07-30 20:35:34 +02:00
treewide: replace strcmp() == 0 with spa_streq() This change is only done in source files for now, header files will be done separately.
2021-05-18 11:36:13 +10:00
if (spa_streq(type, SPA_TYPE_INTERFACE_Node))
indent
2017-05-26 08:05:01 +02:00
*interface = &this->node;
else
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -ENOENT;
Add mapper Ger rid of static ids for interfaces and replace with something we can register dynamically Implement logger.
2016-10-07 13:14:32 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
}
indent
2017-05-26 08:05:01 +02:00
static int impl_clear(struct spa_handle *handle)
cleanups Remove some unused things. Work on shutdown.
2016-09-01 10:04:25 +02:00
{
acp: clean up card object Fixes #369
2020-11-09 15:01:07 +01:00
struct state *this;
spa_return_val_if_fail(handle != NULL, -EINVAL);
this = (struct state *) handle;
spa_alsa_close(this);
alsa: if we are passed a UCM device, make sure to open UCM UCM devices can require local data from use_case_mgr_open() but since we do that in a separate process, make sure we reopen the use case manager in case we are passed a UCM device so that the config is available. See #1251
2021-06-02 13:23:08 +02:00
spa_alsa_clear(this);
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
cleanups Remove some unused things. Work on shutdown.
2016-09-01 10:04:25 +02:00
}
handle: make method to get size
2018-04-09 10:06:17 +02:00
static size_t
impl_get_size(const struct spa_handle_factory *factory,
const struct spa_dict *params)
{
return sizeof(struct state);
}
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
static int
indent
2017-05-26 08:05:01 +02:00
impl_init(const struct spa_handle_factory *factory,
struct spa_handle *handle, const struct spa_dict *info, const struct spa_support *support, uint32_t n_support)
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
{
indent
2017-05-26 08:05:01 +02:00
struct state *this;
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
spa_return_val_if_fail(factory != NULL, -EINVAL);
spa_return_val_if_fail(handle != NULL, -EINVAL);
indent
2017-05-26 08:05:01 +02:00
handle->get_interface = impl_get_interface;
handle->clear = impl_clear;
this = (struct state *) handle;
Make interface types a string This is more in line with wayland and it allows us to create new interfaces in modules without having to add anything to the type enum. It also removes some lookups to map type_id to readable name in debug.
2019-12-19 13:15:10 +01:00
this->log = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Log);
spa: implement a log topic for alsa
2021-09-23 14:25:32 +10:00
alsa_log_topic_init(this->log);
alsa: remove stray log line
2021-11-17 10:52:43 +01:00
Make interface types a string This is more in line with wayland and it allows us to create new interfaces in modules without having to add anything to the type enum. It also removes some lookups to map type_id to readable name in debug.
2019-12-19 13:15:10 +01:00
this->data_system = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_DataSystem);
this->data_loop = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_DataLoop);
alsa: Move ctl sources to a main loop It doesn't make sense to hang these on the data loop, so let's have these on the main loop instead. Also avoids a potential crash while removing them (since removal happens on the main loop and the data loop might be polling while we're doing the remove).
2023-11-21 17:05:24 -05:00
this->main_loop = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Loop);
Make interface types a string This is more in line with wayland and it allows us to create new interfaces in modules without having to add anything to the type enum. It also removes some lookups to map type_id to readable name in debug.
2019-12-19 13:15:10 +01:00
alsa: Move ctl sources to a main loop It doesn't make sense to hang these on the data loop, so let's have these on the main loop instead. Also avoids a potential crash while removing them (since removal happens on the main loop and the data loop might be polling while we're doing the remove).
2023-11-21 17:05:24 -05:00
if (this->main_loop == NULL) {
spa_log_error(this->log, "a main loop is needed");
return -EINVAL;
}
indent
2017-05-26 08:05:01 +02:00
if (this->data_loop == NULL) {
spa_log_error(this->log, "a data loop is needed");
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
}
simply use INTERFACE_Loop for the main-loop
2019-06-06 15:20:43 +02:00
if (this->data_system == NULL) {
spa_log_error(this->log, "a data system is needed");
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EINVAL;
indent
2017-05-26 08:05:01 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
this->node.iface = SPA_INTERFACE_INIT(
SPA_TYPE_INTERFACE_Node,
SPA_VERSION_NODE,
&impl_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
spa_hook_list_init(&this->hooks);
indent
2017-05-26 08:05:01 +02:00
this->stream = SND_PCM_STREAM_PLAYBACK;
alsa: keep track of input and output latency track and report both input and output latency.
2021-06-24 09:43:58 +02:00
this->port_direction = SPA_DIRECTION_INPUT;
this->latency[this->port_direction] = SPA_LATENCY_INFO(
this->port_direction,
.min_quantum = 1.0f,
.max_quantum = 1.0f);
this->latency[SPA_DIRECTION_OUTPUT] = SPA_LATENCY_INFO(SPA_DIRECTION_OUTPUT);
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
this->info_all = SPA_NODE_CHANGE_MASK_FLAGS |
SPA_NODE_CHANGE_MASK_PROPS |
SPA_NODE_CHANGE_MASK_PARAMS;
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
this->info = SPA_NODE_INFO_INIT();
this->info.max_input_ports = 1;
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
this->info.flags = SPA_NODE_FLAG_RT;
alsa: rename indexes into port and node params
2021-06-24 10:01:56 +02:00
this->params[NODE_PropInfo] = SPA_PARAM_INFO(SPA_PARAM_PropInfo, SPA_PARAM_INFO_READ);
this->params[NODE_Props] = SPA_PARAM_INFO(SPA_PARAM_Props, SPA_PARAM_INFO_READWRITE);
this->params[NODE_IO] = SPA_PARAM_INFO(SPA_PARAM_IO, SPA_PARAM_INFO_READ);
alsa: use ProcessLatency param to get and set internal latency
2021-08-17 09:14:40 +02:00
this->params[NODE_ProcessLatency] = SPA_PARAM_INFO(SPA_PARAM_ProcessLatency, SPA_PARAM_INFO_READWRITE);
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
this->info.params = this->params;
alsa: clean up port and node params
2021-05-21 11:08:52 +02:00
this->info.n_params = N_NODE_PARAMS;
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
indent
2017-05-26 08:05:01 +02:00
reset_props(&this->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
this->port_info_all = SPA_PORT_CHANGE_MASK_FLAGS |
SPA_PORT_CHANGE_MASK_PARAMS;
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
this->port_info = SPA_PORT_INFO_INIT();
node: add flags to port_use_buffer Remove the CAN_USE_BUFFERS flag, it is redundant. We can know this because of the IO params and buffer params. Add flags to the port_use_buffer call. We also want this call to replace port_alloc_buffer. Together with a new result event we can ask the node to (a)synchronously fill up the buffer data for us. This is part of a plan to let remote nodes provide buffer data.
2019-07-25 13:19:39 +02:00
this->port_info.flags = SPA_PORT_FLAG_LIVE |
node: add max_ports to node info
2019-02-14 17:40:01 +01:00
SPA_PORT_FLAG_PHYSICAL |
SPA_PORT_FLAG_TERMINAL;
alsa: rename indexes into port and node params
2021-06-24 10:01:56 +02:00
this->port_params[PORT_EnumFormat] = SPA_PARAM_INFO(SPA_PARAM_EnumFormat, SPA_PARAM_INFO_READ);
this->port_params[PORT_Meta] = SPA_PARAM_INFO(SPA_PARAM_Meta, SPA_PARAM_INFO_READ);
this->port_params[PORT_IO] = SPA_PARAM_INFO(SPA_PARAM_IO, SPA_PARAM_INFO_READ);
this->port_params[PORT_Format] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
this->port_params[PORT_Buffers] = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
this->port_params[PORT_Latency] = SPA_PARAM_INFO(SPA_PARAM_Latency, SPA_PARAM_INFO_READWRITE);
alsa: add Tag set and enum support So that we can see the tags on the sinks and sources.
2023-10-11 15:56:52 +02:00
this->port_params[PORT_Tag] = SPA_PARAM_INFO(SPA_PARAM_Tag, SPA_PARAM_INFO_READWRITE);
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
this->port_info.params = this->port_params;
alsa: clean up port and node params
2021-05-21 11:08:52 +02:00
this->port_info.n_params = N_PORT_PARAMS;
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
indent
2017-05-26 08:05:01 +02:00
spa_list_init(&this->ready);
alsa: refactor property parsing Move the common property parsing to the init function.
2021-11-23 12:27:36 +01:00
return spa_alsa_init(this, info);
more hacking Move plugin API to separate directory for now Add ringbuffer and way to get ringbuffer from a port
2016-06-28 12:21:56 +02:00
}
More hacking Add spa based v4l2 pinos module Add allocation params to port_alloc_buffers Let the app do allocation for handles.
2016-07-13 18:29:55 +02:00
indent
2017-05-26 08:05:01 +02:00
static const struct spa_interface_info impl_interfaces[] = {
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
{SPA_TYPE_INTERFACE_Node,},
More hacking Add spa based v4l2 pinos module Add allocation params to port_alloc_buffers Let the app do allocation for handles.
2016-07-13 18:29:55 +02:00
};
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
static int
indent
2017-05-26 08:05:01 +02:00
impl_enum_interface_info(const struct spa_handle_factory *factory,
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
const struct spa_interface_info **info, uint32_t *index)
More hacking Add spa based v4l2 pinos module Add allocation params to port_alloc_buffers Let the app do allocation for handles.
2016-07-13 18:29:55 +02:00
{
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
spa_return_val_if_fail(factory != NULL, -EINVAL);
spa_return_val_if_fail(info != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
indent
2017-05-26 08:05:01 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
switch (*index) {
indent
2017-05-26 08:05:01 +02:00
case 0:
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
*info = &impl_interfaces[*index];
indent
2017-05-26 08:05:01 +02:00
break;
default:
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
indent
2017-05-26 08:05:01 +02:00
}
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
(*index)++;
return 1;
More hacking Add spa based v4l2 pinos module Add allocation params to port_alloc_buffers Let the app do allocation for handles.
2016-07-13 18:29:55 +02:00
}
Add more generic export-spa example Replace the v4l2 example with a more generic version that can add any spa node to a remote graph Make the dictionary items const Add some info to nodes and factories. Add the node info to the node properties. We can then set the media.class directly on the node, instead of letting the monitor set it. Debug node info in spa-inspect. Do async operation on the audiotestsrc and videotestsrc differently.
2017-09-07 19:55:22 +02:00
static const struct spa_dict_item info_items[] = {
spa: add keys for properties Define and document property keys
2019-06-03 16:48:01 +02:00
{ SPA_KEY_FACTORY_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>" },
{ SPA_KEY_FACTORY_DESCRIPTION, "Play audio with the alsa API" },
{ SPA_KEY_FACTORY_USAGE, "["SPA_KEY_API_ALSA_PATH"=<path>]" },
Add more generic export-spa example Replace the v4l2 example with a more generic version that can add any spa node to a remote graph Make the dictionary items const Add some info to nodes and factories. Add the node info to the node properties. We can then set the media.class directly on the node, instead of letting the monitor set it. Debug node info in spa-inspect. Do async operation on the audiotestsrc and videotestsrc differently.
2017-09-07 19:55:22 +02:00
};
reorganize some struct members to remove holes
2019-02-08 12:01:50 +01:00
static const struct spa_dict info = SPA_DICT_INIT_ARRAY(info_items);
Add more generic export-spa example Replace the v4l2 example with a more generic version that can add any spa node to a remote graph Make the dictionary items const Add some info to nodes and factories. Add the node info to the node properties. We can then set the media.class directly on the node, instead of letting the monitor set it. Debug node info in spa-inspect. Do async operation on the audiotestsrc and videotestsrc differently.
2017-09-07 19:55:22 +02:00
indent
2017-05-26 08:05:01 +02:00
const struct spa_handle_factory spa_alsa_sink_factory = {
Add versions to structures Use versions instead of size Remove user_data from callbacks, we can simply pass the callback struct.
2017-06-14 18:32:39 +02:00
SPA_VERSION_HANDLE_FACTORY,
names: add standard factory name definitions Define a set of standard factory names and document what they contain. This makes it possible to change the implementation by mapping the factory-name to a different shared library.
2019-06-21 13:31:34 +02:00
SPA_NAME_API_ALSA_PCM_SINK,
Add more generic export-spa example Replace the v4l2 example with a more generic version that can add any spa node to a remote graph Make the dictionary items const Add some info to nodes and factories. Add the node info to the node properties. We can then set the media.class directly on the node, instead of letting the monitor set it. Debug node info in spa-inspect. Do async operation on the audiotestsrc and videotestsrc differently.
2017-09-07 19:55:22 +02:00
&info,
handle: make method to get size
2018-04-09 10:06:17 +02:00
impl_get_size,
indent
2017-05-26 08:05:01 +02:00
impl_init,
impl_enum_interface_info,
More hacking Add spa based v4l2 pinos module Add allocation params to port_alloc_buffers Let the app do allocation for handles.
2016-07-13 18:29:55 +02:00
};
Reference in a new issue Copy permalink