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/pipewire-pulseaudio/src/introspect.c

2633 lines
66 KiB
C
Raw Normal View History

Initial import
2018-06-01 11:28:31 +02:00
/* PipeWire
* Copyright (C) 2018 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <errno.h>
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
#include <spa/param/props.h>
pulse: improve includes
2019-01-14 13:01:47 +01:00
#include <pipewire/pipewire.h>
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
#include <extensions/metadata.h>
Initial import
2018-06-01 11:28:31 +02:00
#include <pulse/introspect.h>
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
#include <pulse/xmalloc.h>
Initial import
2018-06-01 11:28:31 +02:00
#include "internal.h"
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
struct success_ack {
pa_context_success_cb_t cb;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
int error;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
void *userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
uint32_t idx;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
};
static void on_success(pa_operation *o, void *userdata)
{
struct success_ack *d = userdata;
pa_context *c = o->context;
improve debug
2020-04-06 18:01:19 +02:00
pw_log_debug("error:%d", d->error);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
if (d->error != 0)
pa_context_set_error(c, d->error);
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
if (d->cb)
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
d->cb(c, d->error ? 0 : 1, d->userdata);
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
pa_operation_done(o);
}
Initial import
2018-06-01 11:28:31 +02:00
struct sink_data {
pa_sink_info_cb_t cb;
void *userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
char *name;
uint32_t idx;
Initial import
2018-06-01 11:28:31 +02:00
};
introspect: improve introspection stream: set roles
2018-07-04 18:43:45 +02:00
static pa_sink_state_t node_state_to_sink(enum pw_node_state s)
{
switch(s) {
case PW_NODE_STATE_ERROR:
return PA_SINK_UNLINKED;
case PW_NODE_STATE_CREATING:
return PA_SINK_INIT;
case PW_NODE_STATE_SUSPENDED:
return PA_SINK_SUSPENDED;
case PW_NODE_STATE_IDLE:
return PA_SINK_IDLE;
case PW_NODE_STATE_RUNNING:
return PA_SINK_RUNNING;
default:
return PA_SINK_INVALID_STATE;
}
}
context: update the Profiles and Routes in the card Update the Profile and Route information directly into the card info. Use this info to fill the port info for the sink and sources.
2020-06-25 16:46:47 +02:00
static int has_profile(pa_card_profile_info2 **list, pa_card_profile_info2 *active)
{
for(;*list; list++) {
if (*list == active)
return 1;
}
return 0;
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
static int sink_callback(pa_context *c, struct global *g, struct sink_data *d)
Initial import
2018-06-01 11:28:31 +02:00
{
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct global *cg;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
struct pw_node_info *info = g->info;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
const char *str;
context: update the Profiles and Routes in the card Update the Profile and Route information directly into the card info. Use this info to fill the port info for the sink and sources.
2020-06-25 16:46:47 +02:00
uint32_t n, j;
Initial import
2018-06-01 11:28:31 +02:00
pa_sink_info i;
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
pa_format_info ii[1];
pa_format_info *ip[1];
Initial import
2018-06-01 11:28:31 +02:00
spa_zero(i);
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
if (info->props && (str = spa_dict_lookup(info->props, PW_KEY_NODE_NAME)))
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.name = str;
else
i.name = "unknown";
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
pw_log_debug("sink %d %s monitor %d", g->id, i.name, g->node_info.monitor);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.index = g->id;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
if (info->props && (str = spa_dict_lookup(info->props, PW_KEY_NODE_DESCRIPTION)))
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.description = str;
else
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.description = "Unknown";
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
pulse: use format from node if available And fall back to some defaults otherwise.
2020-07-29 14:42:29 +02:00
i.sample_spec = g->node_info.sample_spec;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
if (g->node_info.n_channel_volumes)
i.sample_spec.channels = g->node_info.n_channel_volumes;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
else
i.sample_spec.channels = 2;
pulse: use format from node if available And fall back to some defaults otherwise.
2020-07-29 14:42:29 +02:00
if (i.sample_spec.channels == g->node_info.channel_map.channels)
i.channel_map = g->node_info.channel_map;
else
pa_channel_map_init_auto(&i.channel_map, i.sample_spec.channels, PA_CHANNEL_MAP_OSS);
use properties instead of parent_id
2019-08-16 22:10:08 +02:00
i.owner_module = 0;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.volume.channels = i.sample_spec.channels;
for (n = 0; n < i.volume.channels; n++)
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.volume.values[n] = g->node_info.volume * g->node_info.channel_volumes[n] * PA_VOLUME_NORM;
i.mute = g->node_info.mute;
i.monitor_source = g->node_info.monitor;
pulse: improve name of monitors
2020-07-08 16:10:45 +02:00
i.monitor_source_name = pa_context_find_global_name(c, i.monitor_source);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.latency = 0;
i.driver = "PipeWire";
introspect: set sink/source flags
2018-12-20 13:08:09 +01:00
i.flags = PA_SINK_HARDWARE |
PA_SINK_LATENCY | PA_SINK_DYNAMIC_LATENCY |
PA_SINK_DECIBEL_VOLUME;
pulse: control volume on device or node Send the mute and volume values in the route param when hw volume is available. Check if the route has volume/mute and then use that to control the volume instead of them node volume.
2020-06-30 13:33:46 +02:00
if (SPA_FLAG_IS_SET(g->node_info.flags, NODE_FLAG_HW_VOLUME))
i.flags |= PA_SINK_HW_VOLUME_CTRL;
if (SPA_FLAG_IS_SET(g->node_info.flags, NODE_FLAG_HW_MUTE))
i.flags |= PA_SINK_HW_MUTE_CTRL;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.proplist = pa_proplist_new_dict(info->props);
i.configured_latency = 0;
acp: add volume base and step Add a READONLY property flag to makr properties READONLY Set the base_volume and volume_step in the acp device Send the base volume and step as REAONLY properties. Use these in pulse layer.
2020-07-07 13:12:57 +02:00
i.base_volume = g->node_info.base_volume * PA_VOLUME_NORM;
i.n_volume_steps = g->node_info.volume_step * (PA_VOLUME_NORM+1);
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.state = node_state_to_sink(info->state);
pulse: control volume on device or node Send the mute and volume values in the route param when hw volume is available. Check if the route has volume/mute and then use that to control the volume instead of them node volume.
2020-06-30 13:33:46 +02:00
i.card = g->node_info.device_id;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.n_ports = 0;
i.ports = NULL;
i.active_port = NULL;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
if ((cg = pa_context_find_global(c, i.card)) != NULL) {
context: update the Profiles and Routes in the card Update the Profile and Route information directly into the card info. Use this info to fill the port info for the sink and sources.
2020-06-25 16:46:47 +02:00
pa_sink_port_info *spi;
pa_card_info *ci = &cg->card_info.info;
spi = alloca(ci->n_ports * sizeof(pa_sink_port_info));
i.ports = alloca((ci->n_ports + 1) * sizeof(pa_sink_port_info *));
for (n = 0,j = 0; n < ci->n_ports; n++) {
if (ci->ports[n]->direction != PA_DIRECTION_OUTPUT)
continue;
if (!has_profile(ci->ports[n]->profiles2, ci->active_profile2))
continue;
i.ports[j] = &spi[j];
spi[j].name = ci->ports[n]->name;
spi[j].description = ci->ports[n]->description;
spi[j].priority = ci->ports[n]->priority;
spi[j].available = ci->ports[n]->available;
if (n == cg->card_info.active_port_output)
i.active_port = i.ports[j];
j++;
}
i.n_ports = j;
if (i.n_ports == 0)
i.ports = NULL;
else
i.ports[j] = NULL;
}
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
i.n_formats = 1;
ii[0].encoding = PA_ENCODING_PCM;
ii[0].plist = pa_proplist_new();
ip[0] = ii;
i.formats = ip;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->cb(c, &i, 0, d->userdata);
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pa_proplist_free(i.proplist);
pa_proplist_free(ii[0].plist);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
return 0;
Initial import
2018-06-01 11:28:31 +02:00
}
static void sink_info(pa_operation *o, void *userdata)
{
struct sink_data *d = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct global *g;
pa_context *c = o->context;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
int error = 0;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
if (d->name) {
g = pa_context_find_global_by_name(c, PA_SUBSCRIPTION_MASK_SINK, d->name);
pa_xfree(d->name);
} else {
if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & PA_SUBSCRIPTION_MASK_SINK))
g = NULL;
}
pw_log_debug("%p", c);
if (g) {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = sink_callback(c, g, d);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
} else {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = PA_ERR_INVALID;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (error)
pa_context_set_error(c, error);
d->cb(c, NULL, error ? -1 : 1, d->userdata);
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
pa_operation_done(o);
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
pa_operation* pa_context_get_sink_info_by_name(pa_context *c, const char *name, pa_sink_info_cb_t cb, void *userdata)
{
pa_operation *o;
struct sink_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pw_log_debug("%p", c);
pa_context_ensure_registry(c);
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
o = pa_operation_new(c, NULL, sink_info, sizeof(struct sink_data));
d = o->userdata;
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->name = pa_xstrdup(name);
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
introspect: wait for enum to complete Trigger another sync after starting node or device param enum
2019-03-11 18:05:24 +01:00
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
return o;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_sink_info_by_index(pa_context *c, uint32_t idx, pa_sink_info_cb_t cb, void *userdata)
{
pa_operation *o;
struct sink_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
Initial import
2018-06-01 11:28:31 +02:00
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context_ensure_registry(c);
Initial import
2018-06-01 11:28:31 +02:00
o = pa_operation_new(c, NULL, sink_info, sizeof(struct sink_data));
d = o->userdata;
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->idx = idx;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
Initial import
2018-06-01 11:28:31 +02:00
return o;
}
static void sink_info_list(pa_operation *o, void *userdata)
{
struct sink_data *d = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context *c = o->context;
Initial import
2018-06-01 11:28:31 +02:00
struct global *g;
spa_list_for_each(g, &c->globals, link) {
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
if (!(g->mask & PA_SUBSCRIPTION_MASK_SINK))
Initial import
2018-06-01 11:28:31 +02:00
continue;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
sink_callback(c, g, d);
Initial import
2018-06-01 11:28:31 +02:00
}
d->cb(c, NULL, 1, d->userdata);
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
pa_operation_done(o);
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_sink_info_list(pa_context *c, pa_sink_info_cb_t cb, void *userdata)
{
pa_operation *o;
struct sink_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
context: ensure the registry exists Make sure we are watching the registry before we try to enumerate objects. When we wait for new object info, resync the pending operations because they might depend on the info.
2020-06-24 14:23:41 +02:00
pa_context_ensure_registry(c);
Initial import
2018-06-01 11:28:31 +02:00
o = pa_operation_new(c, NULL, sink_info_list, sizeof(struct sink_data));
d = o->userdata;
d->cb = cb;
d->userdata = userdata;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
return o;
}
pulse: handle error from volume set
2020-07-01 15:19:29 +02:00
static int set_stream_volume(pa_context *c, pa_stream *s, const pa_cvolume *volume, bool mute)
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
{
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
uint32_t i, n_channel_volumes;
float channel_volumes[SPA_AUDIO_MAX_CHANNELS];
float *vols;
if (volume) {
for (i = 0; i < volume->channels; i++)
channel_volumes[i] = volume->values[i] / (float) PA_VOLUME_NORM;
vols = channel_volumes;
n_channel_volumes = volume->channels;
} else {
vols = s->channel_volumes;
n_channel_volumes = s->n_channel_volumes;
}
if (n_channel_volumes != s->n_channel_volumes ||
!memcmp(s->channel_volumes, vols, n_channel_volumes * sizeof(float)) ||
s->mute != mute) {
stream: improve control update When setting the volume, update the stream controls with the new values and update the internal state with the control_info event.
2019-08-13 18:46:27 +02:00
float val = s->mute ? 1.0f : 0.0f;
context: use subscribe params Improve volume setting
2019-03-18 16:11:23 +01:00
pw_stream_set_control(s->stream,
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
SPA_PROP_mute, 1, &val,
stream: improve control update When setting the volume, update the stream controls with the new values and update the internal state with the control_info event.
2019-08-13 18:46:27 +02:00
SPA_PROP_channelVolumes, n_channel_volumes, vols,
context: use subscribe params Improve volume setting
2019-03-18 16:11:23 +01:00
0);
}
pulse: handle error from volume set
2020-07-01 15:19:29 +02:00
return 0;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
}
pulse: handle error from volume set
2020-07-01 15:19:29 +02:00
static int set_node_volume(pa_context *c, struct global *g, const pa_cvolume *volume, bool mute)
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
{
char buf[1024];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf));
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
uint32_t i, n_channel_volumes;
float channel_volumes[SPA_AUDIO_MAX_CHANNELS];
float *vols;
if (volume) {
for (i = 0; i < volume->channels; i++)
channel_volumes[i] = volume->values[i] / (float) PA_VOLUME_NORM;
vols = channel_volumes;
n_channel_volumes = volume->channels;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
if (n_channel_volumes == g->node_info.n_channel_volumes &&
memcmp(g->node_info.channel_volumes, vols, n_channel_volumes * sizeof(float)) == 0 &&
mute == g->node_info.mute)
pulse: handle error from volume set
2020-07-01 15:19:29 +02:00
return 0;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
memcpy(g->node_info.channel_volumes, vols, n_channel_volumes * sizeof(float));
g->node_info.n_channel_volumes = n_channel_volumes;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
} else {
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
n_channel_volumes = g->node_info.n_channel_volumes;
vols = g->node_info.channel_volumes;
if (mute == g->node_info.mute)
pulse: handle error from volume set
2020-07-01 15:19:29 +02:00
return 0;
context: use subscribe params Improve volume setting
2019-03-18 16:11:23 +01:00
}
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
g->node_info.mute = mute;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
pulse: don't try to do set_param when not writable
2020-07-16 13:25:03 +02:00
if (!SPA_FLAG_IS_SET(g->permissions, PW_PERM_W | PW_PERM_X))
return PA_ERR_ACCESS;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
pw_node_set_param((struct pw_node*)g->proxy,
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
SPA_PARAM_Props, 0,
spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, SPA_PARAM_Props,
SPA_PROP_mute, SPA_POD_Bool(mute),
SPA_PROP_channelVolumes, SPA_POD_Array(sizeof(float),
SPA_TYPE_Float,
n_channel_volumes,
vols)));
pulse: handle error from volume set
2020-07-01 15:19:29 +02:00
return 0;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
}
pulse: control volume on device or node Send the mute and volume values in the route param when hw volume is available. Check if the route has volume/mute and then use that to control the volume instead of them node volume.
2020-06-30 13:33:46 +02:00
static int set_device_volume(pa_context *c, struct global *g, struct global *cg, uint32_t id,
uint32_t device_id, const pa_cvolume *volume, bool mute)
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
{
char buf[1024];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf));
struct spa_pod_frame f[2];
struct spa_pod *param;
uint32_t i, n_channel_volumes;
float channel_volumes[SPA_AUDIO_MAX_CHANNELS];
float *vols;
if (volume) {
for (i = 0; i < volume->channels; i++)
channel_volumes[i] = volume->values[i] / (float) PA_VOLUME_NORM;
vols = channel_volumes;
n_channel_volumes = volume->channels;
if (n_channel_volumes == g->node_info.n_channel_volumes &&
memcmp(g->node_info.channel_volumes, vols, n_channel_volumes * sizeof(float)) == 0 &&
mute == g->node_info.mute)
return 0;
memcpy(g->node_info.channel_volumes, vols, n_channel_volumes * sizeof(float));
g->node_info.n_channel_volumes = n_channel_volumes;
} else {
n_channel_volumes = g->node_info.n_channel_volumes;
vols = g->node_info.channel_volumes;
if (mute == g->node_info.mute)
return 0;
}
g->node_info.mute = mute;
pulse: don't try to do set_param when not writable
2020-07-16 13:25:03 +02:00
if (!SPA_FLAG_IS_SET(cg->permissions, PW_PERM_W | PW_PERM_X))
return PA_ERR_ACCESS;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
spa_pod_builder_push_object(&b, &f[0],
SPA_TYPE_OBJECT_ParamRoute, SPA_PARAM_Route);
spa_pod_builder_add(&b,
SPA_PARAM_ROUTE_index, SPA_POD_Int(id),
SPA_PARAM_ROUTE_device, SPA_POD_Int(device_id),
0);
spa_pod_builder_prop(&b, SPA_PARAM_ROUTE_props, 0);
spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, SPA_PARAM_Props,
SPA_PROP_mute, SPA_POD_Bool(mute),
SPA_PROP_channelVolumes, SPA_POD_Array(sizeof(float),
SPA_TYPE_Float,
n_channel_volumes,
vols));
param = spa_pod_builder_pop(&b, &f[0]);
pw_device_set_param((struct pw_node*)cg->proxy,
SPA_PARAM_Route, 0, param);
return 0;
}
pulse: control volume on device or node Send the mute and volume values in the route param when hw volume is available. Check if the route has volume/mute and then use that to control the volume instead of them node volume.
2020-06-30 13:33:46 +02:00
static int set_volume(pa_context *c, struct global *g, const pa_cvolume *volume, bool mute,
uint32_t mask)
{
struct global *cg;
uint32_t id = SPA_ID_INVALID, card_id, device_id;
int res;
card_id = g->node_info.device_id;
device_id = g->node_info.profile_device_id;
pw_log_info("card:%u global:%u flags:%08x", card_id, g->id, g->node_info.flags);
pod: add HARDWARE flag to spa_pod_prop Add HARDWARE flag to mark a property that does some hardware control. Mark the device volume/mute property as HARDWARE or not. Use the HARDWARE property in pulse to set the right flags.
2020-07-06 17:46:32 +02:00
if (SPA_FLAG_IS_SET(g->node_info.flags, NODE_FLAG_DEVICE_VOLUME | NODE_FLAG_DEVICE_MUTE) &&
pulse: control volume on device or node Send the mute and volume values in the route param when hw volume is available. Check if the route has volume/mute and then use that to control the volume instead of them node volume.
2020-06-30 13:33:46 +02:00
(cg = pa_context_find_global(c, card_id)) != NULL) {
if (mask & PA_SUBSCRIPTION_MASK_SINK)
id = cg->card_info.active_port_output;
else if (mask & PA_SUBSCRIPTION_MASK_SOURCE)
id = cg->card_info.active_port_input;
}
if (id != SPA_ID_INVALID && device_id != SPA_ID_INVALID) {
res = set_device_volume(c, g, cg, id, device_id, volume, mute);
} else {
res = set_node_volume(c, g, volume, mute);
}
return res;
}
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct volume_data {
pa_context_success_cb_t cb;
uint32_t mask;
void *userdata;
char *name;
uint32_t idx;
bool have_volume;
pa_cvolume volume;
int mute;
};
static void do_node_volume_mute(pa_operation *o, void *userdata)
{
struct volume_data *d = userdata;
pa_context *c = o->context;
struct global *g;
int error = 0;
if (d->name) {
g = pa_context_find_global_by_name(c, d->mask, d->name);
pa_xfree(d->name);
} else {
if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & d->mask))
g = NULL;
}
if (g) {
pulse: control volume on device or node Send the mute and volume values in the route param when hw volume is available. Check if the route has volume/mute and then use that to control the volume instead of them node volume.
2020-06-30 13:33:46 +02:00
error = set_volume(c, g,
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->have_volume ? &d->volume : NULL,
pulse: control volume on device or node Send the mute and volume values in the route param when hw volume is available. Check if the route has volume/mute and then use that to control the volume instead of them node volume.
2020-06-30 13:33:46 +02:00
d->have_volume ? g->node_info.mute : d->mute,
d->mask);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
} else {
error = PA_ERR_INVALID;
}
if (error != 0)
pa_context_set_error(c, error);
if (d->cb)
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->cb(c, error ? 0 : 1, d->userdata);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_operation_done(o);
}
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_sink_volume_by_index(pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata)
{
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation *o;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct volume_data *d;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_assert(c);
pa_assert(c->refcount >= 1);
pw_log_debug("context %p: index %d", c, idx);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context_ensure_registry(c);
o = pa_operation_new(c, NULL, do_node_volume_mute, sizeof(struct volume_data));
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d = o->userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SINK;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->idx = idx;
d->volume = *volume;
d->have_volume = true;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation_sync(o);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_sink_volume_by_name(pa_context *c, const char *name, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata)
{
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation *o;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct volume_data *d;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_assert(c);
pa_assert(c->refcount >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
pw_log_debug("context %p: name %s", c, name);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context_ensure_registry(c);
o = pa_operation_new(c, NULL, do_node_volume_mute, sizeof(struct volume_data));
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d = o->userdata;
d->cb = cb;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SINK;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->name = pa_xstrdup(name);
d->volume = *volume;
d->have_volume = true;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation_sync(o);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_sink_mute_by_index(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata)
{
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation *o;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct volume_data *d;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_assert(c);
pa_assert(c->refcount >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
pw_log_debug("context %p: index %d", c, idx);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context_ensure_registry(c);
o = pa_operation_new(c, NULL, do_node_volume_mute, sizeof(struct volume_data));
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d = o->userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SINK;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->idx = idx;
d->mute = mute;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_sink_mute_by_name(pa_context *c, const char *name, int mute, pa_context_success_cb_t cb, void *userdata)
{
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation *o;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct volume_data *d;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_assert(c);
pa_assert(c->refcount >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
pw_log_debug("context %p: name %s", c, name);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context_ensure_registry(c);
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
o = pa_operation_new(c, NULL, do_node_volume_mute, sizeof(struct volume_data));
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d = o->userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SINK;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->name = pa_xstrdup(name);
d->mute = mute;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation_sync(o);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_suspend_sink_by_name(pa_context *c, const char *sink_name, int suspend, pa_context_success_cb_t cb, void* userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
struct success_ack *d;
o = pa_operation_new(c, NULL, on_success, sizeof(struct success_ack));
d = o->userdata;
d->cb = cb;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
d->error = PA_ERR_NOTIMPLEMENTED;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->userdata = userdata;
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
pw_log_warn("Not Implemented");
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_suspend_sink_by_index(pa_context *c, uint32_t idx, int suspend, pa_context_success_cb_t cb, void* userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
struct success_ack *d;
o = pa_operation_new(c, NULL, on_success, sizeof(struct success_ack));
d = o->userdata;
d->cb = cb;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
d->error = PA_ERR_NOTIMPLEMENTED;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->userdata = userdata;
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
pw_log_warn("Not Implemented");
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: use route param to set current active ports
2020-07-01 15:24:50 +02:00
static int set_device_route(pa_context *c, struct global *g, const char *port, enum spa_direction direction)
{
struct global *cg;
struct param *p;
uint32_t id = SPA_ID_INVALID, card_id, device_id;
char buf[1024];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf));
pulse: control volume on device or node Send the mute and volume values in the route param when hw volume is available. Check if the route has volume/mute and then use that to control the volume instead of them node volume.
2020-06-30 13:33:46 +02:00
card_id = g->node_info.device_id;
device_id = g->node_info.profile_device_id;
pulse: use route param to set current active ports
2020-07-01 15:24:50 +02:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pw_log_info("port \"%s\": card:%u device:%u global:%u", port, card_id, device_id, g->id);
pulse: use route param to set current active ports
2020-07-01 15:24:50 +02:00
pulse: control volume on device or node Send the mute and volume values in the route param when hw volume is available. Check if the route has volume/mute and then use that to control the volume instead of them node volume.
2020-06-30 13:33:46 +02:00
if ((cg = pa_context_find_global(c, card_id)) == NULL || device_id == SPA_ID_INVALID)
pulse: use route param to set current active ports
2020-07-01 15:24:50 +02:00
return PA_ERR_NOENTITY;
spa_list_for_each(p, &cg->card_info.ports, link) {
uint32_t test_id;
const char *name;
enum spa_direction test_direction;
if (spa_pod_parse_object(p->param,
SPA_TYPE_OBJECT_ParamRoute, NULL,
SPA_PARAM_ROUTE_index, SPA_POD_Int(&test_id),
SPA_PARAM_ROUTE_direction, SPA_POD_Id(&test_direction),
SPA_PARAM_ROUTE_name, SPA_POD_String(&name)) < 0) {
pw_log_warn("device %d: can't parse route", g->id);
continue;
}
pw_log_info("port id:%u name:\"%s\" dir:%d", test_id, name, test_direction);
if (test_direction != direction)
continue;
if (strcmp(name, port) == 0) {
id = test_id;
break;
}
}
pw_log_info("port %s, id %u", port, id);
if (id == SPA_ID_INVALID)
return PA_ERR_NOENTITY;
pulse: don't try to do set_param when not writable
2020-07-16 13:25:03 +02:00
if (!SPA_FLAG_IS_SET(cg->permissions, PW_PERM_W | PW_PERM_X))
return PA_ERR_ACCESS;
pulse: use route param to set current active ports
2020-07-01 15:24:50 +02:00
pw_device_set_param((struct pw_device*)cg->proxy,
SPA_PARAM_Route, 0,
spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamRoute, SPA_PARAM_Route,
SPA_PARAM_ROUTE_index, SPA_POD_Int(id),
SPA_PARAM_ROUTE_direction, SPA_POD_Id(direction),
SPA_PARAM_ROUTE_device, SPA_POD_Int(device_id)));
return 0;
}
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct device_route {
uint32_t mask;
pa_context_success_cb_t cb;
void *userdata;
char *name;
uint32_t idx;
char *port;
enum spa_direction direction;
};
static void do_device_route(pa_operation *o, void *userdata)
Initial import
2018-06-01 11:28:31 +02:00
{
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct device_route *d = userdata;
pa_context *c = o->context;
pulse: use route param to set current active ports
2020-07-01 15:24:50 +02:00
struct global *g;
int error;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pw_log_debug("%p", c);
if (d->name) {
g = pa_context_find_global_by_name(c, d->mask, d->name);
pa_xfree(d->name);
pulse: use route param to set current active ports
2020-07-01 15:24:50 +02:00
} else {
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & d->mask))
g = NULL;
pulse: use route param to set current active ports
2020-07-01 15:24:50 +02:00
}
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
if (g) {
error = set_device_route(c, g, d->port, d->direction);
} else {
error = PA_ERR_INVALID;
}
if (error != 0)
pa_context_set_error(c, error);
if (d->cb)
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->cb(c, error != 0 ? 0 : 1, d->userdata);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_operation_done(o);
pa_xfree(d->port);
}
SPA_EXPORT
pa_operation* pa_context_set_sink_port_by_index(pa_context *c, uint32_t idx, const char*port, pa_context_success_cb_t cb, void *userdata)
{
pa_operation *o;
struct device_route *d;
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
pa_context_ensure_registry(c);
o = pa_operation_new(c, NULL, do_device_route, sizeof(struct device_route));
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d = o->userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SINK;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->idx = idx;
d->port = pa_xstrdup(port);
d->direction = SPA_DIRECTION_OUTPUT;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_sink_port_by_name(pa_context *c, const char*name, const char*port, pa_context_success_cb_t cb, void *userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct device_route *d;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
pa_context_ensure_registry(c);
o = pa_operation_new(c, NULL, do_device_route, sizeof(struct device_route));
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d = o->userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SINK;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->name = pa_xstrdup(name);
d->port = pa_xstrdup(port);
d->direction = SPA_DIRECTION_OUTPUT;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
struct source_data {
pa_source_info_cb_t cb;
void *userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
char *name;
uint32_t idx;
Initial import
2018-06-01 11:28:31 +02:00
};
introspect: improve introspection stream: set roles
2018-07-04 18:43:45 +02:00
static pa_source_state_t node_state_to_source(enum pw_node_state s)
{
switch(s) {
case PW_NODE_STATE_ERROR:
return PA_SOURCE_UNLINKED;
case PW_NODE_STATE_CREATING:
return PA_SOURCE_INIT;
case PW_NODE_STATE_SUSPENDED:
return PA_SOURCE_SUSPENDED;
case PW_NODE_STATE_IDLE:
return PA_SOURCE_IDLE;
case PW_NODE_STATE_RUNNING:
return PA_SOURCE_RUNNING;
default:
return PA_SOURCE_INVALID_STATE;
}
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
static int source_callback(pa_context *c, struct global *g, struct source_data *d)
Initial import
2018-06-01 11:28:31 +02:00
{
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct global *cg;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
struct pw_node_info *info = g->info;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
const char *str;
context: update the Profiles and Routes in the card Update the Profile and Route information directly into the card info. Use this info to fill the port info for the sink and sources.
2020-06-25 16:46:47 +02:00
uint32_t n, j;
Initial import
2018-06-01 11:28:31 +02:00
pa_source_info i;
introspect: improve introspection stream: set roles
2018-07-04 18:43:45 +02:00
pa_format_info ii[1];
pa_format_info *ip[1];
Fix some -Wenum-conversion errors Make pw_direction and spa_direction the same Explicitly cast some enums or use the right enums
2020-04-04 19:59:27 +02:00
enum pa_source_flags flags;
pulse: improve name of monitors
2020-07-08 16:10:45 +02:00
bool monitor;
introspect: set sink/source flags
2018-12-20 13:08:09 +01:00
flags = PA_SOURCE_LATENCY | PA_SOURCE_DYNAMIC_LATENCY |
PA_SOURCE_DECIBEL_VOLUME;
Initial import
2018-06-01 11:28:31 +02:00
pulse: improve name of monitors
2020-07-08 16:10:45 +02:00
monitor = (g->mask & PA_SUBSCRIPTION_MASK_SINK) != 0;
Initial import
2018-06-01 11:28:31 +02:00
spa_zero(i);
pulse: improve name of monitors
2020-07-08 16:10:45 +02:00
i.proplist = pa_proplist_new_dict(info->props);
if (monitor) {
if ((str = spa_dict_lookup(info->props, PW_KEY_NODE_NAME)))
pa_proplist_setf(i.proplist, PW_KEY_NODE_NAME, "%s.monitor", str);
if ((str = spa_dict_lookup(info->props, PW_KEY_NODE_DESCRIPTION)))
pa_proplist_setf(i.proplist, PW_KEY_NODE_DESCRIPTION, "Monitor or %s", str);
}
if ((str = pa_proplist_gets(i.proplist, PW_KEY_NODE_NAME)))
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.name = str;
else
i.name = "unknown";
pulse: improve name of monitors
2020-07-08 16:10:45 +02:00
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.index = g->id;
pulse: improve name of monitors
2020-07-08 16:10:45 +02:00
if ((str = pa_proplist_gets(i.proplist, PW_KEY_NODE_DESCRIPTION)))
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.description = str;
else
i.description = "unknown";
pulse: use format from node if available And fall back to some defaults otherwise.
2020-07-29 14:42:29 +02:00
i.sample_spec = g->node_info.sample_spec;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
if (g->node_info.n_channel_volumes)
i.sample_spec.channels = g->node_info.n_channel_volumes;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
else
i.sample_spec.channels = 2;
pulse: use format from node if available And fall back to some defaults otherwise.
2020-07-29 14:42:29 +02:00
if (i.sample_spec.channels == g->node_info.channel_map.channels)
i.channel_map = g->node_info.channel_map;
else
pa_channel_map_init_auto(&i.channel_map, i.sample_spec.channels, PA_CHANNEL_MAP_OSS);
use properties instead of parent_id
2019-08-16 22:10:08 +02:00
i.owner_module = 0;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.volume.channels = i.sample_spec.channels;
for (n = 0; n < i.volume.channels; n++)
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.volume.values[n] = g->node_info.volume * g->node_info.channel_volumes[n] * PA_VOLUME_NORM;
i.mute = g->node_info.mute;
pulse: improve name of monitors
2020-07-08 16:10:45 +02:00
if (monitor) {
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.monitor_of_sink = g->id;
pulse: improve name of monitors
2020-07-08 16:10:45 +02:00
i.monitor_of_sink_name = pa_context_find_global_name(c, g->id);
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.index = g->node_info.monitor;
stream: handle monitor sources
2018-12-11 16:37:30 +01:00
} else {
i.monitor_of_sink = PA_INVALID_INDEX;
i.monitor_of_sink_name = NULL;
pulse: control volume on device or node Send the mute and volume values in the route param when hw volume is available. Check if the route has volume/mute and then use that to control the volume instead of them node volume.
2020-06-30 13:33:46 +02:00
flags |= PA_SOURCE_HARDWARE;
if (SPA_FLAG_IS_SET(g->node_info.flags, NODE_FLAG_HW_VOLUME))
flags |= PA_SINK_HW_VOLUME_CTRL;
if (SPA_FLAG_IS_SET(g->node_info.flags, NODE_FLAG_HW_MUTE))
flags |= PA_SINK_HW_MUTE_CTRL;
stream: handle monitor sources
2018-12-11 16:37:30 +01:00
}
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.latency = 0;
i.driver = "PipeWire";
introspect: set sink/source flags
2018-12-20 13:08:09 +01:00
i.flags = flags;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.configured_latency = 0;
acp: add volume base and step Add a READONLY property flag to makr properties READONLY Set the base_volume and volume_step in the acp device Send the base volume and step as REAONLY properties. Use these in pulse layer.
2020-07-07 13:12:57 +02:00
i.base_volume = g->node_info.base_volume * PA_VOLUME_NORM;
i.n_volume_steps = g->node_info.volume_step * (PA_VOLUME_NORM+1);
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.state = node_state_to_source(info->state);
pulse: control volume on device or node Send the mute and volume values in the route param when hw volume is available. Check if the route has volume/mute and then use that to control the volume instead of them node volume.
2020-06-30 13:33:46 +02:00
i.card = g->node_info.device_id;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.n_ports = 0;
i.ports = NULL;
i.active_port = NULL;
pulse: improve name of monitors
2020-07-08 16:10:45 +02:00
if (!monitor && (cg = pa_context_find_global(c, i.card)) != NULL) {
context: update the Profiles and Routes in the card Update the Profile and Route information directly into the card info. Use this info to fill the port info for the sink and sources.
2020-06-25 16:46:47 +02:00
pa_source_port_info *spi;
pa_card_info *ci = &cg->card_info.info;
spi = alloca(ci->n_ports * sizeof(pa_source_port_info));
i.ports = alloca((ci->n_ports + 1) * sizeof(pa_source_port_info *));
for (n = 0,j = 0; n < ci->n_ports; n++) {
if (ci->ports[n]->direction != PA_DIRECTION_INPUT)
continue;
if (!has_profile(ci->ports[n]->profiles2, ci->active_profile2))
continue;
i.ports[j] = &spi[j];
spi[j].name = ci->ports[n]->name;
spi[j].description = ci->ports[n]->description;
spi[j].priority = ci->ports[n]->priority;
spi[j].available = ci->ports[n]->available;
if (n == cg->card_info.active_port_input)
i.active_port = i.ports[j];
j++;
}
i.n_ports = j;
if (i.n_ports == 0)
i.ports = NULL;
else
i.ports[j] = NULL;
}
introspect: improve introspection stream: set roles
2018-07-04 18:43:45 +02:00
i.n_formats = 1;
ii[0].encoding = PA_ENCODING_PCM;
ii[0].plist = pa_proplist_new();
ip[0] = ii;
i.formats = ip;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->cb(c, &i, 0, d->userdata);
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pa_proplist_free(i.proplist);
pa_proplist_free(ii[0].plist);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
return 0;
Initial import
2018-06-01 11:28:31 +02:00
}
static void source_info(pa_operation *o, void *userdata)
{
struct source_data *d = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context *c = o->context;
struct global *g;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
int error;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
if (d->name) {
g = pa_context_find_global_by_name(c, PA_SUBSCRIPTION_MASK_SOURCE, d->name);
pa_xfree(d->name);
} else {
if (((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & PA_SUBSCRIPTION_MASK_SOURCE)) &&
(((g = pa_context_find_global(c, d->idx & PA_IDX_MASK_DSP)) == NULL ||
!(g->mask & PA_SUBSCRIPTION_MASK_SOURCE))))
g = NULL;
}
if (g) {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = source_callback(c, g, d);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
} else {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = PA_ERR_INVALID;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (error)
pa_context_set_error(c, error);
d->cb(c, NULL, error ? -1 : 1, d->userdata);
stream: fix introspection of linked device
2018-07-04 15:33:20 +02:00
pa_operation_done(o);
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_source_info_by_name(pa_context *c, const char *name, pa_source_info_cb_t cb, void *userdata)
{
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
pa_operation *o;
struct source_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context_ensure_registry(c);
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
o = pa_operation_new(c, NULL, source_info, sizeof(struct source_data));
d = o->userdata;
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->name = pa_xstrdup(name);
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
pa_operation_sync(o);
introspect: wait for enum to complete Trigger another sync after starting node or device param enum
2019-03-11 18:05:24 +01:00
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_source_info_by_index(pa_context *c, uint32_t idx, pa_source_info_cb_t cb, void *userdata)
{
pa_operation *o;
struct source_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
Update for new adapter nodes
2019-07-02 17:38:16 +02:00
pw_log_debug("context %p: index %d", c, idx);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context_ensure_registry(c);
Initial import
2018-06-01 11:28:31 +02:00
o = pa_operation_new(c, NULL, source_info, sizeof(struct source_data));
d = o->userdata;
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->idx = idx;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
introspect: wait for enum to complete Trigger another sync after starting node or device param enum
2019-03-11 18:05:24 +01:00
Initial import
2018-06-01 11:28:31 +02:00
return o;
}
static void source_info_list(pa_operation *o, void *userdata)
{
struct source_data *d = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context *c = o->context;
Initial import
2018-06-01 11:28:31 +02:00
struct global *g;
spa_list_for_each(g, &c->globals, link) {
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
if (!(g->mask & PA_SUBSCRIPTION_MASK_SOURCE))
Initial import
2018-06-01 11:28:31 +02:00
continue;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
source_callback(c, g, d);
Initial import
2018-06-01 11:28:31 +02:00
}
d->cb(c, NULL, 1, d->userdata);
stream: fix introspection of linked device
2018-07-04 15:33:20 +02:00
pa_operation_done(o);
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_source_info_list(pa_context *c, pa_source_info_cb_t cb, void *userdata)
{
pa_operation *o;
struct source_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
context: ensure the registry exists Make sure we are watching the registry before we try to enumerate objects. When we wait for new object info, resync the pending operations because they might depend on the info.
2020-06-24 14:23:41 +02:00
pa_context_ensure_registry(c);
Initial import
2018-06-01 11:28:31 +02:00
o = pa_operation_new(c, NULL, source_info_list, sizeof(struct source_data));
d = o->userdata;
d->cb = cb;
d->userdata = userdata;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
return o;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_source_volume_by_index(pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata)
{
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation *o;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct volume_data *d;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_assert(c);
pa_assert(c->refcount >= 1);
pw_log_debug("context %p: index %d", c, idx);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context_ensure_registry(c);
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
o = pa_operation_new(c, NULL, do_node_volume_mute, sizeof(struct volume_data));
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d = o->userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SOURCE;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->idx = idx;
d->volume = *volume;
d->have_volume = true;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation_sync(o);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_source_volume_by_name(pa_context *c, const char *name, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata)
{
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation *o;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct volume_data *d;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_assert(c);
pa_assert(c->refcount >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
pw_log_debug("context %p: name %s", c, name);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context_ensure_registry(c);
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
o = pa_operation_new(c, NULL, do_node_volume_mute, sizeof(struct volume_data));
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d = o->userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SOURCE;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->name = pa_xstrdup(name);
d->volume = *volume;
d->have_volume = true;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation_sync(o);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_source_mute_by_index(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata)
{
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation *o;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct volume_data *d;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_assert(c);
pa_assert(c->refcount >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
pw_log_debug("context %p: index %d", c, idx);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context_ensure_registry(c);
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
o = pa_operation_new(c, NULL, do_node_volume_mute, sizeof(struct volume_data));
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d = o->userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SOURCE;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->idx = idx;
d->mute = mute;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation_sync(o);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_source_mute_by_name(pa_context *c, const char *name, int mute, pa_context_success_cb_t cb, void *userdata)
{
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation *o;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct volume_data *d;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_assert(c);
pa_assert(c->refcount >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
pw_log_debug("context %p: name %s", c, name);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
pa_context_ensure_registry(c);
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
o = pa_operation_new(c, NULL, do_node_volume_mute, sizeof(struct volume_data));
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d = o->userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SOURCE;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->name = pa_xstrdup(name);
d->mute = mute;
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pa_operation_sync(o);
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_suspend_source_by_name(pa_context *c, const char *source_name, int suspend, pa_context_success_cb_t cb, void* userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
struct success_ack *d;
o = pa_operation_new(c, NULL, on_success, sizeof(struct success_ack));
d = o->userdata;
d->cb = cb;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
d->error = PA_ERR_NOTIMPLEMENTED;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->userdata = userdata;
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
pw_log_warn("Not Implemented");
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_suspend_source_by_index(pa_context *c, uint32_t idx, int suspend, pa_context_success_cb_t cb, void* userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
struct success_ack *d;
o = pa_operation_new(c, NULL, on_success, sizeof(struct success_ack));
d = o->userdata;
d->cb = cb;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
d->error = PA_ERR_NOTIMPLEMENTED;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->userdata = userdata;
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
pw_log_warn("Not Implemented");
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_source_port_by_index(pa_context *c, uint32_t idx, const char*port, pa_context_success_cb_t cb, void *userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct device_route *d;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
pw_log_debug("context %p: idx %d", c, idx);
pa_context_ensure_registry(c);
o = pa_operation_new(c, NULL, do_device_route, sizeof(struct device_route));
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d = o->userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SOURCE;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->idx = idx;
d->port = pa_xstrdup(port);
d->direction = SPA_DIRECTION_INPUT;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_source_port_by_name(pa_context *c, const char*name, const char*port, pa_context_success_cb_t cb, void *userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
struct device_route *d;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
pw_log_debug("context %p: name %s", c, name);
pa_context_ensure_registry(c);
o = pa_operation_new(c, NULL, do_device_route, sizeof(struct device_route));
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d = o->userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->mask = PA_SUBSCRIPTION_MASK_SOURCE;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->cb = cb;
d->userdata = userdata;
pulse: handle volume and mute with the Route params Update the device volume with properties from the Route param is available. Rework pulse a little to make sure we have all the globals ready before performing the operation. Update the volume/mute in the device route
2020-06-29 16:38:10 +02:00
d->name = pa_xstrdup(name);
d->port = pa_xstrdup(port);
d->direction = SPA_DIRECTION_INPUT;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
struct server_data {
pa_server_info_cb_t cb;
void *userdata;
struct global *global;
};
introspect: fix default source/sink
2020-06-30 20:23:52 +02:00
static const char *get_default_name(pa_context *c, uint32_t mask)
{
struct global *g;
use id to store default sink/source This is easier to handle in general and we should not use the name as a unique id. If the session manager wants to save things, it can use whatever fields it wants from the object to create a unique persistent name.
2020-07-23 11:59:13 +02:00
const char *str, *id = NULL, *type, *key;
pulse: use metadata to store default source/sink The metadata is implemented by the session manager and it can decide what to do when the defaults change. It can also choose to save (some of) the metadata to a database. The metadata is also shared between applications so that changes can be picked up immediately.
2020-07-07 17:09:46 +02:00
if (c->metadata) {
if (mask & PA_SUBSCRIPTION_MASK_SINK)
pulse: emit server change events when default sink/source change
2020-07-08 17:07:07 +02:00
key = METADATA_DEFAULT_SINK;
pulse: use metadata to store default source/sink The metadata is implemented by the session manager and it can decide what to do when the defaults change. It can also choose to save (some of) the metadata to a database. The metadata is also shared between applications so that changes can be picked up immediately.
2020-07-07 17:09:46 +02:00
else if (mask & PA_SUBSCRIPTION_MASK_SOURCE)
pulse: emit server change events when default sink/source change
2020-07-08 17:07:07 +02:00
key = METADATA_DEFAULT_SOURCE;
pulse: use metadata to store default source/sink The metadata is implemented by the session manager and it can decide what to do when the defaults change. It can also choose to save (some of) the metadata to a database. The metadata is also shared between applications so that changes can be picked up immediately.
2020-07-07 17:09:46 +02:00
else
return NULL;
introspect: fix default source/sink
2020-06-30 20:23:52 +02:00
use id to store default sink/source This is easier to handle in general and we should not use the name as a unique id. If the session manager wants to save things, it can use whatever fields it wants from the object to create a unique persistent name.
2020-07-23 11:59:13 +02:00
if (pa_metadata_get(c->metadata, PW_ID_CORE, key, &type, &id) <= 0)
id = NULL;
pulse: use metadata to store default source/sink The metadata is implemented by the session manager and it can decide what to do when the defaults change. It can also choose to save (some of) the metadata to a database. The metadata is also shared between applications so that changes can be picked up immediately.
2020-07-07 17:09:46 +02:00
}
introspect: fix default source/sink
2020-06-30 20:23:52 +02:00
spa_list_for_each(g, &c->globals, link) {
if ((g->mask & mask) != mask)
continue;
if (g->props != NULL &&
pulse: use metadata to store default source/sink The metadata is implemented by the session manager and it can decide what to do when the defaults change. It can also choose to save (some of) the metadata to a database. The metadata is also shared between applications so that changes can be picked up immediately.
2020-07-07 17:09:46 +02:00
(str = pw_properties_get(g->props, PW_KEY_NODE_NAME)) != NULL &&
use id to store default sink/source This is easier to handle in general and we should not use the name as a unique id. If the session manager wants to save things, it can use whatever fields it wants from the object to create a unique persistent name.
2020-07-23 11:59:13 +02:00
(id == NULL || (uint32_t)atoi(id) == g->id))
introspect: fix default source/sink
2020-06-30 20:23:52 +02:00
return str;
}
return "unknown";
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
static void server_callback(struct server_data *d, pa_context *c)
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
{
pulse: use core_proxy to listen for done and info messages
2019-01-10 09:31:37 +01:00
const struct pw_core_info *info = c->core_info;
introspect: fix default source/sink
2020-06-30 20:23:52 +02:00
const char *str;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
pa_server_info i;
spa_zero(i);
i.user_name = info->user_name;
i.host_name = info->host_name;
i.server_version = info->version;
i.server_name = info->name;
introspect: fix default source/sink
2020-06-30 20:23:52 +02:00
i.sample_spec.format = PA_SAMPLE_FLOAT32NE;
if (info->props && (str = spa_dict_lookup(info->props, "default.clock.rate")) != NULL)
i.sample_spec.rate = atoi(str);
else
i.sample_spec.rate = 44100;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.sample_spec.channels = 2;
introspect: fix default source/sink
2020-06-30 20:23:52 +02:00
i.default_sink_name = get_default_name(c, PA_SUBSCRIPTION_MASK_SINK);
i.default_source_name = get_default_name(c, PA_SUBSCRIPTION_MASK_SOURCE);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.cookie = info->cookie;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
pa_channel_map_init_extend(&i.channel_map, i.sample_spec.channels, PA_CHANNEL_MAP_OSS);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->cb(c, &i, d->userdata);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
}
static void server_info(pa_operation *o, void *userdata)
{
struct server_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
server_callback(d, o->context);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
pa_operation_done(o);
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_server_info(pa_context *c, pa_server_info_cb_t cb, void *userdata)
{
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
pa_operation *o;
struct server_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
context: fix context_id, use the client bound id
2020-06-30 20:23:23 +02:00
pa_context_ensure_registry(c);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
o = pa_operation_new(c, NULL, server_info, sizeof(struct server_data));
d = o->userdata;
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
struct module_data {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
uint32_t idx;
Initial import
2018-06-01 11:28:31 +02:00
pa_module_info_cb_t cb;
void *userdata;
};
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
static int module_callback(pa_context *c, struct module_data *d, struct global *g)
Initial import
2018-06-01 11:28:31 +02:00
{
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->cb(c, &g->module_info.info, 0, d->userdata);
return 0;
Initial import
2018-06-01 11:28:31 +02:00
}
static void module_info(pa_operation *o, void *userdata)
{
struct module_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context *c = o->context;
struct global *g;
int error;
if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & PA_SUBSCRIPTION_MASK_MODULE))
g = NULL;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (g) {
error = module_callback(c, d, g);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
} else {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = PA_ERR_INVALID;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (error)
pa_context_set_error(c, error);
d->cb(c, NULL, error ? -1 : 1, d->userdata);
stream: fix introspection of linked device
2018-07-04 15:33:20 +02:00
pa_operation_done(o);
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_module_info(pa_context *c, uint32_t idx, pa_module_info_cb_t cb, void *userdata)
{
pa_operation *o;
struct module_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
Initial import
2018-06-01 11:28:31 +02:00
o = pa_operation_new(c, NULL, module_info, sizeof(struct module_data));
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
d->cb = cb;
d->userdata = userdata;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
return o;
}
static void module_info_list(pa_operation *o, void *userdata)
{
struct module_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context *c = o->context;
Initial import
2018-06-01 11:28:31 +02:00
struct global *g;
spa_list_for_each(g, &c->globals, link) {
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
if (!(g->mask & PA_SUBSCRIPTION_MASK_MODULE))
Initial import
2018-06-01 11:28:31 +02:00
continue;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
module_callback(c, d, g);
Initial import
2018-06-01 11:28:31 +02:00
}
d->cb(c, NULL, 1, d->userdata);
stream: fix introspection of linked device
2018-07-04 15:33:20 +02:00
pa_operation_done(o);
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_module_info_list(pa_context *c, pa_module_info_cb_t cb, void *userdata)
{
pa_operation *o;
struct module_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
context: ensure the registry exists Make sure we are watching the registry before we try to enumerate objects. When we wait for new object info, resync the pending operations because they might depend on the info.
2020-06-24 14:23:41 +02:00
pa_context_ensure_registry(c);
Initial import
2018-06-01 11:28:31 +02:00
o = pa_operation_new(c, NULL, module_info_list, sizeof(struct module_data));
d = o->userdata;
d->cb = cb;
d->userdata = userdata;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
return o;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_load_module(pa_context *c, const char*name, const char *argument, pa_context_index_cb_t cb, void *userdata)
{
pw_log_warn("Not Implemented");
return NULL;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_unload_module(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
struct success_ack *d;
o = pa_operation_new(c, NULL, on_success, sizeof(struct success_ack));
d = o->userdata;
d->cb = cb;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
d->error = PA_ERR_NOTIMPLEMENTED;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->userdata = userdata;
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
pw_log_warn("Not Implemented");
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
struct client_data {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
uint32_t idx;
Initial import
2018-06-01 11:28:31 +02:00
pa_client_info_cb_t cb;
void *userdata;
};
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
static int client_callback(pa_context *c, struct client_data *d, struct global *g)
Initial import
2018-06-01 11:28:31 +02:00
{
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->cb(c, &g->client_info.info, 0, d->userdata);
return 0;
Initial import
2018-06-01 11:28:31 +02:00
}
static void client_info(pa_operation *o, void *userdata)
{
struct client_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context *c = o->context;
struct global *g;
int error;
if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & PA_SUBSCRIPTION_MASK_CLIENT))
g = NULL;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (g) {
error = client_callback(c, d, g);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
} else {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = PA_ERR_INVALID;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (error)
pa_context_set_error(c, error);
d->cb(c, NULL, error ? -1 : 1, d->userdata);
stream: fix introspection of linked device
2018-07-04 15:33:20 +02:00
pa_operation_done(o);
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_client_info(pa_context *c, uint32_t idx, pa_client_info_cb_t cb, void *userdata)
{
pa_operation *o;
struct client_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
Initial import
2018-06-01 11:28:31 +02:00
o = pa_operation_new(c, NULL, client_info, sizeof(struct client_data));
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
d->cb = cb;
d->userdata = userdata;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
return o;
}
static void client_info_list(pa_operation *o, void *userdata)
{
struct client_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context *c = o->context;
Initial import
2018-06-01 11:28:31 +02:00
struct global *g;
spa_list_for_each(g, &c->globals, link) {
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
if (!(g->mask & PA_SUBSCRIPTION_MASK_CLIENT))
Initial import
2018-06-01 11:28:31 +02:00
continue;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
client_callback(c, d, g);
Initial import
2018-06-01 11:28:31 +02:00
}
d->cb(c, NULL, 1, d->userdata);
stream: fix introspection of linked device
2018-07-04 15:33:20 +02:00
pa_operation_done(o);
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_client_info_list(pa_context *c, pa_client_info_cb_t cb, void *userdata)
{
pa_operation *o;
struct client_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
context: ensure the registry exists Make sure we are watching the registry before we try to enumerate objects. When we wait for new object info, resync the pending operations because they might depend on the info.
2020-06-24 14:23:41 +02:00
pa_context_ensure_registry(c);
Initial import
2018-06-01 11:28:31 +02:00
o = pa_operation_new(c, NULL, client_info_list, sizeof(struct client_data));
d = o->userdata;
d->cb = cb;
d->userdata = userdata;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
return o;
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct kill_client {
uint32_t idx;
pa_context_success_cb_t cb;
void *userdata;
};
static void do_kill_client(pa_operation *o, void *userdata)
Initial import
2018-06-01 11:28:31 +02:00
{
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct kill_client *d = userdata;
pa_context *c = o->context;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
struct global *g;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
int error = 0;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & PA_SUBSCRIPTION_MASK_CLIENT))
g = NULL;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (g) {
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
pw_registry_destroy(c->registry, g->id);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
} else {
error = PA_ERR_INVALID;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (error != 0)
pa_context_set_error(c, error);
if (d->cb)
d->cb(c, error ? 0 : 1, d->userdata);
pa_operation_done(o);
}
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
SPA_EXPORT
pa_operation* pa_context_kill_client(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata)
{
pa_operation *o;
struct kill_client *d;
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
pa_context_ensure_registry(c);
o = pa_operation_new(c, NULL, do_kill_client, sizeof(struct kill_client));
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
struct card_data {
pa_card_info_cb_t cb;
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pa_context_success_cb_t success_cb;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
char *name;
uint32_t idx;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
void *userdata;
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
char *profile;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
};
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
static int card_callback(pa_context *c, struct card_data *d, struct global *g)
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
{
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pa_card_info *i = &g->card_info.info;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->cb(c, i, 0, d->userdata);
return 0;
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
}
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
static void card_info(pa_operation *o, void *userdata)
{
struct card_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context *c = o->context;
struct global *g;
int error;
if (d->name) {
g = pa_context_find_global_by_name(c, PA_SUBSCRIPTION_MASK_CARD, d->name);
pa_xfree(d->name);
} else if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & PA_SUBSCRIPTION_MASK_CARD))
g = NULL;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (g) {
error = card_callback(c, d, g);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
} else {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = PA_ERR_INVALID;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (error != 0)
pa_context_set_error(c, error);
if (d->cb)
d->cb(c, NULL, error ? -1 : 1, d->userdata);
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
pa_operation_done(o);
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
pa_operation* pa_context_get_card_info_by_index(pa_context *c, uint32_t idx, pa_card_info_cb_t cb, void *userdata)
{
pa_operation *o;
struct card_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
pw_log_debug("context %p: %u", c, idx);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
o = pa_operation_new(c, NULL, card_info, sizeof(struct card_data));
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
pa_operation* pa_context_get_card_info_by_name(pa_context *c, const char *name, pa_card_info_cb_t cb, void *userdata)
{
pa_operation *o;
struct card_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
pw_log_debug("context %p: %s", c, name);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
o = pa_operation_new(c, NULL, card_info, sizeof(struct card_data));
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->name = pa_xstrdup(name);
introspect: implement more introspect
2018-11-28 13:38:37 +01:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
}
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
static void card_info_list(pa_operation *o, void *userdata)
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
{
struct card_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context *c = o->context;
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
struct global *g;
spa_list_for_each(g, &c->globals, link) {
if (!(g->mask & PA_SUBSCRIPTION_MASK_CARD))
continue;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
card_callback(c, d, g);
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
}
d->cb(c, NULL, 1, d->userdata);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
pa_operation_done(o);
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_card_info_list(pa_context *c, pa_card_info_cb_t cb, void *userdata)
{
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
pa_operation *o;
struct card_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
pw_log_debug("context %p", c);
context: ensure the registry exists Make sure we are watching the registry before we try to enumerate objects. When we wait for new object info, resync the pending operations because they might depend on the info.
2020-06-24 14:23:41 +02:00
pa_context_ensure_registry(c);
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
o = pa_operation_new(c, NULL, card_info_list, sizeof(struct card_data));
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
d = o->userdata;
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
static void card_profile(pa_operation *o, void *userdata)
{
struct card_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct global *g;
pa_context *c = o->context;
int error = 0;
fix signed and unsigned comparisons
2019-01-07 15:04:34 +01:00
uint32_t id = SPA_ID_INVALID;
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
char buf[1024];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf));
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
struct param *p;
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (d->name) {
g = pa_context_find_global_by_name(c, PA_SUBSCRIPTION_MASK_CARD, d->name);
pa_xfree(d->name);
} else if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & PA_SUBSCRIPTION_MASK_CARD))
g = NULL;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
if (g == NULL) {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = PA_ERR_INVALID;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
goto done;
}
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
spa_list_for_each(p, &g->card_info.profiles, link) {
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
uint32_t test_id;
const char *name;
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
if (spa_pod_parse_object(p->param,
pulse: update to new pod api
2019-01-16 11:04:22 +01:00
SPA_TYPE_OBJECT_ParamProfile, NULL,
update for param api change
2019-01-18 13:39:37 +01:00
SPA_PARAM_PROFILE_index, SPA_POD_Int(&test_id),
SPA_PARAM_PROFILE_name, SPA_POD_String(&name)) < 0) {
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
pw_log_warn("device %d: can't parse profile", g->id);
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
continue;
}
if (strcmp(name, d->profile) == 0) {
id = test_id;
break;
}
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (id == SPA_ID_INVALID) {
error = PA_ERR_INVALID;
goto done;
}
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pulse: don't try to do set_param when not writable
2020-07-16 13:25:03 +02:00
if (!SPA_FLAG_IS_SET(g->permissions, PW_PERM_W | PW_PERM_X)) {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = PA_ERR_ACCESS;
pulse: don't try to do set_param when not writable
2020-07-16 13:25:03 +02:00
goto done;
}
pw_device_proxy -> pw_device
2019-12-11 15:00:41 +01:00
pw_device_set_param((struct pw_device*)g->proxy,
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
SPA_PARAM_Profile, 0,
pulse: update to new pod api
2019-01-16 11:04:22 +01:00
spa_pod_builder_add_object(&b,
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
SPA_TYPE_OBJECT_ParamProfile, SPA_PARAM_Profile,
update for param api change
2019-01-18 13:39:37 +01:00
SPA_PARAM_PROFILE_index, SPA_POD_Int(id)));
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
done:
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (error)
pa_context_set_error(c, error);
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
if (d->success_cb)
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->success_cb(c, error ? 0 : 1, d->userdata);
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pa_operation_done(o);
free(d->profile);
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_card_profile_by_index(pa_context *c, uint32_t idx, const char*profile, pa_context_success_cb_t cb, void *userdata)
{
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pa_operation *o;
struct card_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
pw_log_debug("Card set profile %s", profile);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
o = pa_operation_new(c, NULL, card_profile, sizeof(struct card_data));
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
d->success_cb = cb;
d->userdata = userdata;
d->profile = strdup(profile);
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_card_profile_by_name(pa_context *c, const char*name, const char*profile, pa_context_success_cb_t cb, void *userdata)
{
introspect: implement more
2018-12-14 16:42:36 +01:00
pa_operation *o;
struct card_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
pw_log_debug("Card set profile %s", profile);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
introspect: implement more
2018-12-14 16:42:36 +01:00
o = pa_operation_new(c, NULL, card_profile, sizeof(struct card_data));
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->name = pa_xstrdup(name);
introspect: implement more
2018-12-14 16:42:36 +01:00
d->success_cb = cb;
d->userdata = userdata;
d->profile = strdup(profile);
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_port_latency_offset(pa_context *c, const char *card_name, const char *port_name, int64_t offset, pa_context_success_cb_t cb, void *userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
struct success_ack *d;
o = pa_operation_new(c, NULL, on_success, sizeof(struct success_ack));
d = o->userdata;
d->cb = cb;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
d->error = PA_ERR_NOTIMPLEMENTED;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->userdata = userdata;
pa_operation_sync(o);
Initial import
2018-06-01 11:28:31 +02:00
pw_log_warn("Not Implemented");
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
stream: fix introspection of linked device
2018-07-04 15:33:20 +02:00
static pa_stream *find_stream(pa_context *c, uint32_t idx)
{
pa_stream *s;
spa_list_for_each(s, &c->streams, link) {
if (pw_stream_get_node_id(s->stream) == idx)
return s;
}
return NULL;
}
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
struct sink_input_data {
pa_sink_input_info_cb_t cb;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
uint32_t idx;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
void *userdata;
};
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
static int sink_input_callback(pa_context *c, struct sink_input_data *d, struct global *g)
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
{
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct global *cl;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
struct pw_node_info *info = g->info;
const char *name = NULL;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
uint32_t n;
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
pa_sink_input_info i;
pa_format_info ii[1];
stream: fix introspection of linked device
2018-07-04 15:33:20 +02:00
pa_stream *s;
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
introspect: implement enough to make gnome-control-center work We can see sources and sink and change the volume/mute of streams
2018-10-19 16:57:03 +02:00
if (info == NULL)
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
return PA_ERR_INVALID;
introspect: implement enough to make gnome-control-center work We can see sources and sink and change the volume/mute of streams
2018-10-19 16:57:03 +02:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
s = find_stream(c, g->id);
stream: fix introspection of linked device
2018-07-04 15:33:20 +02:00
stream: connect to source and sink Stream: also connect to the right source, try to convert the name to index when lookup fails, just like what pulseaudio does. Implement more proplist functions, add some more info to the stream. stream: handle NULL format Improve introspection of the sink_input and source_output name, this should be the media.name when possible.
2018-12-04 11:48:15 +01:00
if (info->props) {
update for keys
2019-05-24 15:47:05 +02:00
if ((name = spa_dict_lookup(info->props, PW_KEY_MEDIA_NAME)) == NULL &&
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
(name = spa_dict_lookup(info->props, PW_KEY_APP_NAME)) == NULL &&
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
(name = spa_dict_lookup(info->props, PW_KEY_NODE_NAME)) == NULL)
name = NULL;
stream: connect to source and sink Stream: also connect to the right source, try to convert the name to index when lookup fails, just like what pulseaudio does. Implement more proplist functions, add some more info to the stream. stream: handle NULL format Improve introspection of the sink_input and source_output name, this should be the media.name when possible.
2018-12-04 11:48:15 +01:00
}
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
if (name == NULL)
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
name = "unknown";
stream: connect to source and sink Stream: also connect to the right source, try to convert the name to index when lookup fails, just like what pulseaudio does. Implement more proplist functions, add some more info to the stream. stream: handle NULL format Improve introspection of the sink_input and source_output name, this should be the media.name when possible.
2018-12-04 11:48:15 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
cl = pa_context_find_global(c, g->node_info.client_id);
introspect: merge client properties in sink_input/source_output sink_input and source_output must contain the merged properties of the client.
2018-12-04 16:34:58 +01:00
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
spa_zero(i);
i.index = g->id;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.name = name;
introspect: implement enough to make gnome-control-center work We can see sources and sink and change the volume/mute of streams
2018-10-19 16:57:03 +02:00
i.owner_module = PA_INVALID_INDEX;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.client = g->node_info.client_id;
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
if (s) {
i.sink = s->device_index;
}
else {
context: wait till nodes are initialized before notify
2019-07-16 18:53:34 +02:00
struct global *l;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
l = pa_context_find_linked(c, g->id);
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
i.sink = l ? l->id : PA_INVALID_INDEX;
}
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
if (s && s->sample_spec.channels > 0) {
introspect: improve introspection stream: set roles
2018-07-04 18:43:45 +02:00
i.sample_spec = s->sample_spec;
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
if (s->channel_map.channels == s->sample_spec.channels)
i.channel_map = s->channel_map;
else
pa_channel_map_init_auto(&i.channel_map,
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.sample_spec.channels, PA_CHANNEL_MAP_OSS);
introspect: improve introspection stream: set roles
2018-07-04 18:43:45 +02:00
i.format = s->format;
}
else {
pulse: use format from node if available And fall back to some defaults otherwise.
2020-07-29 14:42:29 +02:00
i.sample_spec = g->node_info.sample_spec;
if (g->node_info.n_channel_volumes)
i.sample_spec.channels = g->node_info.n_channel_volumes;
else
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.sample_spec.channels = 2;
pulse: use format from node if available And fall back to some defaults otherwise.
2020-07-29 14:42:29 +02:00
if (i.sample_spec.channels == g->node_info.channel_map.channels)
i.channel_map = g->node_info.channel_map;
else
pa_channel_map_init_auto(&i.channel_map, i.sample_spec.channels, PA_CHANNEL_MAP_OSS);
introspect: improve introspection stream: set roles
2018-07-04 18:43:45 +02:00
ii[0].encoding = PA_ENCODING_PCM;
ii[0].plist = pa_proplist_new();
i.format = ii;
}
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
pa_cvolume_init(&i.volume);
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.volume.channels = i.sample_spec.channels;
for (n = 0; n < i.volume.channels; n++)
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.volume.values[n] = g->node_info.volume * g->node_info.channel_volumes[n] * PA_VOLUME_NORM;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.mute = g->node_info.mute;
introspect: improve introspection stream: set roles
2018-07-04 18:43:45 +02:00
i.buffer_usec = 0;
i.sink_usec = 0;
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
i.resample_method = "PipeWire resampler";
i.driver = "PipeWire";
introspect: improve introspection stream: set roles
2018-07-04 18:43:45 +02:00
i.proplist = pa_proplist_new_dict(info->props);
introspect: merge client properties in sink_input/source_output sink_input and source_output must contain the merged properties of the client.
2018-12-04 16:34:58 +01:00
if (cl && cl->client_info.info.proplist)
pa_proplist_update(i.proplist, PA_UPDATE_MERGE, cl->client_info.info.proplist);
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
i.corked = false;
i.has_volume = true;
i.volume_writable = true;
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pw_log_debug("context %p: sink info for %d sink:%d", c, i.index, i.sink);
context: wait till nodes are initialized before notify
2019-07-16 18:53:34 +02:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->cb(c, &i, 0, d->userdata);
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pa_proplist_free(i.proplist);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
return 0;
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
}
static void sink_input_info(pa_operation *o, void *userdata)
{
struct sink_input_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context *c = o->context;
struct global *g;
int error;
if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & PA_SUBSCRIPTION_MASK_SINK_INPUT))
g = NULL;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (g) {
error = sink_input_callback(c, d, g);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
} else {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = PA_ERR_INVALID;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (error)
pa_context_set_error(c, PA_ERR_INVALID);
d->cb(c, NULL, error ? -1 : 1, d->userdata);
stream: fix introspection of linked device
2018-07-04 15:33:20 +02:00
pa_operation_done(o);
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_sink_input_info(pa_context *c, uint32_t idx, pa_sink_input_info_cb_t cb, void *userdata)
{
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
pa_operation *o;
struct sink_input_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
introspect: implement enough to make gnome-control-center work We can see sources and sink and change the volume/mute of streams
2018-10-19 16:57:03 +02:00
pw_log_debug("context %p: info for %d", c, idx);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
o = pa_operation_new(c, NULL, sink_input_info, sizeof(struct sink_input_data));
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
d->cb = cb;
d->userdata = userdata;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
return o;
}
static void sink_input_info_list(pa_operation *o, void *userdata)
{
struct sink_input_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context *c = o->context;
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
struct global *g;
spa_list_for_each(g, &c->globals, link) {
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
if (!(g->mask & PA_SUBSCRIPTION_MASK_SINK_INPUT))
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
continue;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
sink_input_callback(c, d, g);
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
}
d->cb(c, NULL, 1, d->userdata);
stream: fix introspection of linked device
2018-07-04 15:33:20 +02:00
pa_operation_done(o);
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_sink_input_info_list(pa_context *c, pa_sink_input_info_cb_t cb, void *userdata)
{
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
pa_operation *o;
struct sink_input_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
introspect: implement enough to make gnome-control-center work We can see sources and sink and change the volume/mute of streams
2018-10-19 16:57:03 +02:00
pw_log_debug("context %p", c);
context: ensure the registry exists Make sure we are watching the registry before we try to enumerate objects. When we wait for new object info, resync the pending operations because they might depend on the info.
2020-06-24 14:23:41 +02:00
pa_context_ensure_registry(c);
introspect: implement enough to make gnome-control-center work We can see sources and sink and change the volume/mute of streams
2018-10-19 16:57:03 +02:00
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
o = pa_operation_new(c, NULL, sink_input_info_list, sizeof(struct sink_input_data));
d = o->userdata;
d->cb = cb;
d->userdata = userdata;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
introspect: wait for enum to complete Trigger another sync after starting node or device param enum
2019-03-11 18:05:24 +01:00
Various improvements context: fix memory free subscribe: implement dummy methods introspect: implement more stream: keep track of dequeued buffers ourselves because we need to be able to cancel and keep track of writable size.
2018-06-05 20:10:31 +02:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
struct target_node {
uint32_t idx;
uint32_t mask;
uint32_t target_idx;
uint32_t target_mask;
char *target_name;
pa_context_success_cb_t cb;
void *userdata;
const char *key;
};
static void do_target_node(pa_operation *o, void *userdata)
{
struct target_node *d = userdata;
pa_context *c = o->context;
pulse: check that we have access to change metadata
2020-07-30 16:23:13 +02:00
struct global *g, *t;
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
int error = 0;
pw_log_debug("%p", c);
if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & d->mask)) {
error = PA_ERR_NOENTITY;
goto done;
}
if (d->target_name) {
pulse: check that we have access to change metadata
2020-07-30 16:23:13 +02:00
t = pa_context_find_global_by_name(c, d->target_mask, d->target_name);
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
} else {
pulse: check that we have access to change metadata
2020-07-30 16:23:13 +02:00
if ((t = pa_context_find_global(c, d->target_idx)) == NULL ||
!(t->mask & d->target_mask))
t = NULL;
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
}
pulse: check that we have access to change metadata
2020-07-30 16:23:13 +02:00
if (t == NULL) {
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
error = PA_ERR_NOENTITY;
permission: add M permission The M permission is needed to set metadata on an object.
2020-07-30 16:35:14 +02:00
} else if (!SPA_FLAG_IS_SET(g->permissions, PW_PERM_M) ||
pulse: check that we have access to change metadata
2020-07-30 16:23:13 +02:00
(c->metadata && !SPA_FLAG_IS_SET(c->metadata->permissions, PW_PERM_W|PW_PERM_X))) {
error = PA_ERR_ACCESS;
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
} else if (c->metadata) {
use id to store default sink/source This is easier to handle in general and we should not use the name as a unique id. If the session manager wants to save things, it can use whatever fields it wants from the object to create a unique persistent name.
2020-07-23 11:59:13 +02:00
char buf[16];
pulse: check that we have access to change metadata
2020-07-30 16:23:13 +02:00
snprintf(buf, sizeof(buf), "%d", t->id);
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
pw_metadata_set_property(c->metadata->proxy,
pulse: check that we have access to change metadata
2020-07-30 16:23:13 +02:00
g->id, d->key, SPA_TYPE_INFO_BASE "Id", buf);
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
} else {
error = PA_ERR_NOTIMPLEMENTED;
}
done:
if (error != 0)
pa_context_set_error(c, error);
if (d->cb)
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->cb(c, error != 0 ? 0 : 1, d->userdata);
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
pa_operation_done(o);
pa_xfree(d->target_name);
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_move_sink_input_by_name(pa_context *c, uint32_t idx, const char *sink_name, pa_context_success_cb_t cb, void* userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
struct target_node *d;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
o = pa_operation_new(c, NULL, do_target_node, sizeof(struct target_node));
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d = o->userdata;
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
d->idx = idx;
d->mask = PA_SUBSCRIPTION_MASK_SINK_INPUT;
d->target_name = pa_xstrdup(sink_name);
d->target_mask = PA_SUBSCRIPTION_MASK_SINK;
use id to store default sink/source This is easier to handle in general and we should not use the name as a unique id. If the session manager wants to save things, it can use whatever fields it wants from the object to create a unique persistent name.
2020-07-23 11:59:13 +02:00
d->key = METADATA_TARGET_NODE;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_move_sink_input_by_index(pa_context *c, uint32_t idx, uint32_t sink_idx, pa_context_success_cb_t cb, void* userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
struct target_node *d;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
o = pa_operation_new(c, NULL, do_target_node, sizeof(struct target_node));
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d = o->userdata;
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
d->idx = idx;
d->mask = PA_SUBSCRIPTION_MASK_SINK_INPUT;
d->target_idx = sink_idx;
d->target_mask = PA_SUBSCRIPTION_MASK_SINK;
use id to store default sink/source This is easier to handle in general and we should not use the name as a unique id. If the session manager wants to save things, it can use whatever fields it wants from the object to create a unique persistent name.
2020-07-23 11:59:13 +02:00
d->key = METADATA_TARGET_NODE;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct stream_volume {
uint32_t idx;
uint32_t mask;
bool have_volume;
pa_cvolume volume;
int mute;
pa_context_success_cb_t cb;
void *userdata;
};
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
static void do_stream_volume_mute(pa_operation *o, void *userdata)
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
{
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct stream_volume *d = userdata;
pa_context *c = o->context;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
struct global *g;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
int error = 0;
pa_stream *s;
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if ((s = find_stream(c, d->idx)) == NULL) {
if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & d->mask))
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
g = NULL;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
}
if (s) {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = set_stream_volume(c, s,
d->have_volume ? &d->volume : NULL,
d->have_volume ? s->mute : d->mute);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
} else if (g) {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = set_node_volume(c, g,
d->have_volume ? &d->volume : NULL,
d->have_volume ? g->node_info.mute : d->mute);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
} else {
error = PA_ERR_INVALID;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (error != 0)
pa_context_set_error(c, error);
if (d->cb)
d->cb(c, error != 0 ? 0 : 1, d->userdata);
pa_operation_done(o);
}
SPA_EXPORT
pa_operation* pa_context_set_sink_input_volume(pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata)
{
pa_operation *o;
struct stream_volume *d;
pw_log_debug("contex %p: index %d", c, idx);
pa_context_ensure_registry(c);
o = pa_operation_new(c, NULL, do_stream_volume_mute, sizeof(struct stream_volume));
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
d->mask = PA_SUBSCRIPTION_MASK_SINK_INPUT;
d->volume = *volume;
d->have_volume = true;
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
d->cb = cb;
d->userdata = userdata;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
return o;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_sink_input_mute(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata)
{
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
pa_operation *o;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct stream_volume *d;
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
context: use subscribe params Improve volume setting
2019-03-18 16:11:23 +01:00
pw_log_debug("contex %p: index %d", c, idx);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
context: use subscribe params Improve volume setting
2019-03-18 16:11:23 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
o = pa_operation_new(c, NULL, do_stream_volume_mute, sizeof(struct stream_volume));
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
d->mask = PA_SUBSCRIPTION_MASK_SINK_INPUT;
d->mute = mute;
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
d->cb = cb;
d->userdata = userdata;
pulse: improve remote sync Add an explicit method to make the operation to a roundtrip to sync pending actions. Implement drain.
2018-08-02 10:31:29 +02:00
pa_operation_sync(o);
context: rework how we introspect Use the properties of the global to mark the global type, use this to filter the objects. Hook up the volume control
2018-07-03 22:03:25 +02:00
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct kill_stream {
uint32_t idx;
uint32_t mask;
pa_context_success_cb_t cb;
void *userdata;
};
static void do_kill_stream(pa_operation *o, void *userdata)
Initial import
2018-06-01 11:28:31 +02:00
{
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct kill_stream *d = userdata;
pa_context *c = o->context;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
struct global *g;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
int error = 0;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_stream *s;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if ((s = find_stream(c, d->idx)) == NULL) {
if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & d->mask))
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
g = NULL;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
}
if (s) {
pw_stream_destroy(s->stream);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
} else if (g) {
pw_registry_proxy -> pw_registry
2019-12-11 09:44:48 +01:00
pw_registry_destroy(c->registry, g->id);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
} else {
error = PA_ERR_INVALID;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (error != 0)
pa_context_set_error(c, error);
if (d->cb)
d->cb(c, error != 0 ? 0 : 1, d->userdata);
pa_operation_done(o);
}
SPA_EXPORT
pa_operation* pa_context_kill_sink_input(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata)
{
pa_operation *o;
struct kill_stream *d;
pw_log_debug("contex %p: index %d", c, idx);
pa_context_ensure_registry(c);
o = pa_operation_new(c, NULL, do_kill_stream, sizeof(struct kill_stream));
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
d->mask = PA_SUBSCRIPTION_MASK_SINK_INPUT;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
struct source_output_data {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
uint32_t idx;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
pa_source_output_info_cb_t cb;
void *userdata;
};
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
static int source_output_callback(struct source_output_data *d, pa_context *c, struct global *g)
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
{
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct global *l, *cl;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
struct pw_node_info *info = g->info;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
const char *name = NULL;
uint32_t n;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
pa_source_output_info i;
pa_format_info ii[1];
pa_stream *s;
pw_log_debug("index %d", g->id);
introspect: implement enough to make gnome-control-center work We can see sources and sink and change the volume/mute of streams
2018-10-19 16:57:03 +02:00
if (info == NULL)
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
return PA_ERR_INVALID;
introspect: implement enough to make gnome-control-center work We can see sources and sink and change the volume/mute of streams
2018-10-19 16:57:03 +02:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
s = find_stream(c, g->id);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
if (info->props) {
update for keys
2019-05-24 15:47:05 +02:00
if ((name = spa_dict_lookup(info->props, PW_KEY_MEDIA_NAME)) == NULL &&
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
(name = spa_dict_lookup(info->props, PW_KEY_APP_NAME)) == NULL &&
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
(name = spa_dict_lookup(info->props, PW_KEY_NODE_NAME)) == NULL)
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
name = NULL;
stream: connect to source and sink Stream: also connect to the right source, try to convert the name to index when lookup fails, just like what pulseaudio does. Implement more proplist functions, add some more info to the stream. stream: handle NULL format Improve introspection of the sink_input and source_output name, this should be the media.name when possible.
2018-12-04 11:48:15 +01:00
}
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
if (name == NULL)
name = "unknown";
stream: connect to source and sink Stream: also connect to the right source, try to convert the name to index when lookup fails, just like what pulseaudio does. Implement more proplist functions, add some more info to the stream. stream: handle NULL format Improve introspection of the sink_input and source_output name, this should be the media.name when possible.
2018-12-04 11:48:15 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
cl = pa_context_find_global(c, g->node_info.client_id);
introspect: merge client properties in sink_input/source_output sink_input and source_output must contain the merged properties of the client.
2018-12-04 16:34:58 +01:00
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
spa_zero(i);
i.index = g->id;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.name = name;
introspect: implement enough to make gnome-control-center work We can see sources and sink and change the volume/mute of streams
2018-10-19 16:57:03 +02:00
i.owner_module = PA_INVALID_INDEX;
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.client = g->node_info.client_id;
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
if (s) {
i.source = s->device_index;
}
else {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
l = pa_context_find_linked(c, g->id);
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
i.source = l ? l->id : PA_INVALID_INDEX;
}
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
if (s && s->sample_spec.channels > 0) {
i.sample_spec = s->sample_spec;
context: list audio devices as cards Find the sink/source a stream is linked to
2018-11-28 11:13:21 +01:00
if (s->channel_map.channels == s->sample_spec.channels)
i.channel_map = s->channel_map;
else
pa_channel_map_init_auto(&i.channel_map,
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.sample_spec.channels, PA_CHANNEL_MAP_OSS);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.format = s->format;
}
else {
pulse: use format from node if available And fall back to some defaults otherwise.
2020-07-29 14:42:29 +02:00
i.sample_spec = g->node_info.sample_spec;
if (g->node_info.n_channel_volumes)
i.sample_spec.channels = g->node_info.n_channel_volumes;
else
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.sample_spec.channels = 2;
pulse: use format from node if available And fall back to some defaults otherwise.
2020-07-29 14:42:29 +02:00
if (i.sample_spec.channels == g->node_info.channel_map.channels)
i.channel_map = g->node_info.channel_map;
else
pa_channel_map_init_auto(&i.channel_map, i.sample_spec.channels, PA_CHANNEL_MAP_OSS);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
ii[0].encoding = PA_ENCODING_PCM;
ii[0].plist = pa_proplist_new();
i.format = ii;
}
context: improve introspection When subscribing, always bind to all objects we are interested in. Wait until all info is collected and then reply to introspection requests.
2019-03-15 20:31:20 +01:00
pa_cvolume_init(&i.volume);
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
i.volume.channels = i.sample_spec.channels;
for (n = 0; n < i.volume.channels; n++)
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.volume.values[n] = g->node_info.volume * g->node_info.channel_volumes[n] * PA_VOLUME_NORM;
pulse: update per channel volumes Use the channelVolume property to update the individual channel volumes. Update property values to match pulseaudio. Handle the case where the number of channels changes. In pulse this can normally never happen. Emit a remove and add of the node when this happens as to not confuse pulse clients.
2019-08-12 12:31:55 +02:00
pulse: don't use endpoints Revert back to using nodes, ports and devices. Let's first get this stable until we add endpoints in the mix.
2020-01-13 09:30:25 +01:00
i.mute = g->node_info.mute;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.buffer_usec = 0;
i.source_usec = 0;
i.resample_method = "PipeWire resampler";
i.driver = "PipeWire";
i.proplist = pa_proplist_new_dict(info->props);
introspect: merge client properties in sink_input/source_output sink_input and source_output must contain the merged properties of the client.
2018-12-04 16:34:58 +01:00
if (cl && cl->client_info.info.proplist)
pa_proplist_update(i.proplist, PA_UPDATE_MERGE, cl->client_info.info.proplist);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
i.corked = false;
i.has_volume = true;
i.volume_writable = true;
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->cb(c, &i, 0, d->userdata);
introspect: improve introspection Update introspection structures when we get the info from pipewire.
2018-11-29 17:30:24 +01:00
pa_proplist_free(i.proplist);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
return 0;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
}
static void source_output_info(pa_operation *o, void *userdata)
{
struct source_output_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context *c = o->context;
struct global *g;
int error;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if ((g = pa_context_find_global(c, d->idx)) == NULL ||
!(g->mask & PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT))
g = NULL;
if (g) {
error = source_output_callback(d, c, g);
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
} else {
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
error = PA_ERR_INVALID;
pulse: improve pa_operation compatibility Methods that return a pa_operation should not return NULL. pa_context_success_cb_t should return 1 on success and 0 on failure with the error set in the context. When a global is not found, let the info operation return eol = -1 with the error set in the context.
2020-02-03 16:44:50 +01:00
}
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
if (error)
pa_context_set_error(c, error);
d->cb(c, NULL, error ? -1 : 1, d->userdata);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
pa_operation_done(o);
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_source_output_info(pa_context *c, uint32_t idx, pa_source_output_info_cb_t cb, void *userdata)
{
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
pa_operation *o;
struct source_output_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
o = pa_operation_new(c, NULL, source_output_info, sizeof(struct source_output_data));
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
}
static void source_output_info_list(pa_operation *o, void *userdata)
{
struct source_output_data *d = userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context *c = o->context;
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
struct global *g;
spa_list_for_each(g, &c->globals, link) {
if (!(g->mask & PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT))
continue;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
source_output_callback(d, c, g);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
}
d->cb(c, NULL, 1, d->userdata);
pa_operation_done(o);
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_source_output_info_list(pa_context *c, pa_source_output_info_cb_t cb, void *userdata)
{
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
pa_operation *o;
struct source_output_data *d;
pa_assert(c);
pa_assert(c->refcount >= 1);
pa_assert(cb);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
context: ensure the registry exists Make sure we are watching the registry before we try to enumerate objects. When we wait for new object info, resync the pending operations because they might depend on the info.
2020-06-24 14:23:41 +02:00
pa_context_ensure_registry(c);
implement more methods Implement extensions with dummies Implement some more introspection, enough to make pavucontrol start Implement volume changes on sink_input
2018-10-19 13:30:20 +02:00
o = pa_operation_new(c, NULL, source_output_info_list, sizeof(struct source_output_data));
d = o->userdata;
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_move_source_output_by_name(pa_context *c, uint32_t idx, const char *source_name, pa_context_success_cb_t cb, void* userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
struct target_node *d;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
o = pa_operation_new(c, NULL, do_target_node, sizeof(struct target_node));
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d = o->userdata;
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
d->idx = idx;
d->mask = PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT;
d->target_name = pa_xstrdup(source_name);
d->target_mask = PA_SUBSCRIPTION_MASK_SOURCE;
use id to store default sink/source This is easier to handle in general and we should not use the name as a unique id. If the session manager wants to save things, it can use whatever fields it wants from the object to create a unique persistent name.
2020-07-23 11:59:13 +02:00
d->key = METADATA_TARGET_NODE;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_move_source_output_by_index(pa_context *c, uint32_t idx, uint32_t source_idx, pa_context_success_cb_t cb, void* userdata)
{
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pa_operation *o;
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
struct target_node *d;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
o = pa_operation_new(c, NULL, do_target_node, sizeof(struct target_node));
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d = o->userdata;
introspect: set target node as property Use the metadata to tag streams with the desired target node.
2020-07-20 11:26:32 +02:00
d->idx = idx;
d->mask = PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT;
d->target_idx = source_idx;
d->target_mask = PA_SUBSCRIPTION_MASK_SOURCE;
use id to store default sink/source This is easier to handle in general and we should not use the name as a unique id. If the session manager wants to save things, it can use whatever fields it wants from the object to create a unique persistent name.
2020-07-23 11:59:13 +02:00
d->key = METADATA_TARGET_NODE;
context: Improve not implemented methods Let the not implemented methods return an operation instead of NULL to make clients happy.
2019-04-17 15:44:40 +02:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_source_output_volume(pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata)
{
introspect: implement more
2018-12-14 16:42:36 +01:00
pa_operation *o;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct stream_volume *d;
introspect: implement more
2018-12-14 16:42:36 +01:00
implement more API Implement the sink/source volume/mute api
2019-01-04 10:00:57 +01:00
pw_log_debug("contex %p: index %d", c, idx);
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pa_context_ensure_registry(c);
introspect: implement more
2018-12-14 16:42:36 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
o = pa_operation_new(c, NULL, do_stream_volume_mute, sizeof(struct stream_volume));
introspect: implement more
2018-12-14 16:42:36 +01:00
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
d->mask = PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT;
d->volume = *volume;
d->have_volume = true;
introspect: implement more
2018-12-14 16:42:36 +01:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_set_source_output_mute(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata)
{
introspect: implement more
2018-12-14 16:42:36 +01:00
pa_operation *o;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct stream_volume *d;
introspect: implement more
2018-12-14 16:42:36 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pw_log_debug("contex %p: index %d", c, idx);
pa_context_ensure_registry(c);
o = pa_operation_new(c, NULL, do_stream_volume_mute, sizeof(struct stream_volume));
introspect: implement more
2018-12-14 16:42:36 +01:00
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
d->mask = PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT;
d->mute = mute;
introspect: implement more
2018-12-14 16:42:36 +01:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_kill_source_output(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata)
{
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
pa_operation *o;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
struct kill_stream *d;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
pw_log_debug("contex %p: index %d", c, idx);
pa_context_ensure_registry(c);
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
o = pa_operation_new(c, NULL, do_kill_stream, sizeof(struct kill_stream));
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
d = o->userdata;
pulse: clean up introspection Make sure we always first update the registry. Call callbacks with the right return value and set the context error on errors correctly. Remove some old code.
2020-07-20 13:13:22 +02:00
d->idx = idx;
d->mask = PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT;
introspect: implement kill operations
2018-12-04 16:36:49 +01:00
d->cb = cb;
d->userdata = userdata;
pa_operation_sync(o);
return o;
Initial import
2018-06-01 11:28:31 +02:00
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_stat(pa_context *c, pa_stat_info_cb_t cb, void *userdata)
{
pw_log_warn("Not Implemented");
return NULL;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_sample_info_by_name(pa_context *c, const char *name, pa_sample_info_cb_t cb, void *userdata)
{
pw_log_warn("Not Implemented");
return NULL;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_sample_info_by_index(pa_context *c, uint32_t idx, pa_sample_info_cb_t cb, void *userdata)
{
pw_log_warn("Not Implemented");
return NULL;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_sample_info_list(pa_context *c, pa_sample_info_cb_t cb, void *userdata)
{
pw_log_warn("Not Implemented");
return NULL;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_autoload_info_by_name(pa_context *c, const char *name, pa_autoload_type_t type, pa_autoload_info_cb_t cb, void *userdata)
{
pw_log_warn("Deprecated: Not Implemented");
return NULL;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_autoload_info_by_index(pa_context *c, uint32_t idx, pa_autoload_info_cb_t cb, void *userdata)
{
pw_log_warn("Deprecated: Not Implemented");
return NULL;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_get_autoload_info_list(pa_context *c, pa_autoload_info_cb_t cb, void *userdata)
{
pw_log_warn("Deprecated: Not Implemented");
return NULL;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_add_autoload(pa_context *c, const char *name, pa_autoload_type_t type, const char *module, const char*argument, pa_context_index_cb_t cb, void* userdata)
{
pw_log_warn("Deprecated: Not Implemented");
return NULL;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_remove_autoload_by_name(pa_context *c, const char *name, pa_autoload_type_t type, pa_context_success_cb_t cb, void* userdata)
{
pw_log_warn("Deprecated: Not Implemented");
return NULL;
}
pulse: add SPA_EXPORT
2019-02-06 13:23:43 +01:00
SPA_EXPORT
Initial import
2018-06-01 11:28:31 +02:00
pa_operation* pa_context_remove_autoload_by_index(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void* userdata)
{
pw_log_warn("Deprecated: Not Implemented");
return NULL;
}
Reference in a new issue Copy permalink