mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-03 09:01:54 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
pipewire/spa/plugins/alsa/alsa-pcm-source.c

867 lines
23 KiB
C
Raw Normal View History

Cleanups
2016-09-20 11:20:43 +02:00
/* Spa ALSA Source
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* Copyright © 2018 Wim Taymans
Cleanups
2016-09-20 11:20:43 +02:00
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
Cleanups
2016-09-20 11:20:43 +02:00
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
Cleanups
2016-09-20 11:20:43 +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>
Cleanups
2016-09-20 11:20:43 +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>
Add include of keys.h
2019-11-18 10:10:58 +01:00
#include <spa/node/keys.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>
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/utils/list.h>
spa: add keys for properties Define and document property keys
2019-06-03 16:48:01 +02:00
#include <spa/monitor/device.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>
Cleanups
2016-09-20 11:20:43 +02:00
improve properties on node and port Rename some alsa filenames.
2019-09-23 20:51:34 +02:00
#define NAME "alsa-pcm-source"
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
improve properties on node and port Rename some alsa filenames.
2019-09-23 20:51:34 +02:00
#include "alsa-pcm.h"
Cleanups
2016-09-20 11:20:43 +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_OUTPUT && (p) == 0)
Cleanups
2016-09-20 11:20:43 +02:00
static const char default_device[] = "hw:0";
add some constants for max samples
2019-10-24 12:35:00 +02:00
static const uint32_t default_min_latency = MIN_LATENCY;
static const uint32_t default_max_latency = MAX_LATENCY;
Cleanups
2016-09-20 11:20:43 +02:00
indent
2017-05-26 08:05:01 +02:00
static void reset_props(struct props *props)
Cleanups
2016-09-20 11:20:43 +02:00
{
indent
2017-05-26 08:05:01 +02:00
strncpy(props->device, default_device, 64);
props->min_latency = default_min_latency;
alsa: adjust latency based on buffer size
2018-04-30 09:27:20 +02:00
props->max_latency = default_max_latency;
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;
Cleanups
2016-09-20 11:20:43 +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)
Cleanups
2016-09-20 11:20:43 +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;
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];
struct spa_pod_builder b = { 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
struct props *p;
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;
Cleanups
2016-09-20 11:20:43 +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);
Cleanups
2016-09-20 11:20:43 +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
p = &this->props;
Cleanups
2016-09-20 11:20:43 +02:00
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
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++;
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
spa_pod_builder_init(&b, buffer, sizeof(buffer));
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:
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:
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
param = spa_pod_builder_add_object(&b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_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),
SPA_PROP_INFO_name, SPA_POD_String("The ALSA device"),
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:
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
param = spa_pod_builder_add_object(&b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_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),
SPA_PROP_INFO_name, SPA_POD_String("The ALSA device name"),
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:
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
param = spa_pod_builder_add_object(&b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_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),
SPA_PROP_INFO_name, SPA_POD_String("The ALSA card name"),
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:
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
param = spa_pod_builder_add_object(&b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_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_minLatency),
SPA_PROP_INFO_name, SPA_POD_String("The minimum latency"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(p->min_latency, 1, INT32_MAX));
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;
alsa: adjust latency based on buffer size
2018-04-30 09:27:20 +02:00
case 4:
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
param = spa_pod_builder_add_object(&b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_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_maxLatency),
SPA_PROP_INFO_name, SPA_POD_String("The maximum latency"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(p->max_latency, 1, INT32_MAX));
alsa: adjust latency based on buffer size
2018-04-30 09:27:20 +02:00
break;
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
case 5:
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_START_CUSTOM),
SPA_PROP_INFO_name, SPA_POD_String("Use the driver channelmap"),
SPA_PROP_INFO_type, SPA_POD_Bool(p->use_chmap));
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:
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;
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:
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:
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
param = spa_pod_builder_add_object(&b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_Props, id,
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)),
SPA_PROP_minLatency, SPA_POD_Int(p->min_latency),
SPA_PROP_maxLatency, SPA_POD_Int(p->max_latency),
SPA_PROP_START_CUSTOM, SPA_POD_Bool(p->use_chmap));
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;
alsa: advertize node params correctly
2019-08-21 13:05:52 +02:00
case SPA_PARAM_IO:
switch (result.index) {
case 0:
param = spa_pod_builder_add_object(&b,
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:
param = spa_pod_builder_add_object(&b,
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;
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
}
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 (spa_pod_filter(&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;
Cleanups
2016-09-20 11:20:43 +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: Disable rate matching for the same card Add a clock name to the clock, remove the old api/clock_id. This makes it easier to add descriptive names Place the alsa card number in the clock name. Check the clock name of the master clock and if it matches our own clock, disable rate matching.
2019-10-23 16:04:03 +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:
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: 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
}
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)
Cleanups
2016-09-20 11:20:43 +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;
Cleanups
2016-09-20 11:20:43 +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);
Cleanups
2016-09-20 11:20:43 +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_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;
if (param == NULL) {
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;
Various fixes and improvements to enum_params
2017-11-08 11:22:42 +01:00
}
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
spa_pod_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)),
SPA_PROP_minLatency, SPA_POD_OPT_Int(&p->min_latency),
SPA_PROP_maxLatency, SPA_POD_OPT_Int(&p->max_latency),
SPA_PROP_START_CUSTOM, SPA_POD_OPT_Bool(&p->use_chmap));
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
}
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
}
Cleanups
2016-09-20 11:20:43 +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;
Cleanups
2016-09-20 11:20:43 +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)
Cleanups
2016-09-20 11:20:43 +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;
Cleanups
2016-09-20 11:20:43 +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);
Cleanups
2016-09-20 11:20:43 +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:
if ((res = spa_alsa_open(this)) < 0)
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;
Cleanups
2016-09-20 11:20:43 +02:00
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;
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:
pcm: don't complain on Suspend
2019-10-22 12:20:29 +02:00
case SPA_NODE_COMMAND_Suspend:
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
}
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
2016-09-20 11:20:43 +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
static const struct spa_dict_item node_info_items[] = {
spa: add keys for properties Define and document property keys
2019-06-03 16:48:01 +02:00
{ SPA_KEY_DEVICE_API, "alsa" },
{ SPA_KEY_MEDIA_CLASS, "Audio/Source" },
{ SPA_KEY_NODE_DRIVER, "true" },
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 void emit_node_info(struct state *this, bool full)
node: Add port_info event Add a port_info event. With this, we get updates to ports pushed to us, which is more convenient and also allows for better dynamic add/remove of ports. We don't need to the PortChanged event anymore We can remove the get_port_ids/get_n_ports/port_get_info methods. Update plugins
2019-02-14 17:08:46 +01:00
{
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
if (full)
this->info.change_mask = this->info_all;
if (this->info.change_mask) {
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.props = &SPA_DICT_INIT_ARRAY(node_info_items);
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
spa_node_emit_info(&this->hooks, &this->info);
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
this->info.change_mask = 0;
node: Add port_info event Add a port_info event. With this, we get updates to ports pushed to us, which is more convenient and also allows for better dynamic add/remove of ports. We don't need to the PortChanged event anymore We can remove the get_port_ids/get_n_ports/port_get_info methods. Update plugins
2019-02-14 17:08:46 +01:00
}
}
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 void emit_port_info(struct state *this, bool full)
node: Add port_info event Add a port_info event. With this, we get updates to ports pushed to us, which is more convenient and also allows for better dynamic add/remove of ports. We don't need to the PortChanged event anymore We can remove the get_port_ids/get_n_ports/port_get_info methods. Update plugins
2019-02-14 17:08:46 +01:00
{
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
if (full)
this->port_info.change_mask = this->port_info_all;
if (this->port_info.change_mask) {
spa_node_emit_port_info(&this->hooks,
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
SPA_DIRECTION_OUTPUT, 0, &this->port_info);
this->port_info.change_mask = 0;
node: Add port_info event Add a port_info event. With this, we get updates to ports pushed to us, which is more convenient and also allows for better dynamic add/remove of ports. We don't need to the PortChanged event anymore We can remove the get_port_ids/get_n_ports/port_get_info methods. Update plugins
2019-02-14 17:08:46 +01:00
}
}
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);
emit_node_info(this, true);
emit_port_info(this, true);
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)
Cleanups
2016-09-20 11:20:43 +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;
Cleanups
2016-09-20 11:20:43 +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);
Cleanups
2016-09-20 11:20:43 +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);
Cleanups
2016-09-20 11:20:43 +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;
Cleanups
2016-09-20 11:20:43 +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)
Cleanups
2016-09-20 11:20:43 +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;
Cleanups
2016-09-20 11:20:43 +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)
Cleanups
2016-09-20 11:20:43 +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;
Cleanups
2016-09-20 11:20:43 +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)
Cleanups
2016-09-20 11:20:43 +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;
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
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
struct spa_result_node_params result;
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
uint32_t count = 0;
Cleanups
2016-09-20 11:20:43 +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);
Cleanups
2016-09-20 11:20:43 +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);
Cleanups
2016-09-20 11:20:43 +02:00
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
result.id = id;
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++;
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
spa_pod_builder_init(&b, buffer, sizeof(buffer));
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:
format: make helper function to parse media type
2018-08-29 14:50:58 +02:00
if (!this->have_format)
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)
format: make helper function to parse media type
2018-08-29 14:50:58 +02:00
return 0;
param = spa_format_audio_raw_build(&b, id, &this->current_format.info.raw);
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:
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;
small cleanups Remove the temp storage for formats and props now that we get a builder from the host to write into.
2017-11-07 20:28:07 +01:00
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
param = spa_pod_builder_add_object(&b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_ParamBuffers, id,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 1, 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(
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
this->props.max_latency * this->frame_size,
this->props.min_latency * this->frame_size,
INT32_MAX),
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_stride, SPA_POD_Int(this->frame_size),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
break;
More type fixes Param ids and IO ids are now simple enums. Move some type info in one place, delete some type-info files Fix type debug Make audio layout an enum Mark more enums as enums in types so they show us with their names in the debug.
2018-08-25 12:08:29 +02:00
case SPA_PARAM_Meta:
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
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:
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
param = spa_pod_builder_add_object(&b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_ParamMeta, id,
pod: improve the vararg pod builder and parser Automatically parse and build key/value when in objects without having to prefix the key with ":" Automatically build control/value when in sequence without the "." prefix. Remove the builder with key/pod, taking a reference to the stack built temporary pods is not allowed in c++. We can use the varargs version with the same convenient syntax. Remove the parser "*" option, it is unused. Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them look similar.
2019-01-16 11:05:12 +01:00
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
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:
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
param = spa_pod_builder_add_object(&b,
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
SPA_TYPE_OBJECT_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:
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
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_RateMatch),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_rate_match)));
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;
default:
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -ENOENT;
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
}
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
if (spa_pod_filter(&b, &result.param, param, filter) < 0)
goto next;
spa: add result type We need this to know the type of result, especially when serializing.
2019-05-28 13:59:48 +02:00
spa_node_emit_result(&this->hooks, seq, 0, SPA_RESULT_TYPE_NODE_PARAMS, &result);
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
if (++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;
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->free);
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,
Improve enum_param Add an argument to pass the result param to the caller instead of having the caller have to pick it up from the builder. Improve docs for node, clock and monitor Pass spa_pod everywhere instead of spa_pod_object. Pass result argument to spa_pod_filter to make things a little nicer.
2017-11-13 17:57:38 +01:00
uint32_t flags, const struct spa_pod *format)
Unify props, params and formats Make enum_params and set_param to configure properties, format and other parameters. This allows us to remove some duplicate code and make the properties and parameters much more extensible. Use the object id to mark the id of the parameter. Remove the spa_format and spa_props. We can now make the client-node easier by merging the various format methods into the params. Make the stream API more powerful now that we can pass params around.
2017-11-07 17:39:31 +01:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct state *this = 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
int err;
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;
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);
indent
2017-05-26 08:05:01 +02:00
clear_buffers(this);
spa_alsa_close(this);
this->have_format = false;
} 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)
return err;
Cleanups
2016-09-20 11:20:43 +02:00
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
if (info.media_type != SPA_MEDIA_TYPE_audio ||
info.media_subtype != SPA_MEDIA_SUBTYPE_raw)
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;
Make AllocParams into POD objects Make allocparams into pod objects. This makes it easy to serialize, copy, create and intersect them. Add convenience macros for properties Add helper function to collect object properties.
2017-03-17 11:58:09 +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
if (spa_format_audio_raw_parse(format, &info.info.raw) < 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 -EINVAL;
Make AllocParams into POD objects Make allocparams into pod objects. This makes it easy to serialize, copy, create and intersect them. Add convenience macros for properties Add helper function to collect object properties.
2017-03-17 11:58:09 +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;
Make AllocParams into POD objects Make allocparams into pod objects. This makes it easy to serialize, copy, create and intersect them. Add convenience macros for properties Add helper function to collect object properties.
2017-03-17 11:58:09 +01:00
indent
2017-05-26 08:05:01 +02:00
this->current_format = info;
this->have_format = true;
}
Cleanups
2016-09-20 11:20:43 +02:00
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
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) {
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_params[3] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_READWRITE);
this->port_params[4] = SPA_PARAM_INFO(SPA_PARAM_Buffers, SPA_PARAM_INFO_READ);
} else {
this->port_params[3] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
this->port_params[4] = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
indent
2017-05-26 08:05:01 +02:00
}
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
emit_port_info(this, false);
Cleanups
2016-09-20 11:20:43 +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;
Cleanups
2016-09-20 11:20:43 +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)
Cleanups
2016-09-20 11:20:43 +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;
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
int res;
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);
param: add more generic port params Remove port properties and replace them with port params. Move the params from the PortInfo to enum_params. Use the Param ranges to specify possible sizes etc.
2017-05-22 13:06:18 +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);
param: add more generic port params Remove port properties and replace them with port params. Move the params from the PortInfo to enum_params. Use the Param ranges to specify possible sizes etc.
2017-05-22 13:06:18 +02:00
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
switch (id) {
case SPA_PARAM_Format:
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
res = port_set_format(this, direction, port_id, flags, param);
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
break;
default:
res = -ENOENT;
break;
indent
2017-05-26 08:05:01 +02:00
}
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
return res;
Cleanups
2016-09-20 11:20:43 +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)
Cleanups
2016-09-20 11:20:43 +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;
indent
2017-05-26 08:05:01 +02:00
int res;
fix sign confusion
2019-01-07 15:52:42 +01:00
uint32_t i;
Cleanups
2016-09-20 11:20:43 +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);
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +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
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;
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
Improve some debug
2019-10-18 21:54:25 +02:00
spa_log_debug(this->log, NAME " %p: use %d buffers", this, n_buffers);
indent
2017-05-26 08:05:01 +02: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);
indent
2017-05-26 08:05:01 +02:00
if ((res = clear_buffers(this)) < 0)
return res;
}
for (i = 0; i < n_buffers; i++) {
struct buffer *b = &this->buffers[i];
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 = 0;
Add fd to the data Add the fd to the SpaData so that we can noth use the fd and the mmapped memory when we want instead of needing to mmap again in the plugin. various cleanups
2016-10-04 19:37:44 +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) {
indent
2017-05-26 08:05:01 +02:00
spa_log_error(this->log, NAME " %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
}
use spa_list_append when we can
2017-10-24 12:58:10 +02:00
spa_list_append(&this->free, &b->link);
indent
2017-05-26 08:05:01 +02:00
}
this->n_buffers = n_buffers;
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +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;
Cleanups
2016-09-20 11:20:43 +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)
Cleanups
2016-09-20 11:20:43 +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;
Cleanups
2016-09-20 11:20:43 +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);
Cleanups
2016-09-20 11:20:43 +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);
Cleanups
2016-09-20 11:20:43 +02:00
small cleanups resample: remove unused index variable
2019-07-08 18:23:22 +02:00
spa_log_debug(this->log, NAME " %p: io %d %p %zd", this, id, data, size);
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
switch (id) {
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;
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
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;
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
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;
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
}
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
2016-09-20 11:20:43 +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
{
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;
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
spa_return_val_if_fail(this != NULL, -EINVAL);
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
spa_return_val_if_fail(port_id == 0, -EINVAL);
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
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;
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
indent
2017-05-26 08:05:01 +02:00
if (buffer_id >= this->n_buffers)
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -EINVAL;
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
alsa: fix buffer recycle We only set the OUT flag when we put the buffer on an io area and might need to recycle later. Before placing the output buffer into the io area, recycle any buffer that might be left in there. Only emit the ready callback when we have some data queued.
2020-03-19 13:12:49 +01:00
spa_alsa_recycle_buffer(this, 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 0;
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;
node: Add id to set_io Make it possible to configure multiple io areas on a port by giving an id to set_io. Add some types to enumerate the supported ids Make an area to exchange buffers and one to specify pull ranges. The idea is to make more area types for controlable properties. Implement enumeration of IO areas in volume.
2017-11-21 19:34:37 +01:00
struct spa_io_buffers *io;
alsa: fix capture
2018-04-26 17:22:17 +02:00
struct buffer *b;
improve node io Unify input and output io areas. Add support for ranges in the io area. Automatically recycle buffers in the output areas in process_output Improve the mixer, add use_buffer support, use a queue of input buffers, fix mixing, add support for ranges. Fix mixer and v4l2 tests
2017-04-03 14:56:04 +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);
improve node io Unify input and output io areas. Add support for ranges in the io area. Automatically recycle buffers in the output areas in process_output Improve the mixer, add use_buffer support, use a queue of input buffers, fix mixing, add support for ranges. Fix mixer and v4l2 tests
2017-04-03 14:56:04 +02:00
indent
2017-05-26 08:05:01 +02:00
io = this->io;
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(io != NULL, -EIO);
improve node io Unify input and output io areas. Add support for ranges in the io area. Automatically recycle buffers in the output areas in process_output Improve the mixer, add use_buffer support, use a queue of input buffers, fix mixing, add support for ranges. Fix mixer and v4l2 tests
2017-04-03 14:56:04 +02:00
add some more debug info
2020-09-25 17:01:52 +02:00
spa_log_trace_fp(this->log, NAME " %p; status %d", this, io->status);
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
if (io->status == SPA_STATUS_HAVE_DATA)
return SPA_STATUS_HAVE_DATA;
audiomixer: small improvements Improve the audiomixer state handling Improve PortIO status handling.
2017-04-28 17:22:23 +02:00
small cleanups
2017-08-27 09:16:03 +02:00
if (io->buffer_id < this->n_buffers) {
alsa: fix buffer recycle We only set the OUT flag when we put the buffer on an io area and might need to recycle later. Before placing the output buffer into the io area, recycle any buffer that might be left in there. Only emit the ready callback when we have some data queued.
2020-03-19 13:12:49 +01:00
spa_alsa_recycle_buffer(this, io->buffer_id);
indent
2017-05-26 08:05:01 +02:00
io->buffer_id = SPA_ID_INVALID;
}
alsa: fix capture
2018-04-26 17:22:17 +02:00
slave -> follower We use master/follower terminology everywhere.
2020-02-21 10:47:32 +01:00
if (spa_list_is_empty(&this->ready) && this->following)
alsa: rework source a little in the case of slave When we are slaved, read as much data as we have available and return this from process.
2019-04-11 16:44:07 +02:00
spa_alsa_read(this, 0);
slave -> follower We use master/follower terminology everywhere.
2020-02-21 10:47:32 +01:00
if (spa_list_is_empty(&this->ready) || !this->following)
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
return SPA_STATUS_OK;
alsa: fix capture
2018-04-26 17:22:17 +02:00
b = spa_list_first(&this->ready, struct buffer, link);
spa_list_remove(&b->link);
alsa: fix buffer recycle We only set the OUT flag when we put the buffer on an io area and might need to recycle later. Before placing the output buffer into the io area, recycle any buffer that might be left in there. Only emit the ready callback when we have some data queued.
2020-03-19 13:12:49 +01:00
SPA_FLAG_SET(b->flags, BUFFER_FLAG_OUT);
alsa: fix capture
2018-04-26 17:22:17 +02:00
alsa: improve clock slaving for source
2019-04-25 12:53:23 +02:00
spa_log_trace_fp(this->log, NAME " %p: dequeue buffer %d", this, b->id);
alsa: fix capture
2018-04-26 17:22:17 +02:00
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
io->buffer_id = b->id;
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
io->status = SPA_STATUS_HAVE_DATA;
alsa: fix capture
2018-04-26 17:22:17 +02:00
rename HAVE/NEED_BUFFER -> HAVE/NEED_DATA It is more generic and works with control-only ports as well
2019-09-16 12:55:23 +02:00
return SPA_STATUS_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,
.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,
Cleanups
2016-09-20 11:20:43 +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
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)
Cleanups
2016-09-20 11:20:43 +02:00
{
indent
2017-05-26 08:05:01 +02:00
struct state *this;
Cleanups
2016-09-20 11:20:43 +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);
Cleanups
2016-09-20 11:20:43 +02:00
indent
2017-05-26 08:05:01 +02:00
this = (struct state *) handle;
Cleanups
2016-09-20 11:20:43 +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
if (strcmp(type, SPA_TYPE_INTERFACE_Node) == 0)
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;
Cleanups
2016-09-20 11:20:43 +02:00
}
indent
2017-05-26 08:05:01 +02:00
static int impl_clear(struct spa_handle *handle)
Cleanups
2016-09-20 11:20:43 +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);
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
2016-09-20 11:20:43 +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)
{
struct state *this;
uint32_t i;
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);
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);
indent
2017-05-26 08:05:01 +02:00
if (this->data_loop == NULL) {
improve properties on node and port Rename some alsa filenames.
2019-09-23 20:51:34 +02:00
spa_log_error(this->log, NAME" %p: a data loop is needed", 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
}
simply use INTERFACE_Loop for the main-loop
2019-06-06 15:20:43 +02:00
if (this->data_system == NULL) {
improve properties on node and port Rename some alsa filenames.
2019-09-23 20:51:34 +02:00
spa_log_error(this->log, NAME" %p: a data system is needed", 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
}
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_CAPTURE;
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.max_output_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;
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->params[0] = SPA_PARAM_INFO(SPA_PARAM_PropInfo, SPA_PARAM_INFO_READ);
this->params[1] = SPA_PARAM_INFO(SPA_PARAM_Props, SPA_PARAM_INFO_READWRITE);
alsa: advertize node params correctly
2019-08-21 13:05:52 +02:00
this->params[2] = SPA_PARAM_INFO(SPA_PARAM_IO, SPA_PARAM_INFO_READ);
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: advertize node params correctly
2019-08-21 13:05:52 +02:00
this->info.n_params = 3;
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;
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_params[0] = SPA_PARAM_INFO(SPA_PARAM_EnumFormat, SPA_PARAM_INFO_READ);
this->port_params[1] = SPA_PARAM_INFO(SPA_PARAM_Meta, SPA_PARAM_INFO_READ);
this->port_params[2] = SPA_PARAM_INFO(SPA_PARAM_IO, SPA_PARAM_INFO_READ);
this->port_params[3] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
this->port_params[4] = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
this->port_info.params = this->port_params;
this->port_info.n_params = 5;
control: add control objects Add control objects for all controllable properties on ports. Try to link compatible control properties in autolink. Allocate shared memory for the output property memory and configure the io area on the ports when the controls are linked. Send the shared memfd to clients when the io area is configured. Add port_set_io support in remote.c, mmap the control io area and set on the port. Add some param helpers Add volume control to export-source update the volume before sending each buffer.
2017-11-30 16:36:29 +01:00
indent
2017-05-26 08:05:01 +02:00
spa_list_init(&this->free);
spa_list_init(&this->ready);
alsa: reload alsa configuration Fixes #332
2020-11-05 10:00:25 +01:00
snd_config_update_free_global();
indent
2017-05-26 08:05:01 +02:00
for (i = 0; info && i < info->n_items; i++) {
alsa: rework batch handling a bit By default, use a 512 period for batch and use 512 headroom Add a property to disable special batch handling.
2021-01-21 17:10:48 +01:00
const char *s = info->items[i].value;
spa: add keys for properties Define and document property keys
2019-06-03 16:48:01 +02:00
if (!strcmp(info->items[i].key, SPA_KEY_API_ALSA_PATH)) {
indent
2017-05-26 08:05:01 +02:00
snprintf(this->props.device, 63, "%s", info->items[i].value);
alsa-pcm: allow setting number of channels Allow passing the number of channels when creating a device to restrict the negotiated channels.
2020-07-01 12:54:27 +02:00
} else if (!strcmp(info->items[i].key, SPA_KEY_AUDIO_CHANNELS)) {
this->default_channels = atoi(info->items[i].value);
alsa: add option to force a samplerate
2020-09-16 15:14:26 +02:00
} else if (!strcmp(info->items[i].key, SPA_KEY_AUDIO_RATE)) {
this->default_rate = atoi(info->items[i].value);
alsa: make it possible to fix format
2020-12-09 20:33:57 +01:00
} else if (!strcmp(info->items[i].key, SPA_KEY_AUDIO_FORMAT)) {
this->default_format = spa_alsa_format_from_name(info->items[i].value, 128);
alsa: allow override of channel map
2020-12-28 14:24:59 +01:00
} else if (!strcmp(info->items[i].key, SPA_KEY_AUDIO_POSITION)) {
size_t len;
alsa: rework batch handling a bit By default, use a 512 period for batch and use 512 headroom Add a property to disable special batch handling.
2021-01-21 17:10:48 +01:00
while (*s && this->default_pos.channels < SPA_AUDIO_MAX_CHANNELS) {
if ((len = strcspn(s, ",")) == 0)
alsa: allow override of channel map
2020-12-28 14:24:59 +01:00
break;
this->default_pos.pos[this->default_pos.channels++] =
alsa: rework batch handling a bit By default, use a 512 period for batch and use 512 headroom Add a property to disable special batch handling.
2021-01-21 17:10:48 +01:00
spa_alsa_channel_from_name(s, len);
s += len + strspn(s+len, ",");
alsa: allow override of channel map
2020-12-28 14:24:59 +01:00
}
alsa: add option to configure period-size api.alsa.period-size can be set to something else than 1024 with this config option.
2021-01-05 12:44:10 +01:00
} else if (!strcmp(info->items[i].key, "api.alsa.period-size")) {
this->default_period_size = atoi(info->items[i].value);
alsa: add api.alsa.headroom setting Can be used to tweak the extra distance kept between the hardware and software pointers when reading and writing. See #289
2021-01-14 17:10:05 +01:00
} else if (!strcmp(info->items[i].key, "api.alsa.headroom")) {
this->default_headroom = atoi(info->items[i].value);
alsa: add option to disable mmap access mode
2021-01-15 15:44:22 +01:00
} else if (!strcmp(info->items[i].key, "api.alsa.disable-mmap")) {
alsa: rework batch handling a bit By default, use a 512 period for batch and use 512 headroom Add a property to disable special batch handling.
2021-01-21 17:10:48 +01:00
this->disable_mmap = (strcmp(s, "true") == 0 || atoi(s) == 1);
} else if (!strcmp(info->items[i].key, "api.alsa.disable-batch")) {
this->disable_batch = (strcmp(s, "true") == 0 || atoi(s) == 1);
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
return 0;
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,},
Cleanups
2016-09-20 11:20:43 +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,
const struct spa_interface_info **info,
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
uint32_t *index)
Cleanups
2016-09-20 11:20:43 +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);
Cleanups
2016-09-20 11:20:43 +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
if (*index >= SPA_N_ELEMENTS(impl_interfaces))
return 0;
Cleanups
2016-09-20 11:20:43 +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
*info = &impl_interfaces[(*index)++];
Cleanups
2016-09-20 11:20:43 +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 1;
Cleanups
2016-09-20 11:20:43 +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, "Record audio with the alsa API" },
{ SPA_KEY_FACTORY_USAGE, "["SPA_KEY_API_ALSA_PATH"=<device>]" },
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
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
const struct spa_handle_factory spa_alsa_source_factory = {
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_SOURCE,
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,
Cleanups
2016-09-20 11:20:43 +02:00
};
Reference in a new issue Copy permalink