mirror of
https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git
synced 2025-11-20 06:59:53 -05:00
virtual sink: Factor out common code
This patch moves the code for the virtual sink callbacks and initialization to a separate file. The code is re-factored, extended and built as library, so that it can be used by other virtual sinks as well. The suspend-virtual-on-master-suspend fix for the ladspa sink (!68) was incorporated into the common code as well as the sink part of !78 which fixes a crash with stacked virtual sinks. !68 has a bug which leaves a virtual sink unavailable when the master sink disappears. This bug is also fixed. Additionally, fixed block size filters, fixed window size filters and updating filter parameters are supported by the library. Fixed window size filters always deliver the same number of frames to the filter, padding new data with history frames if necessary. Rewinding can be disabled or or limited to the number of frames that the virtual sink supports. Thanks to Alexander E. Patrakov for pointing out how to rewind fixed block size filters. The library implements following command line arguments if they are enabled in valid_modargs: sink_name, sink_properties, sink_input_properties, force_flat_volume, remix, resample_method and autoloaded.
This commit is contained in:
Georg Chini
parent
d18756fda9
commit
1edc7eb655
6 changed files with 1532 additions and 527 deletions
|
|
@ -2,6 +2,17 @@ if host_machine.system() != 'windows'
|
|||
subdir('rtp')
|
||||
endif
|
||||
|
||||
libvirtual_sink = shared_library('virtual_sink',
|
||||
'virtual-sink-common.c',
|
||||
'virtual-sink-common.h',
|
||||
c_args : [pa_c_args, server_c_args],
|
||||
include_directories : [configinc, topinc],
|
||||
dependencies : [libpulse_dep, libpulsecommon_dep, libpulsecore_dep],
|
||||
install_rpath : privlibdir,
|
||||
install : true,
|
||||
install_dir : modlibexecdir
|
||||
)
|
||||
|
||||
# module name, sources, [headers, extra flags, extra deps, extra libs]
|
||||
all_modules = [
|
||||
[ 'module-allow-passthrough', 'module-allow-passthrough.c' ],
|
||||
|
|
@ -55,7 +66,7 @@ all_modules = [
|
|||
[ 'module-tunnel-sink-new', ['module-tunnel-sink-new.c', 'restart-module.c'] ],
|
||||
[ 'module-tunnel-source', ['module-tunnel.c', 'restart-module.c'], [], [], [x11_dep] ],
|
||||
[ 'module-tunnel-source-new', ['module-tunnel-source-new.c', 'restart-module.c'] ],
|
||||
[ 'module-virtual-sink', 'module-virtual-sink.c' ],
|
||||
[ 'module-virtual-sink', 'module-virtual-sink.c', [], [], [], libvirtual_sink ],
|
||||
[ 'module-virtual-source', 'module-virtual-source.c' ],
|
||||
[ 'module-volume-restore', 'module-volume-restore.c' ],
|
||||
]
|
||||
|
|
|
|||
|
|
@ -22,15 +22,15 @@
|
|||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <modules/virtual-sink-common.h>
|
||||
|
||||
#include <pulse/gccmacro.h>
|
||||
#include <pulse/xmalloc.h>
|
||||
|
||||
#include <pulsecore/i18n.h>
|
||||
#include <pulsecore/namereg.h>
|
||||
#include <pulsecore/sink.h>
|
||||
#include <pulsecore/module.h>
|
||||
#include <pulsecore/core-util.h>
|
||||
#include <pulsecore/modargs.h>
|
||||
#include <pulsecore/log.h>
|
||||
#include <pulsecore/rtpoll.h>
|
||||
#include <pulsecore/sample-util.h>
|
||||
|
|
@ -46,25 +46,17 @@ PA_MODULE_USAGE(
|
|||
"master=<name of sink to filter> "
|
||||
"rate=<sample rate> "
|
||||
"channels=<number of channels> "
|
||||
"format=<sample format> "
|
||||
"channel_map=<channel map> "
|
||||
"use_volume_sharing=<yes or no> "
|
||||
"force_flat_volume=<yes or no> "
|
||||
));
|
||||
|
||||
#define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
|
||||
|
||||
struct userdata {
|
||||
pa_module *module;
|
||||
|
||||
/* FIXME: Uncomment this and take "autoloaded" as a modarg if this is a filter */
|
||||
/* bool autoloaded; */
|
||||
pa_vsink *vsink;
|
||||
|
||||
pa_sink *sink;
|
||||
pa_sink_input *sink_input;
|
||||
|
||||
pa_memblockq *memblockq;
|
||||
|
||||
bool auto_desc;
|
||||
unsigned channels;
|
||||
};
|
||||
|
||||
|
|
@ -74,6 +66,7 @@ static const char* const valid_modargs[] = {
|
|||
"master",
|
||||
"rate",
|
||||
"channels",
|
||||
"format",
|
||||
"channel_map",
|
||||
"use_volume_sharing",
|
||||
"force_flat_volume",
|
||||
|
|
@ -81,397 +74,17 @@ static const char* const valid_modargs[] = {
|
|||
};
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
|
||||
struct userdata *u = PA_SINK(o)->userdata;
|
||||
|
||||
switch (code) {
|
||||
|
||||
case PA_SINK_MESSAGE_GET_LATENCY:
|
||||
|
||||
/* The sink is _put() before the sink input is, so let's
|
||||
* make sure we don't access it in that time. Also, the
|
||||
* sink input is first shut down, the sink second. */
|
||||
if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
|
||||
!PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state)) {
|
||||
*((int64_t*) data) = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
*((int64_t*) data) =
|
||||
|
||||
/* Get the latency of the master sink */
|
||||
pa_sink_get_latency_within_thread(u->sink_input->sink, true) +
|
||||
|
||||
/* Add the latency internal to our sink input on top */
|
||||
pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->sink_input->sink->sample_spec);
|
||||
|
||||
/* Add resampler latency */
|
||||
*((int64_t*) data) += pa_resampler_get_delay_usec(u->sink_input->thread_info.resampler);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pa_sink_process_msg(o, code, data, offset, chunk);
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
static int sink_set_state_in_main_thread_cb(pa_sink *s, pa_sink_state_t state, pa_suspend_cause_t suspend_cause) {
|
||||
static void filter_process_chunk(uint8_t *src, uint8_t *dst, unsigned in_count, unsigned out_count, void *userdata) {
|
||||
struct userdata *u;
|
||||
unsigned buffer_size;
|
||||
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
pa_assert_se(u = userdata);
|
||||
pa_assert(in_count == out_count);
|
||||
|
||||
if (!PA_SINK_IS_LINKED(state) ||
|
||||
!PA_SINK_INPUT_IS_LINKED(u->sink_input->state))
|
||||
return 0;
|
||||
|
||||
pa_sink_input_cork(u->sink_input, state == PA_SINK_SUSPENDED);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Called from the IO thread. */
|
||||
static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state, pa_suspend_cause_t new_suspend_cause) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_assert(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
|
||||
/* When set to running or idle for the first time, request a rewind
|
||||
* of the master sink to make sure we are heard immediately */
|
||||
if (PA_SINK_IS_OPENED(new_state) && s->thread_info.state == PA_SINK_INIT) {
|
||||
pa_log_debug("Requesting rewind due to state change.");
|
||||
pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_request_rewind_cb(pa_sink *s) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
|
||||
if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
|
||||
!PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state))
|
||||
return;
|
||||
|
||||
/* Just hand this one over to the master sink */
|
||||
pa_sink_input_request_rewind(u->sink_input,
|
||||
s->thread_info.rewind_nbytes +
|
||||
pa_memblockq_get_length(u->memblockq), true, false, false);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_update_requested_latency_cb(pa_sink *s) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
|
||||
if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
|
||||
!PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state))
|
||||
return;
|
||||
|
||||
/* Just hand this one over to the master sink */
|
||||
pa_sink_input_set_requested_latency_within_thread(
|
||||
u->sink_input,
|
||||
pa_sink_get_requested_latency_within_thread(s));
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
static void sink_set_volume_cb(pa_sink *s) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
|
||||
if (!PA_SINK_IS_LINKED(s->state) ||
|
||||
!PA_SINK_INPUT_IS_LINKED(u->sink_input->state))
|
||||
return;
|
||||
|
||||
pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, true);
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
static void sink_set_mute_cb(pa_sink *s) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
|
||||
if (!PA_SINK_IS_LINKED(s->state) ||
|
||||
!PA_SINK_INPUT_IS_LINKED(u->sink_input->state))
|
||||
return;
|
||||
|
||||
pa_sink_input_set_mute(u->sink_input, s->muted, s->save_muted);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
|
||||
struct userdata *u;
|
||||
float *src, *dst;
|
||||
size_t fs;
|
||||
unsigned n, c;
|
||||
pa_memchunk tchunk;
|
||||
pa_usec_t current_latency PA_GCC_UNUSED;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert(chunk);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
if (!PA_SINK_IS_LINKED(u->sink->thread_info.state))
|
||||
return -1;
|
||||
|
||||
/* Hmm, process any rewind request that might be queued up */
|
||||
pa_sink_process_rewind(u->sink, 0);
|
||||
|
||||
/* (1) IF YOU NEED A FIXED BLOCK SIZE USE
|
||||
* pa_memblockq_peek_fixed_size() HERE INSTEAD. NOTE THAT FILTERS
|
||||
* WHICH CAN DEAL WITH DYNAMIC BLOCK SIZES ARE HIGHLY
|
||||
* PREFERRED. */
|
||||
while (pa_memblockq_peek(u->memblockq, &tchunk) < 0) {
|
||||
pa_memchunk nchunk;
|
||||
|
||||
pa_sink_render(u->sink, nbytes, &nchunk);
|
||||
pa_memblockq_push(u->memblockq, &nchunk);
|
||||
pa_memblock_unref(nchunk.memblock);
|
||||
}
|
||||
|
||||
/* (2) IF YOU NEED A FIXED BLOCK SIZE, THIS NEXT LINE IS NOT
|
||||
* NECESSARY */
|
||||
tchunk.length = PA_MIN(nbytes, tchunk.length);
|
||||
pa_assert(tchunk.length > 0);
|
||||
|
||||
fs = pa_frame_size(&i->sample_spec);
|
||||
n = (unsigned) (tchunk.length / fs);
|
||||
|
||||
pa_assert(n > 0);
|
||||
|
||||
chunk->index = 0;
|
||||
chunk->length = n*fs;
|
||||
chunk->memblock = pa_memblock_new(i->sink->core->mempool, chunk->length);
|
||||
|
||||
pa_memblockq_drop(u->memblockq, chunk->length);
|
||||
|
||||
src = pa_memblock_acquire_chunk(&tchunk);
|
||||
dst = pa_memblock_acquire(chunk->memblock);
|
||||
|
||||
/* (3) PUT YOUR CODE HERE TO DO SOMETHING WITH THE DATA */
|
||||
buffer_size = pa_frame_size(&u->vsink->sink->sample_spec) * in_count;
|
||||
|
||||
/* As an example, copy input to output */
|
||||
for (c = 0; c < u->channels; c++) {
|
||||
pa_sample_clamp(PA_SAMPLE_FLOAT32NE,
|
||||
dst+c, u->channels * sizeof(float),
|
||||
src+c, u->channels * sizeof(float),
|
||||
n);
|
||||
}
|
||||
|
||||
pa_memblock_release(tchunk.memblock);
|
||||
pa_memblock_release(chunk->memblock);
|
||||
|
||||
pa_memblock_unref(tchunk.memblock);
|
||||
|
||||
/* (4) IF YOU NEED THE LATENCY FOR SOMETHING ACQUIRE IT LIKE THIS: */
|
||||
current_latency =
|
||||
/* Get the latency of the master sink */
|
||||
pa_sink_get_latency_within_thread(i->sink, false) +
|
||||
|
||||
/* Add the latency internal to our sink input on top */
|
||||
pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
|
||||
struct userdata *u;
|
||||
size_t amount = 0;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
/* If the sink is not yet linked, there is nothing to rewind */
|
||||
if (!PA_SINK_IS_LINKED(u->sink->thread_info.state))
|
||||
return;
|
||||
|
||||
if (u->sink->thread_info.rewind_nbytes > 0) {
|
||||
size_t max_rewrite;
|
||||
|
||||
max_rewrite = nbytes + pa_memblockq_get_length(u->memblockq);
|
||||
amount = PA_MIN(u->sink->thread_info.rewind_nbytes, max_rewrite);
|
||||
u->sink->thread_info.rewind_nbytes = 0;
|
||||
|
||||
if (amount > 0) {
|
||||
pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE, true);
|
||||
|
||||
/* (5) PUT YOUR CODE HERE TO RESET YOUR FILTER */
|
||||
}
|
||||
}
|
||||
|
||||
pa_sink_process_rewind(u->sink, amount);
|
||||
pa_memblockq_rewind(u->memblockq, nbytes);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
/* FIXME: Too small max_rewind:
|
||||
* https://bugs.freedesktop.org/show_bug.cgi?id=53709 */
|
||||
pa_memblockq_set_maxrewind(u->memblockq, nbytes);
|
||||
pa_sink_set_max_rewind_within_thread(u->sink, nbytes);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
/* (6) IF YOU NEED A FIXED BLOCK SIZE ROUND nbytes UP TO MULTIPLES
|
||||
* OF IT HERE. THE PA_ROUND_UP MACRO IS USEFUL FOR THAT. */
|
||||
|
||||
pa_sink_set_max_request_within_thread(u->sink, nbytes);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_update_sink_latency_range_cb(pa_sink_input *i) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_update_sink_fixed_latency_cb(pa_sink_input *i) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
/* (7) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
|
||||
* BLOCK MINUS ONE SAMPLE HERE. pa_usec_to_bytes_round_up() IS
|
||||
* USEFUL FOR THAT. */
|
||||
|
||||
pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_detach_cb(pa_sink_input *i) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
if (PA_SINK_IS_LINKED(u->sink->thread_info.state))
|
||||
pa_sink_detach_within_thread(u->sink);
|
||||
|
||||
pa_sink_set_rtpoll(u->sink, NULL);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_attach_cb(pa_sink_input *i) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
pa_sink_set_rtpoll(u->sink, i->sink->thread_info.rtpoll);
|
||||
pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
|
||||
|
||||
/* (8.1) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
|
||||
* BLOCK MINUS ONE SAMPLE HERE. SEE (7) */
|
||||
pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
|
||||
|
||||
/* (8.2) IF YOU NEED A FIXED BLOCK SIZE ROUND
|
||||
* pa_sink_input_get_max_request(i) UP TO MULTIPLES OF IT
|
||||
* HERE. SEE (6) */
|
||||
pa_sink_set_max_request_within_thread(u->sink, pa_sink_input_get_max_request(i));
|
||||
|
||||
/* FIXME: Too small max_rewind:
|
||||
* https://bugs.freedesktop.org/show_bug.cgi?id=53709 */
|
||||
pa_sink_set_max_rewind_within_thread(u->sink, pa_sink_input_get_max_rewind(i));
|
||||
|
||||
if (PA_SINK_IS_LINKED(u->sink->thread_info.state))
|
||||
pa_sink_attach_within_thread(u->sink);
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
static void sink_input_kill_cb(pa_sink_input *i) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
/* The order here matters! We first kill the sink so that streams
|
||||
* can properly be moved away while the sink input is still connected
|
||||
* to the master. */
|
||||
pa_sink_input_cork(u->sink_input, true);
|
||||
pa_sink_unlink(u->sink);
|
||||
pa_sink_input_unlink(u->sink_input);
|
||||
|
||||
pa_sink_input_unref(u->sink_input);
|
||||
u->sink_input = NULL;
|
||||
|
||||
pa_sink_unref(u->sink);
|
||||
u->sink = NULL;
|
||||
|
||||
pa_module_unload_request(u->module, true);
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
if (dest) {
|
||||
pa_sink_set_asyncmsgq(u->sink, dest->asyncmsgq);
|
||||
pa_sink_update_flags(u->sink, PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY, dest->flags);
|
||||
} else
|
||||
pa_sink_set_asyncmsgq(u->sink, NULL);
|
||||
|
||||
if (u->auto_desc && dest) {
|
||||
const char *z;
|
||||
pa_proplist *pl;
|
||||
|
||||
pl = pa_proplist_new();
|
||||
z = pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_DESCRIPTION);
|
||||
pa_proplist_setf(pl, PA_PROP_DEVICE_DESCRIPTION, "Virtual Sink %s on %s",
|
||||
pa_proplist_gets(u->sink->proplist, "device.vsink.name"), z ? z : dest->name);
|
||||
|
||||
pa_sink_update_proplist(u->sink, PA_UPDATE_REPLACE, pl);
|
||||
pa_proplist_free(pl);
|
||||
}
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
static void sink_input_volume_changed_cb(pa_sink_input *i) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
pa_sink_volume_changed(u->sink, &i->volume);
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
static void sink_input_mute_changed_cb(pa_sink_input *i) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
pa_sink_mute_changed(u->sink, i->muted);
|
||||
memcpy(dst, src, buffer_size);
|
||||
}
|
||||
|
||||
int pa__init(pa_module*m) {
|
||||
|
|
@ -480,11 +93,7 @@ int pa__init(pa_module*m) {
|
|||
pa_channel_map map;
|
||||
pa_modargs *ma;
|
||||
pa_sink *master=NULL;
|
||||
pa_sink_input_new_data sink_input_data;
|
||||
pa_sink_new_data sink_data;
|
||||
bool use_volume_sharing = true;
|
||||
bool force_flat_volume = false;
|
||||
pa_memchunk silence;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -501,7 +110,6 @@ int pa__init(pa_module*m) {
|
|||
pa_assert(master);
|
||||
|
||||
ss = master->sample_spec;
|
||||
ss.format = PA_SAMPLE_FLOAT32;
|
||||
map = master->channel_map;
|
||||
if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
|
||||
pa_log("Invalid sample format specification or channel map");
|
||||
|
|
@ -513,118 +121,23 @@ int pa__init(pa_module*m) {
|
|||
goto fail;
|
||||
}
|
||||
|
||||
if (pa_modargs_get_value_boolean(ma, "force_flat_volume", &force_flat_volume) < 0) {
|
||||
pa_log("force_flat_volume= expects a boolean argument");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (use_volume_sharing && force_flat_volume) {
|
||||
pa_log("Flat volume can't be forced when using volume sharing.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u = pa_xnew0(struct userdata, 1);
|
||||
u->module = m;
|
||||
m->userdata = u;
|
||||
u->channels = ss.channels;
|
||||
|
||||
/* Create sink */
|
||||
pa_sink_new_data_init(&sink_data);
|
||||
sink_data.driver = __FILE__;
|
||||
sink_data.module = m;
|
||||
if (!(sink_data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
|
||||
sink_data.name = pa_sprintf_malloc("%s.vsink", master->name);
|
||||
pa_sink_new_data_set_sample_spec(&sink_data, &ss);
|
||||
pa_sink_new_data_set_channel_map(&sink_data, &map);
|
||||
pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, master->name);
|
||||
pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_CLASS, "filter");
|
||||
pa_proplist_sets(sink_data.proplist, "device.vsink.name", sink_data.name);
|
||||
|
||||
if (pa_modargs_get_proplist(ma, "sink_properties", sink_data.proplist, PA_UPDATE_REPLACE) < 0) {
|
||||
pa_log("Invalid properties");
|
||||
pa_sink_new_data_done(&sink_data);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if ((u->auto_desc = !pa_proplist_contains(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION))) {
|
||||
const char *z;
|
||||
|
||||
z = pa_proplist_gets(master->proplist, PA_PROP_DEVICE_DESCRIPTION);
|
||||
pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Virtual Sink %s on %s", sink_data.name, z ? z : master->name);
|
||||
}
|
||||
|
||||
u->sink = pa_sink_new(m->core, &sink_data, (master->flags & (PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY))
|
||||
| (use_volume_sharing ? PA_SINK_SHARE_VOLUME_WITH_MASTER : 0));
|
||||
pa_sink_new_data_done(&sink_data);
|
||||
|
||||
if (!u->sink) {
|
||||
pa_log("Failed to create sink.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u->sink->parent.process_msg = sink_process_msg_cb;
|
||||
u->sink->set_state_in_main_thread = sink_set_state_in_main_thread_cb;
|
||||
u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
|
||||
u->sink->update_requested_latency = sink_update_requested_latency_cb;
|
||||
u->sink->request_rewind = sink_request_rewind_cb;
|
||||
pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
|
||||
if (!use_volume_sharing) {
|
||||
pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
|
||||
pa_sink_enable_decibel_volume(u->sink, true);
|
||||
}
|
||||
/* Normally this flag would be enabled automatically be we can force it. */
|
||||
if (force_flat_volume)
|
||||
u->sink->flags |= PA_SINK_FLAT_VOLUME;
|
||||
u->sink->userdata = u;
|
||||
|
||||
pa_sink_set_asyncmsgq(u->sink, master->asyncmsgq);
|
||||
|
||||
/* Create sink input */
|
||||
pa_sink_input_new_data_init(&sink_input_data);
|
||||
sink_input_data.driver = __FILE__;
|
||||
sink_input_data.module = m;
|
||||
pa_sink_input_new_data_set_sink(&sink_input_data, master, false, true);
|
||||
sink_input_data.origin_sink = u->sink;
|
||||
pa_proplist_setf(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Virtual Sink Stream from %s", pa_proplist_gets(u->sink->proplist, PA_PROP_DEVICE_DESCRIPTION));
|
||||
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
|
||||
pa_sink_input_new_data_set_sample_spec(&sink_input_data, &ss);
|
||||
pa_sink_input_new_data_set_channel_map(&sink_input_data, &map);
|
||||
sink_input_data.flags |= PA_SINK_INPUT_START_CORKED;
|
||||
|
||||
pa_sink_input_new(&u->sink_input, m->core, &sink_input_data);
|
||||
pa_sink_input_new_data_done(&sink_input_data);
|
||||
|
||||
if (!u->sink_input)
|
||||
/* Create virtual sink */
|
||||
if (!(u->vsink = pa_virtual_sink_create(master, "vsink", "Virtual Sink", &ss, &map,
|
||||
&ss, &map, m, u, ma, use_volume_sharing, true, 0)))
|
||||
goto fail;
|
||||
|
||||
u->sink_input->pop = sink_input_pop_cb;
|
||||
u->sink_input->process_rewind = sink_input_process_rewind_cb;
|
||||
u->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
|
||||
u->sink_input->update_max_request = sink_input_update_max_request_cb;
|
||||
u->sink_input->update_sink_latency_range = sink_input_update_sink_latency_range_cb;
|
||||
u->sink_input->update_sink_fixed_latency = sink_input_update_sink_fixed_latency_cb;
|
||||
u->sink_input->kill = sink_input_kill_cb;
|
||||
u->sink_input->attach = sink_input_attach_cb;
|
||||
u->sink_input->detach = sink_input_detach_cb;
|
||||
u->sink_input->moving = sink_input_moving_cb;
|
||||
u->sink_input->volume_changed = use_volume_sharing ? NULL : sink_input_volume_changed_cb;
|
||||
u->sink_input->mute_changed = sink_input_mute_changed_cb;
|
||||
u->sink_input->userdata = u;
|
||||
/* Set callback for virtual sink */
|
||||
u->vsink->process_chunk = filter_process_chunk;
|
||||
|
||||
u->sink->input_to_master = u->sink_input;
|
||||
/* INITIALIZE YOUR FILTER HERE */
|
||||
|
||||
pa_sink_input_get_silence(u->sink_input, &silence);
|
||||
u->memblockq = pa_memblockq_new("module-virtual-sink memblockq", 0, MEMBLOCKQ_MAXLENGTH, 0, &ss, 1, 1, 0, &silence);
|
||||
pa_memblock_unref(silence.memblock);
|
||||
|
||||
/* (9) INITIALIZE ANYTHING ELSE YOU NEED HERE */
|
||||
|
||||
/* The order here is important. The input must be put first,
|
||||
* otherwise streams might attach to the sink before the sink
|
||||
* input is attached to the master. */
|
||||
pa_sink_input_put(u->sink_input);
|
||||
pa_sink_put(u->sink);
|
||||
pa_sink_input_cork(u->sink_input, false);
|
||||
if (pa_virtual_sink_activate(u->vsink) < 0)
|
||||
goto fail;
|
||||
|
||||
pa_modargs_free(ma);
|
||||
|
||||
|
|
@ -645,7 +158,7 @@ int pa__get_n_used(pa_module *m) {
|
|||
pa_assert(m);
|
||||
pa_assert_se(u = m->userdata);
|
||||
|
||||
return pa_sink_linked_by(u->sink);
|
||||
return pa_sink_linked_by(u->vsink->sink);
|
||||
}
|
||||
|
||||
void pa__done(pa_module*m) {
|
||||
|
|
@ -656,25 +169,8 @@ void pa__done(pa_module*m) {
|
|||
if (!(u = m->userdata))
|
||||
return;
|
||||
|
||||
/* See comments in sink_input_kill_cb() above regarding
|
||||
* destruction order! */
|
||||
|
||||
if (u->sink_input)
|
||||
pa_sink_input_cork(u->sink_input, true);
|
||||
|
||||
if (u->sink)
|
||||
pa_sink_unlink(u->sink);
|
||||
|
||||
if (u->sink_input) {
|
||||
pa_sink_input_unlink(u->sink_input);
|
||||
pa_sink_input_unref(u->sink_input);
|
||||
}
|
||||
|
||||
if (u->sink)
|
||||
pa_sink_unref(u->sink);
|
||||
|
||||
if (u->memblockq)
|
||||
pa_memblockq_free(u->memblockq);
|
||||
if (u->vsink)
|
||||
pa_virtual_sink_destroy(u->vsink);
|
||||
|
||||
pa_xfree(u);
|
||||
}
|
||||
|
|
|
|||
1404
src/modules/virtual-sink-common.c
Normal file
1404
src/modules/virtual-sink-common.c
Normal file
File diff suppressed because it is too large
Load diff
77
src/modules/virtual-sink-common.h
Normal file
77
src/modules/virtual-sink-common.h
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
/***
|
||||
This file is part of PulseAudio.
|
||||
|
||||
PulseAudio is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation; either version 2.1 of the License,
|
||||
or (at your option) any later version.
|
||||
|
||||
PulseAudio 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
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
|
||||
***/
|
||||
|
||||
#include <pulsecore/sink.h>
|
||||
#include <pulsecore/modargs.h>
|
||||
|
||||
/* Callbacks for virtual sinks. */
|
||||
int pa_virtual_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk);
|
||||
|
||||
int pa_virtual_sink_set_state_in_main_thread(pa_sink *s, pa_sink_state_t state, pa_suspend_cause_t suspend_cause);
|
||||
int pa_virtual_sink_set_state_in_io_thread(pa_sink *s, pa_sink_state_t new_state, pa_suspend_cause_t new_suspend_cause);
|
||||
|
||||
void pa_virtual_sink_request_rewind(pa_sink *s);
|
||||
void pa_virtual_sink_update_requested_latency(pa_sink *s);
|
||||
void pa_virtual_sink_set_volume(pa_sink *s);
|
||||
void pa_virtual_sink_set_mute(pa_sink *s);
|
||||
|
||||
int pa_virtual_sink_input_pop(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk);
|
||||
|
||||
void pa_virtual_sink_input_process_rewind(pa_sink_input *i, size_t nbytes);
|
||||
void pa_virtual_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes);
|
||||
void pa_virtual_sink_input_update_max_request(pa_sink_input *i, size_t nbytes);
|
||||
void pa_virtual_sink_input_update_sink_latency_range(pa_sink_input *i);
|
||||
void pa_virtual_sink_input_update_sink_fixed_latency(pa_sink_input *i);
|
||||
|
||||
void pa_virtual_sink_input_detach(pa_sink_input *i);
|
||||
void pa_virtual_sink_input_attach(pa_sink_input *i);
|
||||
void pa_virtual_sink_input_kill(pa_sink_input *i);
|
||||
void pa_virtual_sink_input_moving(pa_sink_input *i, pa_sink *dest);
|
||||
bool pa_virtual_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest);
|
||||
size_t pa_virtual_sink_input_get_max_rewind_limit(pa_sink_input *i);
|
||||
|
||||
void pa_virtual_sink_input_volume_changed(pa_sink_input *i);
|
||||
void pa_virtual_sink_input_mute_changed(pa_sink_input *i);
|
||||
|
||||
void pa_virtual_sink_input_suspend(pa_sink_input *i, pa_sink_state_t old_state, pa_suspend_cause_t old_suspend_cause);
|
||||
|
||||
/* Set callbacks for virtual sink and sink input. */
|
||||
void pa_virtual_sink_set_callbacks(pa_sink *s, bool use_volume_sharing);
|
||||
void pa_virtual_sink_input_set_callbacks(pa_sink_input *i, bool use_volume_sharing);
|
||||
|
||||
/* Create a new virtual sink. Returns a filled vsink structure or NULL on failure. */
|
||||
pa_vsink *pa_virtual_sink_create(pa_sink *master, const char *sink_type, const char *desc_prefix,
|
||||
pa_sample_spec *sink_ss, pa_channel_map *sink_map,
|
||||
pa_sample_spec *sink_input_ss, pa_channel_map *sink_input_map,
|
||||
pa_module *m, void *userdata, pa_modargs *ma,
|
||||
bool use_volume_sharing, bool create_memblockq,
|
||||
int max_rewind);
|
||||
|
||||
/* Activate the new virtual sink. */
|
||||
int pa_virtual_sink_activate(pa_vsink *vs);
|
||||
|
||||
/* Destroys the objects associated with the virtual sink. */
|
||||
void pa_virtual_sink_destroy(pa_vsink *vs);
|
||||
|
||||
/* Create vsink structure */
|
||||
pa_vsink* pa_virtual_sink_vsink_new(pa_sink *s, int max_rewind);
|
||||
|
||||
/* Update filter parameters */
|
||||
void pa_virtual_sink_request_parameter_update(pa_vsink *vs, void *parameters);
|
||||
|
||||
/* Send sink input attached message (only needed for module-echo-cancel) */
|
||||
void pa_virtual_sink_send_input_attached_message(pa_vsink *vs);
|
||||
|
|
@ -816,6 +816,18 @@ size_t pa_memblockq_get_prebuf(pa_memblockq *bq) {
|
|||
return bq->prebuf;
|
||||
}
|
||||
|
||||
size_t pa_memblockq_get_missing(pa_memblockq *bq) {
|
||||
size_t l;
|
||||
|
||||
pa_assert(bq);
|
||||
|
||||
if ((l = pa_memblockq_get_length(bq)) >= bq->tlength)
|
||||
return 0;
|
||||
|
||||
l = bq->tlength - l;
|
||||
return PA_MAX(bq->minreq, l);
|
||||
}
|
||||
|
||||
size_t pa_memblockq_pop_missing(pa_memblockq *bq) {
|
||||
size_t l;
|
||||
|
||||
|
|
|
|||
|
|
@ -112,6 +112,11 @@ bool pa_memblockq_is_readable(pa_memblockq *bq);
|
|||
/* Return the length of the queue in bytes */
|
||||
size_t pa_memblockq_get_length(pa_memblockq *bq);
|
||||
|
||||
/* Return the number of bytes missing to achieve the target length.
|
||||
* If the number of missing bytes is smaller than minreq but larger
|
||||
* than 0, minreq will be returned. */
|
||||
size_t pa_memblockq_get_missing(pa_memblockq *bq);
|
||||
|
||||
/* Return the number of bytes that are missing since the last call to
|
||||
* this function, reset the internal counter to 0. */
|
||||
size_t pa_memblockq_pop_missing(pa_memblockq *bq);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue