diff options
Diffstat (limited to 'src/pulsecore/sink.c')
-rw-r--r-- | src/pulsecore/sink.c | 348 |
1 files changed, 284 insertions, 64 deletions
diff --git a/src/pulsecore/sink.c b/src/pulsecore/sink.c index a4d993cd..3afeadb0 100644 --- a/src/pulsecore/sink.c +++ b/src/pulsecore/sink.c @@ -32,6 +32,7 @@ #include <pulse/utf8.h> #include <pulse/xmalloc.h> #include <pulse/timeval.h> +#include <pulse/util.h> #include <pulsecore/sink-input.h> #include <pulsecore/namereg.h> @@ -167,6 +168,9 @@ pa_sink* pa_sink_new( if (!data->muted_is_set) data->muted = FALSE; + if (data->card) + pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist); + if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_FIXATE], data) < 0) { pa_xfree(s); pa_namereg_unregister(core, name); @@ -181,8 +185,9 @@ pa_sink* pa_sink_new( s->flags = flags; s->name = pa_xstrdup(name); s->proplist = pa_proplist_copy(data->proplist); - s->driver = pa_xstrdup(data->driver); + s->driver = pa_xstrdup(pa_path_get_filename(data->driver)); s->module = data->module; + s->card = data->card; s->sample_spec = data->sample_spec; s->channel_map = data->channel_map; @@ -190,8 +195,10 @@ pa_sink* pa_sink_new( s->inputs = pa_idxset_new(NULL, NULL); s->n_corked = 0; - s->volume = data->volume; + s->virtual_volume = data->volume; + pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels); s->base_volume = PA_VOLUME_NORM; + s->n_volume_steps = PA_VOLUME_NORM+1; s->muted = data->muted; s->refresh_volume = s->refresh_muted = FALSE; @@ -209,8 +216,8 @@ pa_sink* pa_sink_new( 0); s->thread_info.inputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func); - pa_cvolume_reset(&s->thread_info.soft_volume, s->sample_spec.channels); - s->thread_info.soft_muted = FALSE; + s->thread_info.soft_volume = s->soft_volume; + s->thread_info.soft_muted = s->muted; s->thread_info.state = s->state; s->thread_info.rewind_nbytes = 0; s->thread_info.rewind_requested = FALSE; @@ -223,6 +230,9 @@ pa_sink* pa_sink_new( pa_assert_se(pa_idxset_put(core->sinks, s, &s->index) >= 0); + if (s->card) + pa_assert_se(pa_idxset_put(s->card->sinks, s, NULL) >= 0); + pa_log_info("Created sink %u \"%s\" with sample spec %s and channel map %s", s->index, s->name, @@ -235,6 +245,7 @@ pa_sink* pa_sink_new( source_data.name = pa_sprintf_malloc("%s.monitor", name); source_data.driver = data->driver; source_data.module = data->module; + source_data.card = data->card; dn = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION); pa_proplist_setf(source_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Monitor of %s", dn ? dn : s->name); @@ -301,8 +312,10 @@ static int sink_set_state(pa_sink *s, pa_sink_state_t state) { i->suspend(i, state == PA_SINK_SUSPENDED); } - if (state != PA_SINK_UNLINKED) /* if we enter UNLINKED state pa_sink_unlink() will fire the apropriate events */ + if (state != PA_SINK_UNLINKED) { /* if we enter UNLINKED state pa_sink_unlink() will fire the apropriate events */ pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_STATE_CHANGED], s); + pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index); + } return 0; } @@ -322,10 +335,17 @@ void pa_sink_put(pa_sink* s) { if (!(s->flags & PA_SINK_HW_VOLUME_CTRL)) { s->flags |= PA_SINK_DECIBEL_VOLUME; - s->thread_info.soft_volume = s->volume; + s->thread_info.soft_volume = s->soft_volume; s->thread_info.soft_muted = s->muted; } + if (s->flags & PA_SINK_DECIBEL_VOLUME) + s->n_volume_steps = PA_VOLUME_NORM+1; + + if (s->core->flat_volumes) + if (s->flags & PA_SINK_DECIBEL_VOLUME) + s->flags |= PA_SINK_FLAT_VOLUME; + pa_assert_se(sink_set_state(s, PA_SINK_IDLE) == 0); pa_source_put(s->monitor_source); @@ -358,6 +378,9 @@ void pa_sink_unlink(pa_sink* s) { pa_namereg_unregister(s->core, s->name); pa_idxset_remove_by_data(s->core->sinks, s, NULL); + if (s->card) + pa_idxset_remove_by_data(s->card->sinks, s, NULL); + while ((i = pa_idxset_first(s->inputs, NULL))) { pa_assert(i != j); pa_sink_input_kill(i); @@ -458,6 +481,58 @@ int pa_sink_suspend(pa_sink *s, pa_bool_t suspend) { return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE); } +/* Called from main context */ +pa_queue *pa_sink_move_all_start(pa_sink *s) { + pa_queue *q; + pa_sink_input *i, *n; + uint32_t idx; + + pa_sink_assert_ref(s); + pa_assert(PA_SINK_IS_LINKED(s->state)); + + q = pa_queue_new(); + + for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = n) { + n = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx)); + + if (pa_sink_input_start_move(i) >= 0) + pa_queue_push(q, pa_sink_input_ref(i)); + } + + return q; +} + +/* Called from main context */ +void pa_sink_move_all_finish(pa_sink *s, pa_queue *q, pa_bool_t save) { + pa_sink_input *i; + + pa_sink_assert_ref(s); + pa_assert(PA_SINK_IS_LINKED(s->state)); + pa_assert(q); + + while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) { + if (pa_sink_input_finish_move(i, s, save) < 0) + pa_sink_input_unlink(i); + + pa_sink_input_unref(i); + } + + pa_queue_free(q, NULL, NULL); +} + +/* Called from main context */ +void pa_sink_move_all_fail(pa_queue *q) { + pa_sink_input *i; + pa_assert(q); + + while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) { + pa_sink_input_unlink(i); + pa_sink_input_unref(i); + } + + pa_queue_free(q, NULL, NULL); +} + /* Called from IO thread context */ void pa_sink_process_rewind(pa_sink *s, size_t nbytes) { pa_sink_input *i; @@ -642,7 +717,7 @@ void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result) { pa_assert(length > 0); - n = s->thread_info.state == PA_SINK_RUNNING ? fill_mix_info(s, &length, info, MAX_MIX_CHANNELS) : 0; + n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS); if (n == 0) { @@ -685,8 +760,7 @@ void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result) { result->index = 0; } - if (s->thread_info.state == PA_SINK_RUNNING) - inputs_drop(s, info, n, result); + inputs_drop(s, info, n, result); pa_sink_unref(s); } @@ -716,7 +790,7 @@ void pa_sink_render_into(pa_sink*s, pa_memchunk *target) { pa_assert(length > 0); - n = s->thread_info.state == PA_SINK_RUNNING ? fill_mix_info(s, &length, info, MAX_MIX_CHANNELS) : 0; + n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS); if (n == 0) { if (target->length > length) @@ -765,8 +839,7 @@ void pa_sink_render_into(pa_sink*s, pa_memchunk *target) { pa_memblock_release(target->memblock); } - if (s->thread_info.state == PA_SINK_RUNNING) - inputs_drop(s, info, n, target); + inputs_drop(s, info, n, target); pa_sink_unref(s); } @@ -845,9 +918,100 @@ pa_usec_t pa_sink_get_latency(pa_sink *s) { } /* Called from main thread */ -void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume) { - pa_bool_t changed; - pa_sink_set_volume_data data; +void pa_sink_update_flat_volume(pa_sink *s, pa_cvolume *new_volume) { + pa_sink_input *i; + uint32_t idx; + + /* This is called whenever a sink input volume changes and we + * might need to fix up the sink volume accordingly. Please note + * that we don't actually update the sinks volume here, we only + * return how it needs to be updated. The caller should then call + * pa_sink_set_flat_volume().*/ + + pa_cvolume_mute(new_volume, s->channel_map.channels); + + /* First let's determine the new maximum volume of all inputs + * connected to this sink */ + for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) { + unsigned c; + pa_cvolume remapped_volume; + + remapped_volume = i->virtual_volume; + pa_cvolume_remap(&remapped_volume, &i->channel_map, &s->channel_map); + + for (c = 0; c < new_volume->channels; c++) + if (remapped_volume.values[c] > new_volume->values[c]) + new_volume->values[c] = remapped_volume.values[c]; + } + + /* Then, let's update the soft volumes of all inputs connected + * to this sink */ + for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) { + pa_cvolume remapped_new_volume; + + remapped_new_volume = *new_volume; + pa_cvolume_remap(&remapped_new_volume, &s->channel_map, &i->channel_map); + pa_sw_cvolume_divide(&i->soft_volume, &i->virtual_volume, &remapped_new_volume); + + /* Hooks have the ability to play games with i->soft_volume */ + pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME], i); + + /* We don't issue PA_SINK_INPUT_MESSAGE_SET_VOLUME because + * we want the update to have atomically with the sink + * volume update, hence we do it within the + * pa_sink_set_flat_volume() call below*/ + } +} + +/* Called from main thread */ +void pa_sink_propagate_flat_volume(pa_sink *s, const pa_cvolume *old_volume) { + pa_sink_input *i; + uint32_t idx; + + pa_sink_assert_ref(s); + pa_assert(PA_SINK_IS_LINKED(s->state)); + pa_assert(old_volume); + pa_assert(s->flags & PA_SINK_FLAT_VOLUME); + + /* This is called whenever the sink volume changes that is not + * caused by a sink input volume change. We need to fix up the + * sink input volumes accordingly */ + + for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) { + pa_cvolume remapped_old_volume, remapped_new_volume, fixed_volume; + unsigned c; + + remapped_new_volume = s->virtual_volume; + pa_cvolume_remap(&remapped_new_volume, &s->channel_map, &i->channel_map); + + remapped_old_volume = *old_volume; + pa_cvolume_remap(&remapped_old_volume, &s->channel_map, &i->channel_map); + + for (c = 0; c < i->sample_spec.channels; c++) + + if (remapped_old_volume.values[c] == PA_VOLUME_MUTED) + fixed_volume.values[c] = PA_VOLUME_MUTED; + else + fixed_volume.values[c] = (pa_volume_t) + ((uint64_t) i->virtual_volume.values[c] * + (uint64_t) remapped_new_volume.values[c] / + (uint64_t) remapped_old_volume.values[c]); + + fixed_volume.channels = i->virtual_volume.channels; + + if (!pa_cvolume_equal(&fixed_volume, &i->virtual_volume)) { + i->virtual_volume = fixed_volume; + + /* The virtual volume changed, let's tell people so */ + pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index); + } + } +} + +/* Called from main thread */ +void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume, pa_bool_t propagate, pa_bool_t sendmsg) { + pa_cvolume old_virtual_volume; + pa_bool_t virtual_volume_changed; pa_sink_assert_ref(s); pa_assert(PA_SINK_IS_LINKED(s->state)); @@ -855,37 +1019,45 @@ void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume) { pa_assert(pa_cvolume_valid(volume)); pa_assert(pa_cvolume_compatible(volume, &s->sample_spec)); - data.sink = s; - data.volume = *volume; + old_virtual_volume = s->virtual_volume; + s->virtual_volume = *volume; + virtual_volume_changed = !pa_cvolume_equal(&old_virtual_volume, &s->virtual_volume); - changed = !pa_cvolume_equal(&data.volume, &s->volume); + /* Propagate this volume change back to the inputs */ + if (virtual_volume_changed) + if (propagate && (s->flags & PA_SINK_FLAT_VOLUME)) + pa_sink_propagate_flat_volume(s, &old_virtual_volume); - if (changed) { - if (pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_SET_VOLUME], &data) < 0) - return; - - changed = !pa_cvolume_equal(&data.volume, &s->volume); - } + if (s->set_volume) { + /* If we have a function set_volume(), then we do not apply a + * soft volume by default. However, set_volume() is apply one + * to s->soft_volume */ - s->volume = data.volume; + pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels); + s->set_volume(s); - if (s->set_volume && s->set_volume(s) < 0) - s->set_volume = NULL; + } else + /* If we have no function set_volume(), then the soft volume + * becomes the virtual volume */ + s->soft_volume = s->virtual_volume; - if (!s->set_volume) - pa_sink_set_soft_volume(s, volume); + /* This tells the sink that soft and/or virtual volume changed */ + if (sendmsg) + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0); - if (changed) + if (virtual_volume_changed) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); } -/* Called from main thread */ +/* Called from main thread. Only to be called by sink implementor */ void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) { pa_sink_assert_ref(s); pa_assert(volume); + s->soft_volume = *volume; + if (PA_SINK_IS_LINKED(s->state)) - pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, volume, 0, NULL); + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0); else s->thread_info.soft_volume = *volume; } @@ -893,41 +1065,43 @@ void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) { /* Called from main thread */ const pa_cvolume *pa_sink_get_volume(pa_sink *s, pa_bool_t force_refresh) { pa_sink_assert_ref(s); - pa_assert(PA_SINK_IS_LINKED(s->state)); if (s->refresh_volume || force_refresh) { - struct pa_cvolume old_volume = s->volume; + struct pa_cvolume old_virtual_volume = s->virtual_volume; + + if (s->get_volume) + s->get_volume(s); - if (s->get_volume && s->get_volume(s) < 0) - s->get_volume = NULL; + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0); - if (!s->get_volume) - pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, &s->volume, 0, NULL); + if (!pa_cvolume_equal(&old_virtual_volume, &s->virtual_volume)) { + + if (s->flags & PA_SINK_FLAT_VOLUME) + pa_sink_propagate_flat_volume(s, &old_virtual_volume); - if (!pa_cvolume_equal(&old_volume, &s->volume)) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); + } } - return &s->volume; + return &s->virtual_volume; } /* Called from main thread */ void pa_sink_set_mute(pa_sink *s, pa_bool_t mute) { - pa_bool_t changed; + pa_bool_t old_muted; pa_sink_assert_ref(s); pa_assert(PA_SINK_IS_LINKED(s->state)); - changed = s->muted != mute; + old_muted = s->muted; s->muted = mute; - if (s->set_mute && s->set_mute(s) < 0) - s->set_mute = NULL; + if (s->set_mute) + s->set_mute(s); - if (!s->set_mute) - pa_asyncmsgq_post(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, PA_UINT_TO_PTR(mute), 0, NULL, NULL); + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0); - if (changed) + if (old_muted != s->muted) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); } @@ -935,16 +1109,14 @@ void pa_sink_set_mute(pa_sink *s, pa_bool_t mute) { pa_bool_t pa_sink_get_mute(pa_sink *s, pa_bool_t force_refresh) { pa_sink_assert_ref(s); - pa_assert(PA_SINK_IS_LINKED(s->state)); if (s->refresh_muted || force_refresh) { pa_bool_t old_muted = s->muted; - if (s->get_mute && s->get_mute(s) < 0) - s->get_mute = NULL; + if (s->get_mute) + s->get_mute(s); - if (!s->get_mute) - pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, &s->muted, 0, NULL); + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0); if (old_muted != s->muted) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); @@ -954,6 +1126,21 @@ pa_bool_t pa_sink_get_mute(pa_sink *s, pa_bool_t force_refresh) { } /* Called from main thread */ +pa_bool_t pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p) { + + pa_sink_assert_ref(s); + + pa_proplist_update(s->proplist, mode, p); + + if (PA_SINK_IS_LINKED(s->state)) { + pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s); + pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); + } + + return TRUE; +} + +/* Called from main thread */ void pa_sink_set_description(pa_sink *s, const char *description) { const char *old; pa_sink_assert_ref(s); @@ -1053,6 +1240,22 @@ unsigned pa_sink_check_suspend(pa_sink *s) { return ret; } +/* Called from the IO thread */ +static void sync_input_volumes_within_thread(pa_sink *s) { + pa_sink_input *i; + void *state = NULL; + + pa_sink_assert_ref(s); + + while ((i = PA_SINK_INPUT(pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))) { + if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) + continue; + + i->thread_info.soft_volume = i->soft_volume; + pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE); + } +} + /* Called from IO thread, except when it is not */ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) { pa_sink *s = PA_SINK(o); @@ -1107,7 +1310,9 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse * slow start, i.e. need some time to buffer client * samples before beginning streaming. */ - return 0; + /* In flat volume mode we need to update the volume as + * well */ + return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL); } case PA_SINK_MESSAGE_REMOVE_INPUT: { @@ -1148,7 +1353,9 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse pa_sink_invalidate_requested_latency(s); pa_sink_request_rewind(s, (size_t) -1); - return 0; + /* In flat volume mode we need to update the volume as + * well */ + return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL); } case PA_SINK_MESSAGE_START_MOVE: { @@ -1194,7 +1401,9 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse pa_log_debug("Requesting rewind due to started move"); pa_sink_request_rewind(s, (size_t) -1); - return 0; + /* In flat volume mode we need to update the volume as + * well */ + return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL); } case PA_SINK_MESSAGE_FINISH_MOVE: { @@ -1238,27 +1447,36 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse pa_sink_request_rewind(s, nbytes); } - return 0; + /* In flat volume mode we need to update the volume as + * well */ + return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL); } case PA_SINK_MESSAGE_SET_VOLUME: - s->thread_info.soft_volume = *((pa_cvolume*) userdata); - pa_sink_request_rewind(s, (size_t) -1); - return 0; + if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) { + s->thread_info.soft_volume = s->soft_volume; + pa_sink_request_rewind(s, (size_t) -1); + } - case PA_SINK_MESSAGE_SET_MUTE: - s->thread_info.soft_muted = PA_PTR_TO_UINT(userdata); + if (s->flags & PA_SINK_FLAT_VOLUME) + sync_input_volumes_within_thread(s); - pa_sink_request_rewind(s, (size_t) -1); return 0; case PA_SINK_MESSAGE_GET_VOLUME: - *((pa_cvolume*) userdata) = s->thread_info.soft_volume; + return 0; + + case PA_SINK_MESSAGE_SET_MUTE: + + if (!s->thread_info.soft_muted != s->muted) { + s->thread_info.soft_muted = s->muted; + pa_sink_request_rewind(s, (size_t) -1); + } + return 0; case PA_SINK_MESSAGE_GET_MUTE: - *((pa_bool_t*) userdata) = s->thread_info.soft_muted; return 0; case PA_SINK_MESSAGE_SET_STATE: @@ -1591,6 +1809,7 @@ void pa_sink_update_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t m pa_source_update_latency_range(s->monitor_source, min_latency, max_latency); } +/* Called from main context */ size_t pa_sink_get_max_rewind(pa_sink *s) { size_t r; pa_sink_assert_ref(s); @@ -1603,6 +1822,7 @@ size_t pa_sink_get_max_rewind(pa_sink *s) { return r; } +/* Called from main context */ size_t pa_sink_get_max_request(pa_sink *s) { size_t r; pa_sink_assert_ref(s); |