2 This file is part of PulseAudio.
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
31 #include <pulse/introspect.h>
32 #include <pulse/format.h>
33 #include <pulse/utf8.h>
34 #include <pulse/xmalloc.h>
35 #include <pulse/timeval.h>
36 #include <pulse/util.h>
37 #include <pulse/rtclock.h>
38 #include <pulse/internal.h>
40 #include <pulsecore/i18n.h>
41 #include <pulsecore/sink-input.h>
42 #include <pulsecore/namereg.h>
43 #include <pulsecore/core-util.h>
44 #include <pulsecore/sample-util.h>
45 #include <pulsecore/core-subscribe.h>
46 #include <pulsecore/log.h>
47 #include <pulsecore/macro.h>
48 #include <pulsecore/play-memblockq.h>
49 #include <pulsecore/flist.h>
53 #define MAX_MIX_CHANNELS 32
54 #define MIX_BUFFER_LENGTH (PA_PAGE_SIZE)
55 #define ABSOLUTE_MIN_LATENCY (500)
56 #define ABSOLUTE_MAX_LATENCY (10*PA_USEC_PER_SEC)
57 #define DEFAULT_FIXED_LATENCY (250*PA_USEC_PER_MSEC)
59 PA_DEFINE_PUBLIC_CLASS(pa_sink, pa_msgobject);
61 struct pa_sink_volume_change {
65 PA_LLIST_FIELDS(pa_sink_volume_change);
68 struct sink_message_set_port {
73 static void sink_free(pa_object *s);
75 static void pa_sink_volume_change_push(pa_sink *s);
76 static void pa_sink_volume_change_flush(pa_sink *s);
77 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes);
79 pa_sink_new_data* pa_sink_new_data_init(pa_sink_new_data *data) {
83 data->proplist = pa_proplist_new();
88 void pa_sink_new_data_set_name(pa_sink_new_data *data, const char *name) {
92 data->name = pa_xstrdup(name);
95 void pa_sink_new_data_set_sample_spec(pa_sink_new_data *data, const pa_sample_spec *spec) {
98 if ((data->sample_spec_is_set = !!spec))
99 data->sample_spec = *spec;
102 void pa_sink_new_data_set_channel_map(pa_sink_new_data *data, const pa_channel_map *map) {
105 if ((data->channel_map_is_set = !!map))
106 data->channel_map = *map;
109 void pa_sink_new_data_set_volume(pa_sink_new_data *data, const pa_cvolume *volume) {
112 if ((data->volume_is_set = !!volume))
113 data->volume = *volume;
116 void pa_sink_new_data_set_muted(pa_sink_new_data *data, pa_bool_t mute) {
119 data->muted_is_set = TRUE;
120 data->muted = !!mute;
123 void pa_sink_new_data_set_port(pa_sink_new_data *data, const char *port) {
126 pa_xfree(data->active_port);
127 data->active_port = pa_xstrdup(port);
130 void pa_sink_new_data_done(pa_sink_new_data *data) {
133 pa_proplist_free(data->proplist);
138 while ((p = pa_hashmap_steal_first(data->ports)))
139 pa_device_port_free(p);
141 pa_hashmap_free(data->ports, NULL, NULL);
144 pa_xfree(data->name);
145 pa_xfree(data->active_port);
148 pa_device_port *pa_device_port_new(const char *name, const char *description, size_t extra) {
153 p = pa_xmalloc(PA_ALIGN(sizeof(pa_device_port)) + extra);
154 p->name = pa_xstrdup(name);
155 p->description = pa_xstrdup(description);
162 void pa_device_port_free(pa_device_port *p) {
166 pa_xfree(p->description);
170 /* Called from main context */
171 static void reset_callbacks(pa_sink *s) {
175 s->get_volume = NULL;
176 s->set_volume = NULL;
177 s->write_volume = NULL;
180 s->request_rewind = NULL;
181 s->update_requested_latency = NULL;
183 s->get_formats = NULL;
184 s->set_formats = NULL;
187 /* Called from main context */
188 pa_sink* pa_sink_new(
190 pa_sink_new_data *data,
191 pa_sink_flags_t flags) {
195 char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
196 pa_source_new_data source_data;
202 pa_assert(data->name);
203 pa_assert_ctl_context();
205 s = pa_msgobject_new(pa_sink);
207 if (!(name = pa_namereg_register(core, data->name, PA_NAMEREG_SINK, s, data->namereg_fail))) {
208 pa_log_debug("Failed to register name %s.", data->name);
213 pa_sink_new_data_set_name(data, name);
215 if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_NEW], data) < 0) {
217 pa_namereg_unregister(core, name);
221 /* FIXME, need to free s here on failure */
223 pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver));
224 pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]);
226 pa_return_null_if_fail(data->sample_spec_is_set && pa_sample_spec_valid(&data->sample_spec));
228 if (!data->channel_map_is_set)
229 pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
231 pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
232 pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
234 /* FIXME: There should probably be a general function for checking whether
235 * the sink volume is allowed to be set, like there is for sink inputs. */
236 pa_assert(!data->volume_is_set || !(flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
238 if (!data->volume_is_set) {
239 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
240 data->save_volume = FALSE;
243 pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
244 pa_return_null_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec));
246 if (!data->muted_is_set)
250 pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
252 pa_device_init_description(data->proplist);
253 pa_device_init_icon(data->proplist, TRUE);
254 pa_device_init_intended_roles(data->proplist);
256 if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_FIXATE], data) < 0) {
258 pa_namereg_unregister(core, name);
262 s->parent.parent.free = sink_free;
263 s->parent.process_msg = pa_sink_process_msg;
266 s->state = PA_SINK_INIT;
269 s->suspend_cause = 0;
270 s->name = pa_xstrdup(name);
271 s->proplist = pa_proplist_copy(data->proplist);
272 s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
273 s->module = data->module;
274 s->card = data->card;
276 s->priority = pa_device_init_priority(s->proplist);
278 s->sample_spec = data->sample_spec;
279 s->channel_map = data->channel_map;
281 s->inputs = pa_idxset_new(NULL, NULL);
283 s->input_to_master = NULL;
285 s->reference_volume = s->real_volume = data->volume;
286 pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
287 s->base_volume = PA_VOLUME_NORM;
288 s->n_volume_steps = PA_VOLUME_NORM+1;
289 s->muted = data->muted;
290 s->refresh_volume = s->refresh_muted = FALSE;
297 /* As a minor optimization we just steal the list instead of
299 s->ports = data->ports;
302 s->active_port = NULL;
303 s->save_port = FALSE;
305 if (data->active_port && s->ports)
306 if ((s->active_port = pa_hashmap_get(s->ports, data->active_port)))
307 s->save_port = data->save_port;
309 if (!s->active_port && s->ports) {
313 PA_HASHMAP_FOREACH(p, s->ports, state)
314 if (!s->active_port || p->priority > s->active_port->priority)
318 s->save_volume = data->save_volume;
319 s->save_muted = data->save_muted;
321 pa_silence_memchunk_get(
322 &core->silence_cache,
328 s->thread_info.rtpoll = NULL;
329 s->thread_info.inputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
330 s->thread_info.soft_volume = s->soft_volume;
331 s->thread_info.soft_muted = s->muted;
332 s->thread_info.state = s->state;
333 s->thread_info.rewind_nbytes = 0;
334 s->thread_info.rewind_requested = FALSE;
335 s->thread_info.max_rewind = 0;
336 s->thread_info.max_request = 0;
337 s->thread_info.requested_latency_valid = FALSE;
338 s->thread_info.requested_latency = 0;
339 s->thread_info.min_latency = ABSOLUTE_MIN_LATENCY;
340 s->thread_info.max_latency = ABSOLUTE_MAX_LATENCY;
341 s->thread_info.fixed_latency = flags & PA_SINK_DYNAMIC_LATENCY ? 0 : DEFAULT_FIXED_LATENCY;
343 PA_LLIST_HEAD_INIT(pa_sink_volume_change, s->thread_info.volume_changes);
344 s->thread_info.volume_changes_tail = NULL;
345 pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
346 s->thread_info.volume_change_safety_margin = core->deferred_volume_safety_margin_usec;
347 s->thread_info.volume_change_extra_delay = core->deferred_volume_extra_delay_usec;
349 /* FIXME: This should probably be moved to pa_sink_put() */
350 pa_assert_se(pa_idxset_put(core->sinks, s, &s->index) >= 0);
353 pa_assert_se(pa_idxset_put(s->card->sinks, s, NULL) >= 0);
355 pt = pa_proplist_to_string_sep(s->proplist, "\n ");
356 pa_log_info("Created sink %u \"%s\" with sample spec %s and channel map %s\n %s",
359 pa_sample_spec_snprint(st, sizeof(st), &s->sample_spec),
360 pa_channel_map_snprint(cm, sizeof(cm), &s->channel_map),
364 pa_source_new_data_init(&source_data);
365 pa_source_new_data_set_sample_spec(&source_data, &s->sample_spec);
366 pa_source_new_data_set_channel_map(&source_data, &s->channel_map);
367 source_data.name = pa_sprintf_malloc("%s.monitor", name);
368 source_data.driver = data->driver;
369 source_data.module = data->module;
370 source_data.card = data->card;
372 dn = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
373 pa_proplist_setf(source_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Monitor of %s", dn ? dn : s->name);
374 pa_proplist_sets(source_data.proplist, PA_PROP_DEVICE_CLASS, "monitor");
376 s->monitor_source = pa_source_new(core, &source_data,
377 ((flags & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
378 ((flags & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0));
380 pa_source_new_data_done(&source_data);
382 if (!s->monitor_source) {
388 s->monitor_source->monitor_of = s;
390 pa_source_set_latency_range(s->monitor_source, s->thread_info.min_latency, s->thread_info.max_latency);
391 pa_source_set_fixed_latency(s->monitor_source, s->thread_info.fixed_latency);
392 pa_source_set_max_rewind(s->monitor_source, s->thread_info.max_rewind);
397 /* Called from main context */
398 static int sink_set_state(pa_sink *s, pa_sink_state_t state) {
400 pa_bool_t suspend_change;
401 pa_sink_state_t original_state;
404 pa_assert_ctl_context();
406 if (s->state == state)
409 original_state = s->state;
412 (original_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(state)) ||
413 (PA_SINK_IS_OPENED(original_state) && state == PA_SINK_SUSPENDED);
416 if ((ret = s->set_state(s, state)) < 0)
420 if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_STATE, PA_UINT_TO_PTR(state), 0, NULL)) < 0) {
423 s->set_state(s, original_state);
430 if (state != PA_SINK_UNLINKED) { /* if we enter UNLINKED state pa_sink_unlink() will fire the appropriate events */
431 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_STATE_CHANGED], s);
432 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
435 if (suspend_change) {
439 /* We're suspending or resuming, tell everyone about it */
441 PA_IDXSET_FOREACH(i, s->inputs, idx)
442 if (s->state == PA_SINK_SUSPENDED &&
443 (i->flags & PA_SINK_INPUT_KILL_ON_SUSPEND))
444 pa_sink_input_kill(i);
446 i->suspend(i, state == PA_SINK_SUSPENDED);
448 if (s->monitor_source)
449 pa_source_sync_suspend(s->monitor_source);
455 void pa_sink_set_get_volume_callback(pa_sink *s, pa_sink_cb_t cb) {
461 void pa_sink_set_set_volume_callback(pa_sink *s, pa_sink_cb_t cb) {
462 pa_sink_flags_t flags;
465 pa_assert(!s->write_volume || cb);
469 /* Save the current flags so we can tell if they've changed */
473 /* The sink implementor is responsible for setting decibel volume support */
474 s->flags |= PA_SINK_HW_VOLUME_CTRL;
476 s->flags &= ~PA_SINK_HW_VOLUME_CTRL;
477 /* See note below in pa_sink_put() about volume sharing and decibel volumes */
478 pa_sink_enable_decibel_volume(s, !(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
481 /* If the flags have changed after init, let any clients know via a change event */
482 if (s->state != PA_SINK_INIT && flags != s->flags)
483 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
486 void pa_sink_set_write_volume_callback(pa_sink *s, pa_sink_cb_t cb) {
487 pa_sink_flags_t flags;
490 pa_assert(!cb || s->set_volume);
492 s->write_volume = cb;
494 /* Save the current flags so we can tell if they've changed */
498 s->flags |= PA_SINK_DEFERRED_VOLUME;
500 s->flags &= ~PA_SINK_DEFERRED_VOLUME;
502 /* If the flags have changed after init, let any clients know via a change event */
503 if (s->state != PA_SINK_INIT && flags != s->flags)
504 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
507 void pa_sink_set_get_mute_callback(pa_sink *s, pa_sink_cb_t cb) {
513 void pa_sink_set_set_mute_callback(pa_sink *s, pa_sink_cb_t cb) {
514 pa_sink_flags_t flags;
520 /* Save the current flags so we can tell if they've changed */
524 s->flags |= PA_SINK_HW_MUTE_CTRL;
526 s->flags &= ~PA_SINK_HW_MUTE_CTRL;
528 /* If the flags have changed after init, let any clients know via a change event */
529 if (s->state != PA_SINK_INIT && flags != s->flags)
530 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
533 static void enable_flat_volume(pa_sink *s, pa_bool_t enable) {
534 pa_sink_flags_t flags;
538 /* Always follow the overall user preference here */
539 enable = enable && s->core->flat_volumes;
541 /* Save the current flags so we can tell if they've changed */
545 s->flags |= PA_SINK_FLAT_VOLUME;
547 s->flags &= ~PA_SINK_FLAT_VOLUME;
549 /* If the flags have changed after init, let any clients know via a change event */
550 if (s->state != PA_SINK_INIT && flags != s->flags)
551 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
554 void pa_sink_enable_decibel_volume(pa_sink *s, pa_bool_t enable) {
555 pa_sink_flags_t flags;
559 /* Save the current flags so we can tell if they've changed */
563 s->flags |= PA_SINK_DECIBEL_VOLUME;
564 enable_flat_volume(s, TRUE);
566 s->flags &= ~PA_SINK_DECIBEL_VOLUME;
567 enable_flat_volume(s, FALSE);
570 /* If the flags have changed after init, let any clients know via a change event */
571 if (s->state != PA_SINK_INIT && flags != s->flags)
572 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
575 /* Called from main context */
576 void pa_sink_put(pa_sink* s) {
577 pa_sink_assert_ref(s);
578 pa_assert_ctl_context();
580 pa_assert(s->state == PA_SINK_INIT);
581 pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) || s->input_to_master);
583 /* The following fields must be initialized properly when calling _put() */
584 pa_assert(s->asyncmsgq);
585 pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency);
587 /* Generally, flags should be initialized via pa_sink_new(). As a
588 * special exception we allow some volume related flags to be set
589 * between _new() and _put() by the callback setter functions above.
591 * Thus we implement a couple safeguards here which ensure the above
592 * setters were used (or at least the implementor made manual changes
593 * in a compatible way).
595 * Note: All of these flags set here can change over the life time
597 pa_assert(!(s->flags & PA_SINK_HW_VOLUME_CTRL) || s->set_volume);
598 pa_assert(!(s->flags & PA_SINK_DEFERRED_VOLUME) || s->write_volume);
599 pa_assert(!(s->flags & PA_SINK_HW_MUTE_CTRL) || s->set_mute);
601 /* XXX: Currently decibel volume is disabled for all sinks that use volume
602 * sharing. When the master sink supports decibel volume, it would be good
603 * to have the flag also in the filter sink, but currently we don't do that
604 * so that the flags of the filter sink never change when it's moved from
605 * a master sink to another. One solution for this problem would be to
606 * remove user-visible volume altogether from filter sinks when volume
607 * sharing is used, but the current approach was easier to implement... */
608 /* We always support decibel volumes in software, otherwise we leave it to
609 * the sink implementor to set this flag as needed.
611 * Note: This flag can also change over the life time of the sink. */
612 if (!(s->flags & PA_SINK_HW_VOLUME_CTRL) && !(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
613 pa_sink_enable_decibel_volume(s, TRUE);
615 /* If the sink implementor support DB volumes by itself, we should always
616 * try and enable flat volumes too */
617 if ((s->flags & PA_SINK_DECIBEL_VOLUME))
618 enable_flat_volume(s, TRUE);
620 if (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) {
621 pa_sink *root_sink = pa_sink_get_master(s);
623 pa_assert(root_sink);
625 s->reference_volume = root_sink->reference_volume;
626 pa_cvolume_remap(&s->reference_volume, &root_sink->channel_map, &s->channel_map);
628 s->real_volume = root_sink->real_volume;
629 pa_cvolume_remap(&s->real_volume, &root_sink->channel_map, &s->channel_map);
631 /* We assume that if the sink implementor changed the default
632 * volume he did so in real_volume, because that is the usual
633 * place where he is supposed to place his changes. */
634 s->reference_volume = s->real_volume;
636 s->thread_info.soft_volume = s->soft_volume;
637 s->thread_info.soft_muted = s->muted;
638 pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
640 pa_assert((s->flags & PA_SINK_HW_VOLUME_CTRL)
641 || (s->base_volume == PA_VOLUME_NORM
642 && ((s->flags & PA_SINK_DECIBEL_VOLUME || (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)))));
643 pa_assert(!(s->flags & PA_SINK_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1);
644 pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == (s->thread_info.fixed_latency != 0));
645 pa_assert(!(s->flags & PA_SINK_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_LATENCY));
646 pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_DYNAMIC_LATENCY));
648 pa_assert(s->monitor_source->thread_info.fixed_latency == s->thread_info.fixed_latency);
649 pa_assert(s->monitor_source->thread_info.min_latency == s->thread_info.min_latency);
650 pa_assert(s->monitor_source->thread_info.max_latency == s->thread_info.max_latency);
652 pa_assert_se(sink_set_state(s, PA_SINK_IDLE) == 0);
654 pa_source_put(s->monitor_source);
656 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_NEW, s->index);
657 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PUT], s);
660 /* Called from main context */
661 void pa_sink_unlink(pa_sink* s) {
663 pa_sink_input *i, *j = NULL;
666 pa_assert_ctl_context();
668 /* Please note that pa_sink_unlink() does more than simply
669 * reversing pa_sink_put(). It also undoes the registrations
670 * already done in pa_sink_new()! */
672 /* All operations here shall be idempotent, i.e. pa_sink_unlink()
673 * may be called multiple times on the same sink without bad
676 linked = PA_SINK_IS_LINKED(s->state);
679 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK], s);
681 if (s->state != PA_SINK_UNLINKED)
682 pa_namereg_unregister(s->core, s->name);
683 pa_idxset_remove_by_data(s->core->sinks, s, NULL);
686 pa_idxset_remove_by_data(s->card->sinks, s, NULL);
688 while ((i = pa_idxset_first(s->inputs, NULL))) {
690 pa_sink_input_kill(i);
695 sink_set_state(s, PA_SINK_UNLINKED);
697 s->state = PA_SINK_UNLINKED;
701 if (s->monitor_source)
702 pa_source_unlink(s->monitor_source);
705 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
706 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK_POST], s);
710 /* Called from main context */
711 static void sink_free(pa_object *o) {
712 pa_sink *s = PA_SINK(o);
716 pa_assert_ctl_context();
717 pa_assert(pa_sink_refcnt(s) == 0);
719 if (PA_SINK_IS_LINKED(s->state))
722 pa_log_info("Freeing sink %u \"%s\"", s->index, s->name);
724 if (s->monitor_source) {
725 pa_source_unref(s->monitor_source);
726 s->monitor_source = NULL;
729 pa_idxset_free(s->inputs, NULL, NULL);
731 while ((i = pa_hashmap_steal_first(s->thread_info.inputs)))
732 pa_sink_input_unref(i);
734 pa_hashmap_free(s->thread_info.inputs, NULL, NULL);
736 if (s->silence.memblock)
737 pa_memblock_unref(s->silence.memblock);
743 pa_proplist_free(s->proplist);
748 while ((p = pa_hashmap_steal_first(s->ports)))
749 pa_device_port_free(p);
751 pa_hashmap_free(s->ports, NULL, NULL);
757 /* Called from main context, and not while the IO thread is active, please */
758 void pa_sink_set_asyncmsgq(pa_sink *s, pa_asyncmsgq *q) {
759 pa_sink_assert_ref(s);
760 pa_assert_ctl_context();
764 if (s->monitor_source)
765 pa_source_set_asyncmsgq(s->monitor_source, q);
768 /* Called from main context, and not while the IO thread is active, please */
769 void pa_sink_update_flags(pa_sink *s, pa_sink_flags_t mask, pa_sink_flags_t value) {
770 pa_sink_assert_ref(s);
771 pa_assert_ctl_context();
776 /* For now, allow only a minimal set of flags to be changed. */
777 pa_assert((mask & ~(PA_SINK_DYNAMIC_LATENCY|PA_SINK_LATENCY)) == 0);
779 s->flags = (s->flags & ~mask) | (value & mask);
781 pa_source_update_flags(s->monitor_source,
782 ((mask & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
783 ((mask & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0),
784 ((value & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
785 ((value & PA_SINK_DYNAMIC_LATENCY) ? PA_SINK_DYNAMIC_LATENCY : 0));
788 /* Called from IO context, or before _put() from main context */
789 void pa_sink_set_rtpoll(pa_sink *s, pa_rtpoll *p) {
790 pa_sink_assert_ref(s);
791 pa_sink_assert_io_context(s);
793 s->thread_info.rtpoll = p;
795 if (s->monitor_source)
796 pa_source_set_rtpoll(s->monitor_source, p);
799 /* Called from main context */
800 int pa_sink_update_status(pa_sink*s) {
801 pa_sink_assert_ref(s);
802 pa_assert_ctl_context();
803 pa_assert(PA_SINK_IS_LINKED(s->state));
805 if (s->state == PA_SINK_SUSPENDED)
808 return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
811 /* Called from main context */
812 int pa_sink_suspend(pa_sink *s, pa_bool_t suspend, pa_suspend_cause_t cause) {
813 pa_sink_assert_ref(s);
814 pa_assert_ctl_context();
815 pa_assert(PA_SINK_IS_LINKED(s->state));
816 pa_assert(cause != 0);
819 s->suspend_cause |= cause;
820 s->monitor_source->suspend_cause |= cause;
822 s->suspend_cause &= ~cause;
823 s->monitor_source->suspend_cause &= ~cause;
826 if ((pa_sink_get_state(s) == PA_SINK_SUSPENDED) == !!s->suspend_cause)
829 pa_log_debug("Suspend cause of sink %s is 0x%04x, %s", s->name, s->suspend_cause, s->suspend_cause ? "suspending" : "resuming");
831 if (s->suspend_cause)
832 return sink_set_state(s, PA_SINK_SUSPENDED);
834 return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
837 /* Called from main context */
838 pa_queue *pa_sink_move_all_start(pa_sink *s, pa_queue *q) {
839 pa_sink_input *i, *n;
842 pa_sink_assert_ref(s);
843 pa_assert_ctl_context();
844 pa_assert(PA_SINK_IS_LINKED(s->state));
849 for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = n) {
850 n = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx));
852 pa_sink_input_ref(i);
854 if (pa_sink_input_start_move(i) >= 0)
857 pa_sink_input_unref(i);
863 /* Called from main context */
864 void pa_sink_move_all_finish(pa_sink *s, pa_queue *q, pa_bool_t save) {
867 pa_sink_assert_ref(s);
868 pa_assert_ctl_context();
869 pa_assert(PA_SINK_IS_LINKED(s->state));
872 while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
873 if (pa_sink_input_finish_move(i, s, save) < 0)
874 pa_sink_input_fail_move(i);
876 pa_sink_input_unref(i);
879 pa_queue_free(q, NULL, NULL);
882 /* Called from main context */
883 void pa_sink_move_all_fail(pa_queue *q) {
886 pa_assert_ctl_context();
889 while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
890 pa_sink_input_fail_move(i);
891 pa_sink_input_unref(i);
894 pa_queue_free(q, NULL, NULL);
897 /* Called from IO thread context */
898 void pa_sink_process_rewind(pa_sink *s, size_t nbytes) {
902 pa_sink_assert_ref(s);
903 pa_sink_assert_io_context(s);
904 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
906 /* If nobody requested this and this is actually no real rewind
907 * then we can short cut this. Please note that this means that
908 * not all rewind requests triggered upstream will always be
909 * translated in actual requests! */
910 if (!s->thread_info.rewind_requested && nbytes <= 0)
913 s->thread_info.rewind_nbytes = 0;
914 s->thread_info.rewind_requested = FALSE;
916 if (s->thread_info.state == PA_SINK_SUSPENDED)
920 pa_log_debug("Processing rewind...");
921 if (s->flags & PA_SINK_DEFERRED_VOLUME)
922 pa_sink_volume_change_rewind(s, nbytes);
925 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
926 pa_sink_input_assert_ref(i);
927 pa_sink_input_process_rewind(i, nbytes);
931 if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
932 pa_source_process_rewind(s->monitor_source, nbytes);
936 /* Called from IO thread context */
937 static unsigned fill_mix_info(pa_sink *s, size_t *length, pa_mix_info *info, unsigned maxinfo) {
941 size_t mixlength = *length;
943 pa_sink_assert_ref(s);
944 pa_sink_assert_io_context(s);
947 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)) && maxinfo > 0) {
948 pa_sink_input_assert_ref(i);
950 pa_sink_input_peek(i, *length, &info->chunk, &info->volume);
952 if (mixlength == 0 || info->chunk.length < mixlength)
953 mixlength = info->chunk.length;
955 if (pa_memblock_is_silence(info->chunk.memblock)) {
956 pa_memblock_unref(info->chunk.memblock);
960 info->userdata = pa_sink_input_ref(i);
962 pa_assert(info->chunk.memblock);
963 pa_assert(info->chunk.length > 0);
976 /* Called from IO thread context */
977 static void inputs_drop(pa_sink *s, pa_mix_info *info, unsigned n, pa_memchunk *result) {
981 unsigned n_unreffed = 0;
983 pa_sink_assert_ref(s);
984 pa_sink_assert_io_context(s);
986 pa_assert(result->memblock);
987 pa_assert(result->length > 0);
989 /* We optimize for the case where the order of the inputs has not changed */
991 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
993 pa_mix_info* m = NULL;
995 pa_sink_input_assert_ref(i);
997 /* Let's try to find the matching entry info the pa_mix_info array */
998 for (j = 0; j < n; j ++) {
1000 if (info[p].userdata == i) {
1010 /* Drop read data */
1011 pa_sink_input_drop(i, result->length);
1013 if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state)) {
1015 if (pa_hashmap_size(i->thread_info.direct_outputs) > 0) {
1016 void *ostate = NULL;
1017 pa_source_output *o;
1020 if (m && m->chunk.memblock) {
1022 pa_memblock_ref(c.memblock);
1023 pa_assert(result->length <= c.length);
1024 c.length = result->length;
1026 pa_memchunk_make_writable(&c, 0);
1027 pa_volume_memchunk(&c, &s->sample_spec, &m->volume);
1030 pa_memblock_ref(c.memblock);
1031 pa_assert(result->length <= c.length);
1032 c.length = result->length;
1035 while ((o = pa_hashmap_iterate(i->thread_info.direct_outputs, &ostate, NULL))) {
1036 pa_source_output_assert_ref(o);
1037 pa_assert(o->direct_on_input == i);
1038 pa_source_post_direct(s->monitor_source, o, &c);
1041 pa_memblock_unref(c.memblock);
1046 if (m->chunk.memblock)
1047 pa_memblock_unref(m->chunk.memblock);
1048 pa_memchunk_reset(&m->chunk);
1050 pa_sink_input_unref(m->userdata);
1057 /* Now drop references to entries that are included in the
1058 * pa_mix_info array but don't exist anymore */
1060 if (n_unreffed < n) {
1061 for (; n > 0; info++, n--) {
1063 pa_sink_input_unref(info->userdata);
1064 if (info->chunk.memblock)
1065 pa_memblock_unref(info->chunk.memblock);
1069 if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
1070 pa_source_post(s->monitor_source, result);
1073 /* Called from IO thread context */
1074 void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result) {
1075 pa_mix_info info[MAX_MIX_CHANNELS];
1077 size_t block_size_max;
1079 pa_sink_assert_ref(s);
1080 pa_sink_assert_io_context(s);
1081 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1082 pa_assert(pa_frame_aligned(length, &s->sample_spec));
1085 pa_assert(!s->thread_info.rewind_requested);
1086 pa_assert(s->thread_info.rewind_nbytes == 0);
1088 if (s->thread_info.state == PA_SINK_SUSPENDED) {
1089 result->memblock = pa_memblock_ref(s->silence.memblock);
1090 result->index = s->silence.index;
1091 result->length = PA_MIN(s->silence.length, length);
1098 length = pa_frame_align(MIX_BUFFER_LENGTH, &s->sample_spec);
1100 block_size_max = pa_mempool_block_size_max(s->core->mempool);
1101 if (length > block_size_max)
1102 length = pa_frame_align(block_size_max, &s->sample_spec);
1104 pa_assert(length > 0);
1106 n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
1110 *result = s->silence;
1111 pa_memblock_ref(result->memblock);
1113 if (result->length > length)
1114 result->length = length;
1116 } else if (n == 1) {
1119 *result = info[0].chunk;
1120 pa_memblock_ref(result->memblock);
1122 if (result->length > length)
1123 result->length = length;
1125 pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
1127 if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume)) {
1128 pa_memblock_unref(result->memblock);
1129 pa_silence_memchunk_get(&s->core->silence_cache,
1134 } else if (!pa_cvolume_is_norm(&volume)) {
1135 pa_memchunk_make_writable(result, 0);
1136 pa_volume_memchunk(result, &s->sample_spec, &volume);
1140 result->memblock = pa_memblock_new(s->core->mempool, length);
1142 ptr = pa_memblock_acquire(result->memblock);
1143 result->length = pa_mix(info, n,
1146 &s->thread_info.soft_volume,
1147 s->thread_info.soft_muted);
1148 pa_memblock_release(result->memblock);
1153 inputs_drop(s, info, n, result);
1158 /* Called from IO thread context */
1159 void pa_sink_render_into(pa_sink*s, pa_memchunk *target) {
1160 pa_mix_info info[MAX_MIX_CHANNELS];
1162 size_t length, block_size_max;
1164 pa_sink_assert_ref(s);
1165 pa_sink_assert_io_context(s);
1166 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1168 pa_assert(target->memblock);
1169 pa_assert(target->length > 0);
1170 pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
1172 pa_assert(!s->thread_info.rewind_requested);
1173 pa_assert(s->thread_info.rewind_nbytes == 0);
1175 if (s->thread_info.state == PA_SINK_SUSPENDED) {
1176 pa_silence_memchunk(target, &s->sample_spec);
1182 length = target->length;
1183 block_size_max = pa_mempool_block_size_max(s->core->mempool);
1184 if (length > block_size_max)
1185 length = pa_frame_align(block_size_max, &s->sample_spec);
1187 pa_assert(length > 0);
1189 n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
1192 if (target->length > length)
1193 target->length = length;
1195 pa_silence_memchunk(target, &s->sample_spec);
1196 } else if (n == 1) {
1199 if (target->length > length)
1200 target->length = length;
1202 pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
1204 if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume))
1205 pa_silence_memchunk(target, &s->sample_spec);
1209 vchunk = info[0].chunk;
1210 pa_memblock_ref(vchunk.memblock);
1212 if (vchunk.length > length)
1213 vchunk.length = length;
1215 if (!pa_cvolume_is_norm(&volume)) {
1216 pa_memchunk_make_writable(&vchunk, 0);
1217 pa_volume_memchunk(&vchunk, &s->sample_spec, &volume);
1220 pa_memchunk_memcpy(target, &vchunk);
1221 pa_memblock_unref(vchunk.memblock);
1227 ptr = pa_memblock_acquire(target->memblock);
1229 target->length = pa_mix(info, n,
1230 (uint8_t*) ptr + target->index, length,
1232 &s->thread_info.soft_volume,
1233 s->thread_info.soft_muted);
1235 pa_memblock_release(target->memblock);
1238 inputs_drop(s, info, n, target);
1243 /* Called from IO thread context */
1244 void pa_sink_render_into_full(pa_sink *s, pa_memchunk *target) {
1248 pa_sink_assert_ref(s);
1249 pa_sink_assert_io_context(s);
1250 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1252 pa_assert(target->memblock);
1253 pa_assert(target->length > 0);
1254 pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
1256 pa_assert(!s->thread_info.rewind_requested);
1257 pa_assert(s->thread_info.rewind_nbytes == 0);
1259 if (s->thread_info.state == PA_SINK_SUSPENDED) {
1260 pa_silence_memchunk(target, &s->sample_spec);
1273 pa_sink_render_into(s, &chunk);
1282 /* Called from IO thread context */
1283 void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result) {
1284 pa_sink_assert_ref(s);
1285 pa_sink_assert_io_context(s);
1286 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1287 pa_assert(length > 0);
1288 pa_assert(pa_frame_aligned(length, &s->sample_spec));
1291 pa_assert(!s->thread_info.rewind_requested);
1292 pa_assert(s->thread_info.rewind_nbytes == 0);
1296 pa_sink_render(s, length, result);
1298 if (result->length < length) {
1301 pa_memchunk_make_writable(result, length);
1303 chunk.memblock = result->memblock;
1304 chunk.index = result->index + result->length;
1305 chunk.length = length - result->length;
1307 pa_sink_render_into_full(s, &chunk);
1309 result->length = length;
1315 /* Called from main thread */
1316 pa_usec_t pa_sink_get_latency(pa_sink *s) {
1319 pa_sink_assert_ref(s);
1320 pa_assert_ctl_context();
1321 pa_assert(PA_SINK_IS_LINKED(s->state));
1323 /* The returned value is supposed to be in the time domain of the sound card! */
1325 if (s->state == PA_SINK_SUSPENDED)
1328 if (!(s->flags & PA_SINK_LATENCY))
1331 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
1336 /* Called from IO thread */
1337 pa_usec_t pa_sink_get_latency_within_thread(pa_sink *s) {
1341 pa_sink_assert_ref(s);
1342 pa_sink_assert_io_context(s);
1343 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1345 /* The returned value is supposed to be in the time domain of the sound card! */
1347 if (s->thread_info.state == PA_SINK_SUSPENDED)
1350 if (!(s->flags & PA_SINK_LATENCY))
1353 o = PA_MSGOBJECT(s);
1355 /* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
1357 if (o->process_msg(o, PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1363 /* Called from the main thread (and also from the IO thread while the main
1364 * thread is waiting).
1366 * When a sink uses volume sharing, it never has the PA_SINK_FLAT_VOLUME flag
1367 * set. Instead, flat volume mode is detected by checking whether the root sink
1368 * has the flag set. */
1369 pa_bool_t pa_sink_flat_volume_enabled(pa_sink *s) {
1370 pa_sink_assert_ref(s);
1372 s = pa_sink_get_master(s);
1375 return (s->flags & PA_SINK_FLAT_VOLUME);
1380 /* Called from the main thread (and also from the IO thread while the main
1381 * thread is waiting). */
1382 pa_sink *pa_sink_get_master(pa_sink *s) {
1383 pa_sink_assert_ref(s);
1385 while (s && (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1386 if (PA_UNLIKELY(!s->input_to_master))
1389 s = s->input_to_master->sink;
1395 /* Called from main context */
1396 pa_bool_t pa_sink_is_passthrough(pa_sink *s) {
1397 pa_sink_input *alt_i;
1400 pa_sink_assert_ref(s);
1402 /* one and only one PASSTHROUGH input can possibly be connected */
1403 if (pa_idxset_size(s->inputs) == 1) {
1404 alt_i = pa_idxset_first(s->inputs, &idx);
1406 if (pa_sink_input_is_passthrough(alt_i))
1413 /* Called from main context */
1414 void pa_sink_enter_passthrough(pa_sink *s) {
1417 /* disable the monitor in passthrough mode */
1418 if (s->monitor_source)
1419 pa_source_suspend(s->monitor_source, TRUE, PA_SUSPEND_PASSTHROUGH);
1421 /* set the volume to NORM */
1422 s->saved_volume = *pa_sink_get_volume(s, TRUE);
1423 s->saved_save_volume = s->save_volume;
1425 pa_cvolume_set(&volume, s->sample_spec.channels, PA_MIN(s->base_volume, PA_VOLUME_NORM));
1426 pa_sink_set_volume(s, &volume, TRUE, FALSE);
1429 /* Called from main context */
1430 void pa_sink_leave_passthrough(pa_sink *s) {
1431 /* Unsuspend monitor */
1432 if (s->monitor_source)
1433 pa_source_suspend(s->monitor_source, FALSE, PA_SUSPEND_PASSTHROUGH);
1435 /* Restore sink volume to what it was before we entered passthrough mode */
1436 pa_sink_set_volume(s, &s->saved_volume, TRUE, s->saved_save_volume);
1438 pa_cvolume_init(&s->saved_volume);
1439 s->saved_save_volume = FALSE;
1442 /* Called from main context. */
1443 static void compute_reference_ratio(pa_sink_input *i) {
1445 pa_cvolume remapped;
1448 pa_assert(pa_sink_flat_volume_enabled(i->sink));
1451 * Calculates the reference ratio from the sink's reference
1452 * volume. This basically calculates:
1454 * i->reference_ratio = i->volume / i->sink->reference_volume
1457 remapped = i->sink->reference_volume;
1458 pa_cvolume_remap(&remapped, &i->sink->channel_map, &i->channel_map);
1460 i->reference_ratio.channels = i->sample_spec.channels;
1462 for (c = 0; c < i->sample_spec.channels; c++) {
1464 /* We don't update when the sink volume is 0 anyway */
1465 if (remapped.values[c] <= PA_VOLUME_MUTED)
1468 /* Don't update the reference ratio unless necessary */
1469 if (pa_sw_volume_multiply(
1470 i->reference_ratio.values[c],
1471 remapped.values[c]) == i->volume.values[c])
1474 i->reference_ratio.values[c] = pa_sw_volume_divide(
1475 i->volume.values[c],
1476 remapped.values[c]);
1480 /* Called from main context. Only called for the root sink in volume sharing
1481 * cases, except for internal recursive calls. */
1482 static void compute_reference_ratios(pa_sink *s) {
1486 pa_sink_assert_ref(s);
1487 pa_assert_ctl_context();
1488 pa_assert(PA_SINK_IS_LINKED(s->state));
1489 pa_assert(pa_sink_flat_volume_enabled(s));
1491 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1492 compute_reference_ratio(i);
1494 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1495 compute_reference_ratios(i->origin_sink);
1499 /* Called from main context. Only called for the root sink in volume sharing
1500 * cases, except for internal recursive calls. */
1501 static void compute_real_ratios(pa_sink *s) {
1505 pa_sink_assert_ref(s);
1506 pa_assert_ctl_context();
1507 pa_assert(PA_SINK_IS_LINKED(s->state));
1508 pa_assert(pa_sink_flat_volume_enabled(s));
1510 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1512 pa_cvolume remapped;
1514 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1515 /* The origin sink uses volume sharing, so this input's real ratio
1516 * is handled as a special case - the real ratio must be 0 dB, and
1517 * as a result i->soft_volume must equal i->volume_factor. */
1518 pa_cvolume_reset(&i->real_ratio, i->real_ratio.channels);
1519 i->soft_volume = i->volume_factor;
1521 compute_real_ratios(i->origin_sink);
1527 * This basically calculates:
1529 * i->real_ratio := i->volume / s->real_volume
1530 * i->soft_volume := i->real_ratio * i->volume_factor
1533 remapped = s->real_volume;
1534 pa_cvolume_remap(&remapped, &s->channel_map, &i->channel_map);
1536 i->real_ratio.channels = i->sample_spec.channels;
1537 i->soft_volume.channels = i->sample_spec.channels;
1539 for (c = 0; c < i->sample_spec.channels; c++) {
1541 if (remapped.values[c] <= PA_VOLUME_MUTED) {
1542 /* We leave i->real_ratio untouched */
1543 i->soft_volume.values[c] = PA_VOLUME_MUTED;
1547 /* Don't lose accuracy unless necessary */
1548 if (pa_sw_volume_multiply(
1549 i->real_ratio.values[c],
1550 remapped.values[c]) != i->volume.values[c])
1552 i->real_ratio.values[c] = pa_sw_volume_divide(
1553 i->volume.values[c],
1554 remapped.values[c]);
1556 i->soft_volume.values[c] = pa_sw_volume_multiply(
1557 i->real_ratio.values[c],
1558 i->volume_factor.values[c]);
1561 /* We don't copy the soft_volume to the thread_info data
1562 * here. That must be done by the caller */
1566 static pa_cvolume *cvolume_remap_minimal_impact(
1568 const pa_cvolume *template,
1569 const pa_channel_map *from,
1570 const pa_channel_map *to) {
1575 pa_assert(template);
1578 pa_assert(pa_cvolume_compatible_with_channel_map(v, from));
1579 pa_assert(pa_cvolume_compatible_with_channel_map(template, to));
1581 /* Much like pa_cvolume_remap(), but tries to minimize impact when
1582 * mapping from sink input to sink volumes:
1584 * If template is a possible remapping from v it is used instead
1585 * of remapping anew.
1587 * If the channel maps don't match we set an all-channel volume on
1588 * the sink to ensure that changing a volume on one stream has no
1589 * effect that cannot be compensated for in another stream that
1590 * does not have the same channel map as the sink. */
1592 if (pa_channel_map_equal(from, to))
1596 if (pa_cvolume_equal(pa_cvolume_remap(&t, to, from), v)) {
1601 pa_cvolume_set(v, to->channels, pa_cvolume_max(v));
1605 /* Called from main thread. Only called for the root sink in volume sharing
1606 * cases, except for internal recursive calls. */
1607 static void get_maximum_input_volume(pa_sink *s, pa_cvolume *max_volume, const pa_channel_map *channel_map) {
1611 pa_sink_assert_ref(s);
1612 pa_assert(max_volume);
1613 pa_assert(channel_map);
1614 pa_assert(pa_sink_flat_volume_enabled(s));
1616 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1617 pa_cvolume remapped;
1619 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1620 get_maximum_input_volume(i->origin_sink, max_volume, channel_map);
1622 /* Ignore this input. The origin sink uses volume sharing, so this
1623 * input's volume will be set to be equal to the root sink's real
1624 * volume. Obviously this input's current volume must not then
1625 * affect what the root sink's real volume will be. */
1629 remapped = i->volume;
1630 cvolume_remap_minimal_impact(&remapped, max_volume, &i->channel_map, channel_map);
1631 pa_cvolume_merge(max_volume, max_volume, &remapped);
1635 /* Called from main thread. Only called for the root sink in volume sharing
1636 * cases, except for internal recursive calls. */
1637 static pa_bool_t has_inputs(pa_sink *s) {
1641 pa_sink_assert_ref(s);
1643 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1644 if (!i->origin_sink || !(i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) || has_inputs(i->origin_sink))
1651 /* Called from main thread. Only called for the root sink in volume sharing
1652 * cases, except for internal recursive calls. */
1653 static void update_real_volume(pa_sink *s, const pa_cvolume *new_volume, pa_channel_map *channel_map) {
1657 pa_sink_assert_ref(s);
1658 pa_assert(new_volume);
1659 pa_assert(channel_map);
1661 s->real_volume = *new_volume;
1662 pa_cvolume_remap(&s->real_volume, channel_map, &s->channel_map);
1664 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1665 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1666 if (pa_sink_flat_volume_enabled(s)) {
1667 pa_cvolume old_volume = i->volume;
1669 /* Follow the root sink's real volume. */
1670 i->volume = *new_volume;
1671 pa_cvolume_remap(&i->volume, channel_map, &i->channel_map);
1672 compute_reference_ratio(i);
1674 /* The volume changed, let's tell people so */
1675 if (!pa_cvolume_equal(&old_volume, &i->volume)) {
1676 if (i->volume_changed)
1677 i->volume_changed(i);
1679 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1683 update_real_volume(i->origin_sink, new_volume, channel_map);
1688 /* Called from main thread. Only called for the root sink in shared volume
1690 static void compute_real_volume(pa_sink *s) {
1691 pa_sink_assert_ref(s);
1692 pa_assert_ctl_context();
1693 pa_assert(PA_SINK_IS_LINKED(s->state));
1694 pa_assert(pa_sink_flat_volume_enabled(s));
1695 pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1697 /* This determines the maximum volume of all streams and sets
1698 * s->real_volume accordingly. */
1700 if (!has_inputs(s)) {
1701 /* In the special case that we have no sink inputs we leave the
1702 * volume unmodified. */
1703 update_real_volume(s, &s->reference_volume, &s->channel_map);
1707 pa_cvolume_mute(&s->real_volume, s->channel_map.channels);
1709 /* First let's determine the new maximum volume of all inputs
1710 * connected to this sink */
1711 get_maximum_input_volume(s, &s->real_volume, &s->channel_map);
1712 update_real_volume(s, &s->real_volume, &s->channel_map);
1714 /* Then, let's update the real ratios/soft volumes of all inputs
1715 * connected to this sink */
1716 compute_real_ratios(s);
1719 /* Called from main thread. Only called for the root sink in shared volume
1720 * cases, except for internal recursive calls. */
1721 static void propagate_reference_volume(pa_sink *s) {
1725 pa_sink_assert_ref(s);
1726 pa_assert_ctl_context();
1727 pa_assert(PA_SINK_IS_LINKED(s->state));
1728 pa_assert(pa_sink_flat_volume_enabled(s));
1730 /* This is called whenever the sink volume changes that is not
1731 * caused by a sink input volume change. We need to fix up the
1732 * sink input volumes accordingly */
1734 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1735 pa_cvolume old_volume;
1737 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1738 propagate_reference_volume(i->origin_sink);
1740 /* Since the origin sink uses volume sharing, this input's volume
1741 * needs to be updated to match the root sink's real volume, but
1742 * that will be done later in update_shared_real_volume(). */
1746 old_volume = i->volume;
1748 /* This basically calculates:
1750 * i->volume := s->reference_volume * i->reference_ratio */
1752 i->volume = s->reference_volume;
1753 pa_cvolume_remap(&i->volume, &s->channel_map, &i->channel_map);
1754 pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1756 /* The volume changed, let's tell people so */
1757 if (!pa_cvolume_equal(&old_volume, &i->volume)) {
1759 if (i->volume_changed)
1760 i->volume_changed(i);
1762 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1767 /* Called from main thread. Only called for the root sink in volume sharing
1768 * cases, except for internal recursive calls. The return value indicates
1769 * whether any reference volume actually changed. */
1770 static pa_bool_t update_reference_volume(pa_sink *s, const pa_cvolume *v, const pa_channel_map *channel_map, pa_bool_t save) {
1772 pa_bool_t reference_volume_changed;
1776 pa_sink_assert_ref(s);
1777 pa_assert(PA_SINK_IS_LINKED(s->state));
1779 pa_assert(channel_map);
1780 pa_assert(pa_cvolume_valid(v));
1783 pa_cvolume_remap(&volume, channel_map, &s->channel_map);
1785 reference_volume_changed = !pa_cvolume_equal(&volume, &s->reference_volume);
1786 s->reference_volume = volume;
1788 s->save_volume = (!reference_volume_changed && s->save_volume) || save;
1790 if (reference_volume_changed)
1791 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1792 else if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1793 /* If the root sink's volume doesn't change, then there can't be any
1794 * changes in the other sinks in the sink tree either.
1796 * It's probably theoretically possible that even if the root sink's
1797 * volume changes slightly, some filter sink doesn't change its volume
1798 * due to rounding errors. If that happens, we still want to propagate
1799 * the changed root sink volume to the sinks connected to the
1800 * intermediate sink that didn't change its volume. This theoretical
1801 * possibility is the reason why we have that !(s->flags &
1802 * PA_SINK_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
1803 * notice even if we returned here FALSE always if
1804 * reference_volume_changed is FALSE. */
1807 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1808 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1809 update_reference_volume(i->origin_sink, v, channel_map, FALSE);
1815 /* Called from main thread */
1816 void pa_sink_set_volume(
1818 const pa_cvolume *volume,
1822 pa_cvolume new_reference_volume;
1825 pa_sink_assert_ref(s);
1826 pa_assert_ctl_context();
1827 pa_assert(PA_SINK_IS_LINKED(s->state));
1828 pa_assert(!volume || pa_cvolume_valid(volume));
1829 pa_assert(volume || pa_sink_flat_volume_enabled(s));
1830 pa_assert(!volume || volume->channels == 1 || pa_cvolume_compatible(volume, &s->sample_spec));
1832 /* make sure we don't change the volume when a PASSTHROUGH input is connected ...
1833 * ... *except* if we're being invoked to reset the volume to ensure 0 dB gain */
1834 if (pa_sink_is_passthrough(s) && (!volume || !pa_cvolume_is_norm(volume))) {
1835 pa_log_warn("Cannot change volume, Sink is connected to PASSTHROUGH input");
1839 /* In case of volume sharing, the volume is set for the root sink first,
1840 * from which it's then propagated to the sharing sinks. */
1841 root_sink = pa_sink_get_master(s);
1843 if (PA_UNLIKELY(!root_sink))
1846 /* As a special exception we accept mono volumes on all sinks --
1847 * even on those with more complex channel maps */
1850 if (pa_cvolume_compatible(volume, &s->sample_spec))
1851 new_reference_volume = *volume;
1853 new_reference_volume = s->reference_volume;
1854 pa_cvolume_scale(&new_reference_volume, pa_cvolume_max(volume));
1857 pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_sink->channel_map);
1860 /* If volume is NULL we synchronize the sink's real and reference
1861 * volumes with the stream volumes. If it is not NULL we update
1862 * the reference_volume with it. */
1865 if (update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save)) {
1866 if (pa_sink_flat_volume_enabled(root_sink)) {
1867 /* OK, propagate this volume change back to the inputs */
1868 propagate_reference_volume(root_sink);
1870 /* And now recalculate the real volume */
1871 compute_real_volume(root_sink);
1873 update_real_volume(root_sink, &root_sink->reference_volume, &root_sink->channel_map);
1877 pa_assert(pa_sink_flat_volume_enabled(root_sink));
1879 /* Ok, let's determine the new real volume */
1880 compute_real_volume(root_sink);
1882 /* Let's 'push' the reference volume if necessary */
1883 pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_sink->real_volume);
1884 /* If the sink and it's root don't have the same number of channels, we need to remap */
1885 if (s != root_sink && !pa_channel_map_equal(&s->channel_map, &root_sink->channel_map))
1886 pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_sink->channel_map);
1887 update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save);
1889 /* Now that the reference volume is updated, we can update the streams'
1890 * reference ratios. */
1891 compute_reference_ratios(root_sink);
1894 if (root_sink->set_volume) {
1895 /* If we have a function set_volume(), then we do not apply a
1896 * soft volume by default. However, set_volume() is free to
1897 * apply one to root_sink->soft_volume */
1899 pa_cvolume_reset(&root_sink->soft_volume, root_sink->sample_spec.channels);
1900 if (!(root_sink->flags & PA_SINK_DEFERRED_VOLUME))
1901 root_sink->set_volume(root_sink);
1904 /* If we have no function set_volume(), then the soft volume
1905 * becomes the real volume */
1906 root_sink->soft_volume = root_sink->real_volume;
1908 /* This tells the sink that soft volume and/or real volume changed */
1910 pa_assert_se(pa_asyncmsgq_send(root_sink->asyncmsgq, PA_MSGOBJECT(root_sink), PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL) == 0);
1913 /* Called from the io thread if sync volume is used, otherwise from the main thread.
1914 * Only to be called by sink implementor */
1915 void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
1917 pa_sink_assert_ref(s);
1918 pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1920 if (s->flags & PA_SINK_DEFERRED_VOLUME)
1921 pa_sink_assert_io_context(s);
1923 pa_assert_ctl_context();
1926 pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
1928 s->soft_volume = *volume;
1930 if (PA_SINK_IS_LINKED(s->state) && !(s->flags & PA_SINK_DEFERRED_VOLUME))
1931 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
1933 s->thread_info.soft_volume = s->soft_volume;
1936 /* Called from the main thread. Only called for the root sink in volume sharing
1937 * cases, except for internal recursive calls. */
1938 static void propagate_real_volume(pa_sink *s, const pa_cvolume *old_real_volume) {
1942 pa_sink_assert_ref(s);
1943 pa_assert(old_real_volume);
1944 pa_assert_ctl_context();
1945 pa_assert(PA_SINK_IS_LINKED(s->state));
1947 /* This is called when the hardware's real volume changes due to
1948 * some external event. We copy the real volume into our
1949 * reference volume and then rebuild the stream volumes based on
1950 * i->real_ratio which should stay fixed. */
1952 if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1953 if (pa_cvolume_equal(old_real_volume, &s->real_volume))
1956 /* 1. Make the real volume the reference volume */
1957 update_reference_volume(s, &s->real_volume, &s->channel_map, TRUE);
1960 if (pa_sink_flat_volume_enabled(s)) {
1962 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1963 pa_cvolume old_volume = i->volume;
1965 /* 2. Since the sink's reference and real volumes are equal
1966 * now our ratios should be too. */
1967 i->reference_ratio = i->real_ratio;
1969 /* 3. Recalculate the new stream reference volume based on the
1970 * reference ratio and the sink's reference volume.
1972 * This basically calculates:
1974 * i->volume = s->reference_volume * i->reference_ratio
1976 * This is identical to propagate_reference_volume() */
1977 i->volume = s->reference_volume;
1978 pa_cvolume_remap(&i->volume, &s->channel_map, &i->channel_map);
1979 pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1981 /* Notify if something changed */
1982 if (!pa_cvolume_equal(&old_volume, &i->volume)) {
1984 if (i->volume_changed)
1985 i->volume_changed(i);
1987 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1990 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1991 propagate_real_volume(i->origin_sink, old_real_volume);
1995 /* Something got changed in the hardware. It probably makes sense
1996 * to save changed hw settings given that hw volume changes not
1997 * triggered by PA are almost certainly done by the user. */
1998 if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1999 s->save_volume = TRUE;
2002 /* Called from io thread */
2003 void pa_sink_update_volume_and_mute(pa_sink *s) {
2005 pa_sink_assert_io_context(s);
2007 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE, NULL, 0, NULL, NULL);
2010 /* Called from main thread */
2011 const pa_cvolume *pa_sink_get_volume(pa_sink *s, pa_bool_t force_refresh) {
2012 pa_sink_assert_ref(s);
2013 pa_assert_ctl_context();
2014 pa_assert(PA_SINK_IS_LINKED(s->state));
2016 if (s->refresh_volume || force_refresh) {
2017 struct pa_cvolume old_real_volume;
2019 pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2021 old_real_volume = s->real_volume;
2023 if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume)
2026 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
2028 update_real_volume(s, &s->real_volume, &s->channel_map);
2029 propagate_real_volume(s, &old_real_volume);
2032 return &s->reference_volume;
2035 /* Called from main thread. In volume sharing cases, only the root sink may
2037 void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_real_volume) {
2038 pa_cvolume old_real_volume;
2040 pa_sink_assert_ref(s);
2041 pa_assert_ctl_context();
2042 pa_assert(PA_SINK_IS_LINKED(s->state));
2043 pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2045 /* The sink implementor may call this if the volume changed to make sure everyone is notified */
2047 old_real_volume = s->real_volume;
2048 update_real_volume(s, new_real_volume, &s->channel_map);
2049 propagate_real_volume(s, &old_real_volume);
2052 /* Called from main thread */
2053 void pa_sink_set_mute(pa_sink *s, pa_bool_t mute, pa_bool_t save) {
2054 pa_bool_t old_muted;
2056 pa_sink_assert_ref(s);
2057 pa_assert_ctl_context();
2058 pa_assert(PA_SINK_IS_LINKED(s->state));
2060 old_muted = s->muted;
2062 s->save_muted = (old_muted == s->muted && s->save_muted) || save;
2064 if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->set_mute)
2067 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
2069 if (old_muted != s->muted)
2070 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2073 /* Called from main thread */
2074 pa_bool_t pa_sink_get_mute(pa_sink *s, pa_bool_t force_refresh) {
2076 pa_sink_assert_ref(s);
2077 pa_assert_ctl_context();
2078 pa_assert(PA_SINK_IS_LINKED(s->state));
2080 if (s->refresh_muted || force_refresh) {
2081 pa_bool_t old_muted = s->muted;
2083 if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_mute)
2086 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
2088 if (old_muted != s->muted) {
2089 s->save_muted = TRUE;
2091 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2093 /* Make sure the soft mute status stays in sync */
2094 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
2101 /* Called from main thread */
2102 void pa_sink_mute_changed(pa_sink *s, pa_bool_t new_muted) {
2103 pa_sink_assert_ref(s);
2104 pa_assert_ctl_context();
2105 pa_assert(PA_SINK_IS_LINKED(s->state));
2107 /* The sink implementor may call this if the volume changed to make sure everyone is notified */
2109 if (s->muted == new_muted)
2112 s->muted = new_muted;
2113 s->save_muted = TRUE;
2115 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2118 /* Called from main thread */
2119 pa_bool_t pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p) {
2120 pa_sink_assert_ref(s);
2121 pa_assert_ctl_context();
2124 pa_proplist_update(s->proplist, mode, p);
2126 if (PA_SINK_IS_LINKED(s->state)) {
2127 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
2128 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2134 /* Called from main thread */
2135 /* FIXME -- this should be dropped and be merged into pa_sink_update_proplist() */
2136 void pa_sink_set_description(pa_sink *s, const char *description) {
2138 pa_sink_assert_ref(s);
2139 pa_assert_ctl_context();
2141 if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
2144 old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
2146 if (old && description && pa_streq(old, description))
2150 pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
2152 pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
2154 if (s->monitor_source) {
2157 n = pa_sprintf_malloc("Monitor Source of %s", description ? description : s->name);
2158 pa_source_set_description(s->monitor_source, n);
2162 if (PA_SINK_IS_LINKED(s->state)) {
2163 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2164 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
2168 /* Called from main thread */
2169 unsigned pa_sink_linked_by(pa_sink *s) {
2172 pa_sink_assert_ref(s);
2173 pa_assert_ctl_context();
2174 pa_assert(PA_SINK_IS_LINKED(s->state));
2176 ret = pa_idxset_size(s->inputs);
2178 /* We add in the number of streams connected to us here. Please
2179 * note the asymmetry to pa_sink_used_by()! */
2181 if (s->monitor_source)
2182 ret += pa_source_linked_by(s->monitor_source);
2187 /* Called from main thread */
2188 unsigned pa_sink_used_by(pa_sink *s) {
2191 pa_sink_assert_ref(s);
2192 pa_assert_ctl_context();
2193 pa_assert(PA_SINK_IS_LINKED(s->state));
2195 ret = pa_idxset_size(s->inputs);
2196 pa_assert(ret >= s->n_corked);
2198 /* Streams connected to our monitor source do not matter for
2199 * pa_sink_used_by()!.*/
2201 return ret - s->n_corked;
2204 /* Called from main thread */
2205 unsigned pa_sink_check_suspend(pa_sink *s) {
2210 pa_sink_assert_ref(s);
2211 pa_assert_ctl_context();
2213 if (!PA_SINK_IS_LINKED(s->state))
2218 PA_IDXSET_FOREACH(i, s->inputs, idx) {
2219 pa_sink_input_state_t st;
2221 st = pa_sink_input_get_state(i);
2223 /* We do not assert here. It is perfectly valid for a sink input to
2224 * be in the INIT state (i.e. created, marked done but not yet put)
2225 * and we should not care if it's unlinked as it won't contribute
2226 * towards our busy status.
2228 if (!PA_SINK_INPUT_IS_LINKED(st))
2231 if (st == PA_SINK_INPUT_CORKED)
2234 if (i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND)
2240 if (s->monitor_source)
2241 ret += pa_source_check_suspend(s->monitor_source);
2246 /* Called from the IO thread */
2247 static void sync_input_volumes_within_thread(pa_sink *s) {
2251 pa_sink_assert_ref(s);
2252 pa_sink_assert_io_context(s);
2254 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2255 if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume))
2258 i->thread_info.soft_volume = i->soft_volume;
2259 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
2263 /* Called from the IO thread. Only called for the root sink in volume sharing
2264 * cases, except for internal recursive calls. */
2265 static void set_shared_volume_within_thread(pa_sink *s) {
2266 pa_sink_input *i = NULL;
2269 pa_sink_assert_ref(s);
2271 PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
2273 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2274 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2275 set_shared_volume_within_thread(i->origin_sink);
2279 /* Called from IO thread, except when it is not */
2280 int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2281 pa_sink *s = PA_SINK(o);
2282 pa_sink_assert_ref(s);
2284 switch ((pa_sink_message_t) code) {
2286 case PA_SINK_MESSAGE_ADD_INPUT: {
2287 pa_sink_input *i = PA_SINK_INPUT(userdata);
2289 /* If you change anything here, make sure to change the
2290 * sink input handling a few lines down at
2291 * PA_SINK_MESSAGE_FINISH_MOVE, too. */
2293 pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2295 /* Since the caller sleeps in pa_sink_input_put(), we can
2296 * safely access data outside of thread_info even though
2299 if ((i->thread_info.sync_prev = i->sync_prev)) {
2300 pa_assert(i->sink == i->thread_info.sync_prev->sink);
2301 pa_assert(i->sync_prev->sync_next == i);
2302 i->thread_info.sync_prev->thread_info.sync_next = i;
2305 if ((i->thread_info.sync_next = i->sync_next)) {
2306 pa_assert(i->sink == i->thread_info.sync_next->sink);
2307 pa_assert(i->sync_next->sync_prev == i);
2308 i->thread_info.sync_next->thread_info.sync_prev = i;
2311 pa_assert(!i->thread_info.attached);
2312 i->thread_info.attached = TRUE;
2317 pa_sink_input_set_state_within_thread(i, i->state);
2319 /* The requested latency of the sink input needs to be
2320 * fixed up and then configured on the sink */
2322 if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2323 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2325 pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2326 pa_sink_input_update_max_request(i, s->thread_info.max_request);
2328 /* We don't rewind here automatically. This is left to the
2329 * sink input implementor because some sink inputs need a
2330 * slow start, i.e. need some time to buffer client
2331 * samples before beginning streaming. */
2333 /* FIXME: Actually rewinding should be requested before
2334 * updating the sink requested latency, because updating
2335 * the requested latency updates also max_rewind of the
2336 * sink. Now consider this: a sink has a 10 s buffer and
2337 * nobody has requested anything less. Then a new stream
2338 * appears while the sink buffer is full. The new stream
2339 * requests e.g. 100 ms latency. That request is forwarded
2340 * to the sink, so now max_rewind is 100 ms. When a rewind
2341 * is requested, the sink will only rewind 100 ms, and the
2342 * new stream will have to wait about 10 seconds before it
2343 * becomes audible. */
2345 /* In flat volume mode we need to update the volume as
2347 return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2350 case PA_SINK_MESSAGE_REMOVE_INPUT: {
2351 pa_sink_input *i = PA_SINK_INPUT(userdata);
2353 /* If you change anything here, make sure to change the
2354 * sink input handling a few lines down at
2355 * PA_SINK_MESSAGE_START_MOVE, too. */
2360 pa_sink_input_set_state_within_thread(i, i->state);
2362 pa_assert(i->thread_info.attached);
2363 i->thread_info.attached = FALSE;
2365 /* Since the caller sleeps in pa_sink_input_unlink(),
2366 * we can safely access data outside of thread_info even
2367 * though it is mutable */
2369 pa_assert(!i->sync_prev);
2370 pa_assert(!i->sync_next);
2372 if (i->thread_info.sync_prev) {
2373 i->thread_info.sync_prev->thread_info.sync_next = i->thread_info.sync_prev->sync_next;
2374 i->thread_info.sync_prev = NULL;
2377 if (i->thread_info.sync_next) {
2378 i->thread_info.sync_next->thread_info.sync_prev = i->thread_info.sync_next->sync_prev;
2379 i->thread_info.sync_next = NULL;
2382 if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
2383 pa_sink_input_unref(i);
2385 pa_sink_invalidate_requested_latency(s, TRUE);
2386 pa_sink_request_rewind(s, (size_t) -1);
2388 /* In flat volume mode we need to update the volume as
2390 return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2393 case PA_SINK_MESSAGE_START_MOVE: {
2394 pa_sink_input *i = PA_SINK_INPUT(userdata);
2396 /* We don't support moving synchronized streams. */
2397 pa_assert(!i->sync_prev);
2398 pa_assert(!i->sync_next);
2399 pa_assert(!i->thread_info.sync_next);
2400 pa_assert(!i->thread_info.sync_prev);
2402 if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2404 size_t sink_nbytes, total_nbytes;
2406 /* The old sink probably has some audio from this
2407 * stream in its buffer. We want to "take it back" as
2408 * much as possible and play it to the new sink. We
2409 * don't know at this point how much the old sink can
2410 * rewind. We have to pick something, and that
2411 * something is the full latency of the old sink here.
2412 * So we rewind the stream buffer by the sink latency
2413 * amount, which may be more than what we should
2414 * rewind. This can result in a chunk of audio being
2415 * played both to the old sink and the new sink.
2417 * FIXME: Fix this code so that we don't have to make
2418 * guesses about how much the sink will actually be
2419 * able to rewind. If someone comes up with a solution
2420 * for this, something to note is that the part of the
2421 * latency that the old sink couldn't rewind should
2422 * ideally be compensated after the stream has moved
2423 * to the new sink by adding silence. The new sink
2424 * most likely can't start playing the moved stream
2425 * immediately, and that gap should be removed from
2426 * the "compensation silence" (at least at the time of
2427 * writing this, the move finish code will actually
2428 * already take care of dropping the new sink's
2429 * unrewindable latency, so taking into account the
2430 * unrewindable latency of the old sink is the only
2433 * The render_memblockq contents are discarded,
2434 * because when the sink changes, the format of the
2435 * audio stored in the render_memblockq may change
2436 * too, making the stored audio invalid. FIXME:
2437 * However, the read and write indices are moved back
2438 * the same amount, so if they are not the same now,
2439 * they won't be the same after the rewind either. If
2440 * the write index of the render_memblockq is ahead of
2441 * the read index, then the render_memblockq will feed
2442 * the new sink some silence first, which it shouldn't
2443 * do. The write index should be flushed to be the
2444 * same as the read index. */
2446 /* Get the latency of the sink */
2447 usec = pa_sink_get_latency_within_thread(s);
2448 sink_nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2449 total_nbytes = sink_nbytes + pa_memblockq_get_length(i->thread_info.render_memblockq);
2451 if (total_nbytes > 0) {
2452 i->thread_info.rewrite_nbytes = i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, total_nbytes) : total_nbytes;
2453 i->thread_info.rewrite_flush = TRUE;
2454 pa_sink_input_process_rewind(i, sink_nbytes);
2461 pa_assert(i->thread_info.attached);
2462 i->thread_info.attached = FALSE;
2464 /* Let's remove the sink input ...*/
2465 if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
2466 pa_sink_input_unref(i);
2468 pa_sink_invalidate_requested_latency(s, TRUE);
2470 pa_log_debug("Requesting rewind due to started move");
2471 pa_sink_request_rewind(s, (size_t) -1);
2473 /* In flat volume mode we need to update the volume as
2475 return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2478 case PA_SINK_MESSAGE_FINISH_MOVE: {
2479 pa_sink_input *i = PA_SINK_INPUT(userdata);
2481 /* We don't support moving synchronized streams. */
2482 pa_assert(!i->sync_prev);
2483 pa_assert(!i->sync_next);
2484 pa_assert(!i->thread_info.sync_next);
2485 pa_assert(!i->thread_info.sync_prev);
2487 pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2489 pa_assert(!i->thread_info.attached);
2490 i->thread_info.attached = TRUE;
2495 if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2499 /* In the ideal case the new sink would start playing
2500 * the stream immediately. That requires the sink to
2501 * be able to rewind all of its latency, which usually
2502 * isn't possible, so there will probably be some gap
2503 * before the moved stream becomes audible. We then
2504 * have two possibilities: 1) start playing the stream
2505 * from where it is now, or 2) drop the unrewindable
2506 * latency of the sink from the stream. With option 1
2507 * we won't lose any audio but the stream will have a
2508 * pause. With option 2 we may lose some audio but the
2509 * stream time will be somewhat in sync with the wall
2510 * clock. Lennart seems to have chosen option 2 (one
2511 * of the reasons might have been that option 1 is
2512 * actually much harder to implement), so we drop the
2513 * latency of the new sink from the moved stream and
2514 * hope that the sink will undo most of that in the
2517 /* Get the latency of the sink */
2518 usec = pa_sink_get_latency_within_thread(s);
2519 nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2522 pa_sink_input_drop(i, nbytes);
2524 pa_log_debug("Requesting rewind due to finished move");
2525 pa_sink_request_rewind(s, nbytes);
2528 /* Updating the requested sink latency has to be done
2529 * after the sink rewind request, not before, because
2530 * otherwise the sink may limit the rewind amount
2533 if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2534 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2536 pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2537 pa_sink_input_update_max_request(i, s->thread_info.max_request);
2539 return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2542 case PA_SINK_MESSAGE_SET_SHARED_VOLUME: {
2543 pa_sink *root_sink = pa_sink_get_master(s);
2545 if (PA_LIKELY(root_sink))
2546 set_shared_volume_within_thread(root_sink);
2551 case PA_SINK_MESSAGE_SET_VOLUME_SYNCED:
2553 if (s->flags & PA_SINK_DEFERRED_VOLUME) {
2555 pa_sink_volume_change_push(s);
2557 /* Fall through ... */
2559 case PA_SINK_MESSAGE_SET_VOLUME:
2561 if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2562 s->thread_info.soft_volume = s->soft_volume;
2563 pa_sink_request_rewind(s, (size_t) -1);
2566 /* Fall through ... */
2568 case PA_SINK_MESSAGE_SYNC_VOLUMES:
2569 sync_input_volumes_within_thread(s);
2572 case PA_SINK_MESSAGE_GET_VOLUME:
2574 if ((s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume) {
2576 pa_sink_volume_change_flush(s);
2577 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2580 /* In case sink implementor reset SW volume. */
2581 if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2582 s->thread_info.soft_volume = s->soft_volume;
2583 pa_sink_request_rewind(s, (size_t) -1);
2588 case PA_SINK_MESSAGE_SET_MUTE:
2590 if (s->thread_info.soft_muted != s->muted) {
2591 s->thread_info.soft_muted = s->muted;
2592 pa_sink_request_rewind(s, (size_t) -1);
2595 if (s->flags & PA_SINK_DEFERRED_VOLUME && s->set_mute)
2600 case PA_SINK_MESSAGE_GET_MUTE:
2602 if (s->flags & PA_SINK_DEFERRED_VOLUME && s->get_mute)
2607 case PA_SINK_MESSAGE_SET_STATE: {
2609 pa_bool_t suspend_change =
2610 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
2611 (PA_SINK_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SINK_SUSPENDED);
2613 s->thread_info.state = PA_PTR_TO_UINT(userdata);
2615 if (s->thread_info.state == PA_SINK_SUSPENDED) {
2616 s->thread_info.rewind_nbytes = 0;
2617 s->thread_info.rewind_requested = FALSE;
2620 if (suspend_change) {
2624 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
2625 if (i->suspend_within_thread)
2626 i->suspend_within_thread(i, s->thread_info.state == PA_SINK_SUSPENDED);
2632 case PA_SINK_MESSAGE_DETACH:
2634 /* Detach all streams */
2635 pa_sink_detach_within_thread(s);
2638 case PA_SINK_MESSAGE_ATTACH:
2640 /* Reattach all streams */
2641 pa_sink_attach_within_thread(s);
2644 case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY: {
2646 pa_usec_t *usec = userdata;
2647 *usec = pa_sink_get_requested_latency_within_thread(s);
2649 /* Yes, that's right, the IO thread will see -1 when no
2650 * explicit requested latency is configured, the main
2651 * thread will see max_latency */
2652 if (*usec == (pa_usec_t) -1)
2653 *usec = s->thread_info.max_latency;
2658 case PA_SINK_MESSAGE_SET_LATENCY_RANGE: {
2659 pa_usec_t *r = userdata;
2661 pa_sink_set_latency_range_within_thread(s, r[0], r[1]);
2666 case PA_SINK_MESSAGE_GET_LATENCY_RANGE: {
2667 pa_usec_t *r = userdata;
2669 r[0] = s->thread_info.min_latency;
2670 r[1] = s->thread_info.max_latency;
2675 case PA_SINK_MESSAGE_GET_FIXED_LATENCY:
2677 *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2680 case PA_SINK_MESSAGE_SET_FIXED_LATENCY:
2682 pa_sink_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2685 case PA_SINK_MESSAGE_GET_MAX_REWIND:
2687 *((size_t*) userdata) = s->thread_info.max_rewind;
2690 case PA_SINK_MESSAGE_GET_MAX_REQUEST:
2692 *((size_t*) userdata) = s->thread_info.max_request;
2695 case PA_SINK_MESSAGE_SET_MAX_REWIND:
2697 pa_sink_set_max_rewind_within_thread(s, (size_t) offset);
2700 case PA_SINK_MESSAGE_SET_MAX_REQUEST:
2702 pa_sink_set_max_request_within_thread(s, (size_t) offset);
2705 case PA_SINK_MESSAGE_SET_PORT:
2707 pa_assert(userdata);
2709 struct sink_message_set_port *msg_data = userdata;
2710 msg_data->ret = s->set_port(s, msg_data->port);
2714 case PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2715 /* This message is sent from IO-thread and handled in main thread. */
2716 pa_assert_ctl_context();
2718 /* Make sure we're not messing with main thread when no longer linked */
2719 if (!PA_SINK_IS_LINKED(s->state))
2722 pa_sink_get_volume(s, TRUE);
2723 pa_sink_get_mute(s, TRUE);
2726 case PA_SINK_MESSAGE_GET_LATENCY:
2727 case PA_SINK_MESSAGE_MAX:
2734 /* Called from main thread */
2735 int pa_sink_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause) {
2740 pa_core_assert_ref(c);
2741 pa_assert_ctl_context();
2742 pa_assert(cause != 0);
2744 PA_IDXSET_FOREACH(sink, c->sinks, idx) {
2747 if ((r = pa_sink_suspend(sink, suspend, cause)) < 0)
2754 /* Called from main thread */
2755 void pa_sink_detach(pa_sink *s) {
2756 pa_sink_assert_ref(s);
2757 pa_assert_ctl_context();
2758 pa_assert(PA_SINK_IS_LINKED(s->state));
2760 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_DETACH, NULL, 0, NULL) == 0);
2763 /* Called from main thread */
2764 void pa_sink_attach(pa_sink *s) {
2765 pa_sink_assert_ref(s);
2766 pa_assert_ctl_context();
2767 pa_assert(PA_SINK_IS_LINKED(s->state));
2769 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_ATTACH, NULL, 0, NULL) == 0);
2772 /* Called from IO thread */
2773 void pa_sink_detach_within_thread(pa_sink *s) {
2777 pa_sink_assert_ref(s);
2778 pa_sink_assert_io_context(s);
2779 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2781 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2785 if (s->monitor_source)
2786 pa_source_detach_within_thread(s->monitor_source);
2789 /* Called from IO thread */
2790 void pa_sink_attach_within_thread(pa_sink *s) {
2794 pa_sink_assert_ref(s);
2795 pa_sink_assert_io_context(s);
2796 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2798 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2802 if (s->monitor_source)
2803 pa_source_attach_within_thread(s->monitor_source);
2806 /* Called from IO thread */
2807 void pa_sink_request_rewind(pa_sink*s, size_t nbytes) {
2808 pa_sink_assert_ref(s);
2809 pa_sink_assert_io_context(s);
2810 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2812 if (s->thread_info.state == PA_SINK_SUSPENDED)
2815 if (nbytes == (size_t) -1)
2816 nbytes = s->thread_info.max_rewind;
2818 nbytes = PA_MIN(nbytes, s->thread_info.max_rewind);
2820 if (s->thread_info.rewind_requested &&
2821 nbytes <= s->thread_info.rewind_nbytes)
2824 s->thread_info.rewind_nbytes = nbytes;
2825 s->thread_info.rewind_requested = TRUE;
2827 if (s->request_rewind)
2828 s->request_rewind(s);
2831 /* Called from IO thread */
2832 pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s) {
2833 pa_usec_t result = (pa_usec_t) -1;
2836 pa_usec_t monitor_latency;
2838 pa_sink_assert_ref(s);
2839 pa_sink_assert_io_context(s);
2841 if (!(s->flags & PA_SINK_DYNAMIC_LATENCY))
2842 return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
2844 if (s->thread_info.requested_latency_valid)
2845 return s->thread_info.requested_latency;
2847 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2848 if (i->thread_info.requested_sink_latency != (pa_usec_t) -1 &&
2849 (result == (pa_usec_t) -1 || result > i->thread_info.requested_sink_latency))
2850 result = i->thread_info.requested_sink_latency;
2852 monitor_latency = pa_source_get_requested_latency_within_thread(s->monitor_source);
2854 if (monitor_latency != (pa_usec_t) -1 &&
2855 (result == (pa_usec_t) -1 || result > monitor_latency))
2856 result = monitor_latency;
2858 if (result != (pa_usec_t) -1)
2859 result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
2861 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2862 /* Only cache if properly initialized */
2863 s->thread_info.requested_latency = result;
2864 s->thread_info.requested_latency_valid = TRUE;
2870 /* Called from main thread */
2871 pa_usec_t pa_sink_get_requested_latency(pa_sink *s) {
2874 pa_sink_assert_ref(s);
2875 pa_assert_ctl_context();
2876 pa_assert(PA_SINK_IS_LINKED(s->state));
2878 if (s->state == PA_SINK_SUSPENDED)
2881 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
2886 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2887 void pa_sink_set_max_rewind_within_thread(pa_sink *s, size_t max_rewind) {
2891 pa_sink_assert_ref(s);
2892 pa_sink_assert_io_context(s);
2894 if (max_rewind == s->thread_info.max_rewind)
2897 s->thread_info.max_rewind = max_rewind;
2899 if (PA_SINK_IS_LINKED(s->thread_info.state))
2900 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2901 pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2903 if (s->monitor_source)
2904 pa_source_set_max_rewind_within_thread(s->monitor_source, s->thread_info.max_rewind);
2907 /* Called from main thread */
2908 void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind) {
2909 pa_sink_assert_ref(s);
2910 pa_assert_ctl_context();
2912 if (PA_SINK_IS_LINKED(s->state))
2913 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
2915 pa_sink_set_max_rewind_within_thread(s, max_rewind);
2918 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2919 void pa_sink_set_max_request_within_thread(pa_sink *s, size_t max_request) {
2922 pa_sink_assert_ref(s);
2923 pa_sink_assert_io_context(s);
2925 if (max_request == s->thread_info.max_request)
2928 s->thread_info.max_request = max_request;
2930 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2933 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2934 pa_sink_input_update_max_request(i, s->thread_info.max_request);
2938 /* Called from main thread */
2939 void pa_sink_set_max_request(pa_sink *s, size_t max_request) {
2940 pa_sink_assert_ref(s);
2941 pa_assert_ctl_context();
2943 if (PA_SINK_IS_LINKED(s->state))
2944 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REQUEST, NULL, max_request, NULL) == 0);
2946 pa_sink_set_max_request_within_thread(s, max_request);
2949 /* Called from IO thread */
2950 void pa_sink_invalidate_requested_latency(pa_sink *s, pa_bool_t dynamic) {
2954 pa_sink_assert_ref(s);
2955 pa_sink_assert_io_context(s);
2957 if ((s->flags & PA_SINK_DYNAMIC_LATENCY))
2958 s->thread_info.requested_latency_valid = FALSE;
2962 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2964 if (s->update_requested_latency)
2965 s->update_requested_latency(s);
2967 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2968 if (i->update_sink_requested_latency)
2969 i->update_sink_requested_latency(i);
2973 /* Called from main thread */
2974 void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2975 pa_sink_assert_ref(s);
2976 pa_assert_ctl_context();
2978 /* min_latency == 0: no limit
2979 * min_latency anything else: specified limit
2981 * Similar for max_latency */
2983 if (min_latency < ABSOLUTE_MIN_LATENCY)
2984 min_latency = ABSOLUTE_MIN_LATENCY;
2986 if (max_latency <= 0 ||
2987 max_latency > ABSOLUTE_MAX_LATENCY)
2988 max_latency = ABSOLUTE_MAX_LATENCY;
2990 pa_assert(min_latency <= max_latency);
2992 /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2993 pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2994 max_latency == ABSOLUTE_MAX_LATENCY) ||
2995 (s->flags & PA_SINK_DYNAMIC_LATENCY));
2997 if (PA_SINK_IS_LINKED(s->state)) {
3003 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
3005 pa_sink_set_latency_range_within_thread(s, min_latency, max_latency);
3008 /* Called from main thread */
3009 void pa_sink_get_latency_range(pa_sink *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
3010 pa_sink_assert_ref(s);
3011 pa_assert_ctl_context();
3012 pa_assert(min_latency);
3013 pa_assert(max_latency);
3015 if (PA_SINK_IS_LINKED(s->state)) {
3016 pa_usec_t r[2] = { 0, 0 };
3018 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
3020 *min_latency = r[0];
3021 *max_latency = r[1];
3023 *min_latency = s->thread_info.min_latency;
3024 *max_latency = s->thread_info.max_latency;
3028 /* Called from IO thread */
3029 void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
3030 pa_sink_assert_ref(s);
3031 pa_sink_assert_io_context(s);
3033 pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
3034 pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
3035 pa_assert(min_latency <= max_latency);
3037 /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
3038 pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
3039 max_latency == ABSOLUTE_MAX_LATENCY) ||
3040 (s->flags & PA_SINK_DYNAMIC_LATENCY));
3042 if (s->thread_info.min_latency == min_latency &&
3043 s->thread_info.max_latency == max_latency)
3046 s->thread_info.min_latency = min_latency;
3047 s->thread_info.max_latency = max_latency;
3049 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3053 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3054 if (i->update_sink_latency_range)
3055 i->update_sink_latency_range(i);
3058 pa_sink_invalidate_requested_latency(s, FALSE);
3060 pa_source_set_latency_range_within_thread(s->monitor_source, min_latency, max_latency);
3063 /* Called from main thread */
3064 void pa_sink_set_fixed_latency(pa_sink *s, pa_usec_t latency) {
3065 pa_sink_assert_ref(s);
3066 pa_assert_ctl_context();
3068 if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
3069 pa_assert(latency == 0);
3073 if (latency < ABSOLUTE_MIN_LATENCY)
3074 latency = ABSOLUTE_MIN_LATENCY;
3076 if (latency > ABSOLUTE_MAX_LATENCY)
3077 latency = ABSOLUTE_MAX_LATENCY;
3079 if (PA_SINK_IS_LINKED(s->state))
3080 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
3082 s->thread_info.fixed_latency = latency;
3084 pa_source_set_fixed_latency(s->monitor_source, latency);
3087 /* Called from main thread */
3088 pa_usec_t pa_sink_get_fixed_latency(pa_sink *s) {
3091 pa_sink_assert_ref(s);
3092 pa_assert_ctl_context();
3094 if (s->flags & PA_SINK_DYNAMIC_LATENCY)
3097 if (PA_SINK_IS_LINKED(s->state))
3098 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
3100 latency = s->thread_info.fixed_latency;
3105 /* Called from IO thread */
3106 void pa_sink_set_fixed_latency_within_thread(pa_sink *s, pa_usec_t latency) {
3107 pa_sink_assert_ref(s);
3108 pa_sink_assert_io_context(s);
3110 if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
3111 pa_assert(latency == 0);
3115 pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
3116 pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
3118 if (s->thread_info.fixed_latency == latency)
3121 s->thread_info.fixed_latency = latency;
3123 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3127 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3128 if (i->update_sink_fixed_latency)
3129 i->update_sink_fixed_latency(i);
3132 pa_sink_invalidate_requested_latency(s, FALSE);
3134 pa_source_set_fixed_latency_within_thread(s->monitor_source, latency);
3137 /* Called from main context */
3138 size_t pa_sink_get_max_rewind(pa_sink *s) {
3140 pa_assert_ctl_context();
3141 pa_sink_assert_ref(s);
3143 if (!PA_SINK_IS_LINKED(s->state))
3144 return s->thread_info.max_rewind;
3146 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
3151 /* Called from main context */
3152 size_t pa_sink_get_max_request(pa_sink *s) {
3154 pa_sink_assert_ref(s);
3155 pa_assert_ctl_context();
3157 if (!PA_SINK_IS_LINKED(s->state))
3158 return s->thread_info.max_request;
3160 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REQUEST, &r, 0, NULL) == 0);
3165 /* Called from main context */
3166 int pa_sink_set_port(pa_sink *s, const char *name, pa_bool_t save) {
3167 pa_device_port *port;
3170 pa_sink_assert_ref(s);
3171 pa_assert_ctl_context();
3174 pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name);
3175 return -PA_ERR_NOTIMPLEMENTED;
3179 return -PA_ERR_NOENTITY;
3181 if (!(port = pa_hashmap_get(s->ports, name)))
3182 return -PA_ERR_NOENTITY;
3184 if (s->active_port == port) {
3185 s->save_port = s->save_port || save;
3189 if (s->flags & PA_SINK_DEFERRED_VOLUME) {
3190 struct sink_message_set_port msg = { .port = port, .ret = 0 };
3191 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
3195 ret = s->set_port(s, port);
3198 return -PA_ERR_NOENTITY;
3200 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3202 pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name);
3204 s->active_port = port;
3205 s->save_port = save;
3207 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_CHANGED], s);
3212 pa_bool_t pa_device_init_icon(pa_proplist *p, pa_bool_t is_sink) {
3213 const char *ff, *c, *t = NULL, *s = "", *profile, *bus;
3217 if (pa_proplist_contains(p, PA_PROP_DEVICE_ICON_NAME))
3220 if ((ff = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3222 if (pa_streq(ff, "microphone"))
3223 t = "audio-input-microphone";
3224 else if (pa_streq(ff, "webcam"))
3226 else if (pa_streq(ff, "computer"))
3228 else if (pa_streq(ff, "handset"))
3230 else if (pa_streq(ff, "portable"))
3231 t = "multimedia-player";
3232 else if (pa_streq(ff, "tv"))
3233 t = "video-display";
3236 * The following icons are not part of the icon naming spec,
3237 * because Rodney Dawes sucks as the maintainer of that spec.
3239 * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
3241 else if (pa_streq(ff, "headset"))
3242 t = "audio-headset";
3243 else if (pa_streq(ff, "headphone"))
3244 t = "audio-headphones";
3245 else if (pa_streq(ff, "speaker"))
3246 t = "audio-speakers";
3247 else if (pa_streq(ff, "hands-free"))
3248 t = "audio-handsfree";
3252 if ((c = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3253 if (pa_streq(c, "modem"))
3260 t = "audio-input-microphone";
3263 if ((profile = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3264 if (strstr(profile, "analog"))
3266 else if (strstr(profile, "iec958"))
3268 else if (strstr(profile, "hdmi"))
3272 bus = pa_proplist_gets(p, PA_PROP_DEVICE_BUS);
3274 pa_proplist_setf(p, PA_PROP_DEVICE_ICON_NAME, "%s%s%s%s", t, pa_strempty(s), bus ? "-" : "", pa_strempty(bus));
3279 pa_bool_t pa_device_init_description(pa_proplist *p) {
3280 const char *s, *d = NULL, *k;
3283 if (pa_proplist_contains(p, PA_PROP_DEVICE_DESCRIPTION))
3286 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3287 if (pa_streq(s, "internal"))
3288 d = _("Internal Audio");
3291 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3292 if (pa_streq(s, "modem"))
3296 d = pa_proplist_gets(p, PA_PROP_DEVICE_PRODUCT_NAME);
3301 k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
3304 pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, _("%s %s"), d, k);
3306 pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
3311 pa_bool_t pa_device_init_intended_roles(pa_proplist *p) {
3315 if (pa_proplist_contains(p, PA_PROP_DEVICE_INTENDED_ROLES))
3318 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3319 if (pa_streq(s, "handset") || pa_streq(s, "hands-free")
3320 || pa_streq(s, "headset")) {
3321 pa_proplist_sets(p, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
3328 unsigned pa_device_init_priority(pa_proplist *p) {
3330 unsigned priority = 0;
3334 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS))) {
3336 if (pa_streq(s, "sound"))
3338 else if (!pa_streq(s, "modem"))
3342 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3344 if (pa_streq(s, "internal"))
3346 else if (pa_streq(s, "speaker"))
3348 else if (pa_streq(s, "headphone"))
3352 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_BUS))) {
3354 if (pa_streq(s, "pci"))
3356 else if (pa_streq(s, "usb"))
3358 else if (pa_streq(s, "bluetooth"))
3362 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3364 if (pa_startswith(s, "analog-"))
3366 else if (pa_startswith(s, "iec958-"))
3373 PA_STATIC_FLIST_DECLARE(pa_sink_volume_change, 0, pa_xfree);
3375 /* Called from the IO thread. */
3376 static pa_sink_volume_change *pa_sink_volume_change_new(pa_sink *s) {
3377 pa_sink_volume_change *c;
3378 if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_sink_volume_change))))
3379 c = pa_xnew(pa_sink_volume_change, 1);
3381 PA_LLIST_INIT(pa_sink_volume_change, c);
3383 pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
3387 /* Called from the IO thread. */
3388 static void pa_sink_volume_change_free(pa_sink_volume_change *c) {
3390 if (pa_flist_push(PA_STATIC_FLIST_GET(pa_sink_volume_change), c) < 0)
3394 /* Called from the IO thread. */
3395 void pa_sink_volume_change_push(pa_sink *s) {
3396 pa_sink_volume_change *c = NULL;
3397 pa_sink_volume_change *nc = NULL;
3398 uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
3400 const char *direction = NULL;
3403 nc = pa_sink_volume_change_new(s);
3405 /* NOTE: There is already more different volumes in pa_sink that I can remember.
3406 * Adding one more volume for HW would get us rid of this, but I am trying
3407 * to survive with the ones we already have. */
3408 pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
3410 if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
3411 pa_log_debug("Volume not changing");
3412 pa_sink_volume_change_free(nc);
3416 nc->at = pa_sink_get_latency_within_thread(s);
3417 nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3419 if (s->thread_info.volume_changes_tail) {
3420 for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
3421 /* If volume is going up let's do it a bit late. If it is going
3422 * down let's do it a bit early. */
3423 if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
3424 if (nc->at + safety_margin > c->at) {
3425 nc->at += safety_margin;
3430 else if (nc->at - safety_margin > c->at) {
3431 nc->at -= safety_margin;
3439 if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
3440 nc->at += safety_margin;
3443 nc->at -= safety_margin;
3446 PA_LLIST_PREPEND(pa_sink_volume_change, s->thread_info.volume_changes, nc);
3449 PA_LLIST_INSERT_AFTER(pa_sink_volume_change, s->thread_info.volume_changes, c, nc);
3452 pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
3454 /* We can ignore volume events that came earlier but should happen later than this. */
3455 PA_LLIST_FOREACH(c, nc->next) {
3456 pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
3457 pa_sink_volume_change_free(c);
3460 s->thread_info.volume_changes_tail = nc;
3463 /* Called from the IO thread. */
3464 static void pa_sink_volume_change_flush(pa_sink *s) {
3465 pa_sink_volume_change *c = s->thread_info.volume_changes;
3467 s->thread_info.volume_changes = NULL;
3468 s->thread_info.volume_changes_tail = NULL;
3470 pa_sink_volume_change *next = c->next;
3471 pa_sink_volume_change_free(c);
3476 /* Called from the IO thread. */
3477 pa_bool_t pa_sink_volume_change_apply(pa_sink *s, pa_usec_t *usec_to_next) {
3479 pa_bool_t ret = FALSE;
3483 if (!s->thread_info.volume_changes || !PA_SINK_IS_LINKED(s->state)) {
3489 pa_assert(s->write_volume);
3491 now = pa_rtclock_now();
3493 while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
3494 pa_sink_volume_change *c = s->thread_info.volume_changes;
3495 PA_LLIST_REMOVE(pa_sink_volume_change, s->thread_info.volume_changes, c);
3496 pa_log_debug("Volume change to %d at %llu was written %llu usec late",
3497 pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
3499 s->thread_info.current_hw_volume = c->hw_volume;
3500 pa_sink_volume_change_free(c);
3506 if (s->thread_info.volume_changes) {
3508 *usec_to_next = s->thread_info.volume_changes->at - now;
3509 if (pa_log_ratelimit(PA_LOG_DEBUG))
3510 pa_log_debug("Next volume change in %lld usec", (long long) (s->thread_info.volume_changes->at - now));
3515 s->thread_info.volume_changes_tail = NULL;
3520 /* Called from the IO thread. */
3521 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes) {
3522 /* All the queued volume events later than current latency are shifted to happen earlier. */
3523 pa_sink_volume_change *c;
3524 pa_volume_t prev_vol = pa_cvolume_avg(&s->thread_info.current_hw_volume);
3525 pa_usec_t rewound = pa_bytes_to_usec(nbytes, &s->sample_spec);
3526 pa_usec_t limit = pa_sink_get_latency_within_thread(s);
3528 pa_log_debug("latency = %lld", (long long) limit);
3529 limit += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3531 PA_LLIST_FOREACH(c, s->thread_info.volume_changes) {
3532 pa_usec_t modified_limit = limit;
3533 if (prev_vol > pa_cvolume_avg(&c->hw_volume))
3534 modified_limit -= s->thread_info.volume_change_safety_margin;
3536 modified_limit += s->thread_info.volume_change_safety_margin;
3537 if (c->at > modified_limit) {
3539 if (c->at < modified_limit)
3540 c->at = modified_limit;
3542 prev_vol = pa_cvolume_avg(&c->hw_volume);
3544 pa_sink_volume_change_apply(s, NULL);
3547 /* Called from the main thread */
3548 /* Gets the list of formats supported by the sink. The members and idxset must
3549 * be freed by the caller. */
3550 pa_idxset* pa_sink_get_formats(pa_sink *s) {
3555 if (s->get_formats) {
3556 /* Sink supports format query, all is good */
3557 ret = s->get_formats(s);
3559 /* Sink doesn't support format query, so assume it does PCM */
3560 pa_format_info *f = pa_format_info_new();
3561 f->encoding = PA_ENCODING_PCM;
3563 ret = pa_idxset_new(NULL, NULL);
3564 pa_idxset_put(ret, f, NULL);
3570 /* Called from the main thread */
3571 /* Allows an external source to set what formats a sink supports if the sink
3572 * permits this. The function makes a copy of the formats on success. */
3573 pa_bool_t pa_sink_set_formats(pa_sink *s, pa_idxset *formats) {
3578 /* Sink supports setting formats -- let's give it a shot */
3579 return s->set_formats(s, formats);
3581 /* Sink doesn't support setting this -- bail out */
3585 /* Called from the main thread */
3586 /* Checks if the sink can accept this format */
3587 pa_bool_t pa_sink_check_format(pa_sink *s, pa_format_info *f)
3589 pa_idxset *formats = NULL;
3590 pa_bool_t ret = FALSE;
3595 formats = pa_sink_get_formats(s);
3598 pa_format_info *finfo_device;
3601 PA_IDXSET_FOREACH(finfo_device, formats, i) {
3602 if (pa_format_info_is_compatible(finfo_device, f)) {
3608 pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
3614 /* Called from the main thread */
3615 /* Calculates the intersection between formats supported by the sink and
3616 * in_formats, and returns these, in the order of the sink's formats. */
3617 pa_idxset* pa_sink_check_formats(pa_sink *s, pa_idxset *in_formats) {
3618 pa_idxset *out_formats = pa_idxset_new(NULL, NULL), *sink_formats = NULL;
3619 pa_format_info *f_sink, *f_in;
3624 if (!in_formats || pa_idxset_isempty(in_formats))
3627 sink_formats = pa_sink_get_formats(s);
3629 PA_IDXSET_FOREACH(f_sink, sink_formats, i) {
3630 PA_IDXSET_FOREACH(f_in, in_formats, j) {
3631 if (pa_format_info_is_compatible(f_sink, f_in))
3632 pa_idxset_put(out_formats, pa_format_info_copy(f_in), NULL);
3638 pa_idxset_free(sink_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);