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
30 #include <pulse/format.h>
31 #include <pulse/utf8.h>
32 #include <pulse/xmalloc.h>
33 #include <pulse/timeval.h>
34 #include <pulse/util.h>
35 #include <pulse/rtclock.h>
36 #include <pulse/internal.h>
38 #include <pulsecore/core-util.h>
39 #include <pulsecore/source-output.h>
40 #include <pulsecore/namereg.h>
41 #include <pulsecore/core-subscribe.h>
42 #include <pulsecore/log.h>
43 #include <pulsecore/mix.h>
44 #include <pulsecore/flist.h>
48 #define ABSOLUTE_MIN_LATENCY (500)
49 #define ABSOLUTE_MAX_LATENCY (10*PA_USEC_PER_SEC)
50 #define DEFAULT_FIXED_LATENCY (250*PA_USEC_PER_MSEC)
52 PA_DEFINE_PUBLIC_CLASS(pa_source, pa_msgobject);
54 struct pa_source_volume_change {
58 PA_LLIST_FIELDS(pa_source_volume_change);
61 struct source_message_set_port {
66 static void source_free(pa_object *o);
68 static void pa_source_volume_change_push(pa_source *s);
69 static void pa_source_volume_change_flush(pa_source *s);
71 pa_source_new_data* pa_source_new_data_init(pa_source_new_data *data) {
75 data->proplist = pa_proplist_new();
76 data->ports = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, (pa_free_cb_t) pa_device_port_unref);
81 void pa_source_new_data_set_name(pa_source_new_data *data, const char *name) {
85 data->name = pa_xstrdup(name);
88 void pa_source_new_data_set_sample_spec(pa_source_new_data *data, const pa_sample_spec *spec) {
91 if ((data->sample_spec_is_set = !!spec))
92 data->sample_spec = *spec;
95 void pa_source_new_data_set_channel_map(pa_source_new_data *data, const pa_channel_map *map) {
98 if ((data->channel_map_is_set = !!map))
99 data->channel_map = *map;
102 void pa_source_new_data_set_alternate_sample_rate(pa_source_new_data *data, const uint32_t alternate_sample_rate) {
105 data->alternate_sample_rate_is_set = true;
106 data->alternate_sample_rate = alternate_sample_rate;
109 void pa_source_new_data_set_volume(pa_source_new_data *data, const pa_cvolume *volume) {
112 if ((data->volume_is_set = !!volume))
113 data->volume = *volume;
116 void pa_source_new_data_set_muted(pa_source_new_data *data, bool mute) {
119 data->muted_is_set = true;
120 data->muted = !!mute;
123 void pa_source_new_data_set_port(pa_source_new_data *data, const char *port) {
126 pa_xfree(data->active_port);
127 data->active_port = pa_xstrdup(port);
130 void pa_source_new_data_done(pa_source_new_data *data) {
133 pa_proplist_free(data->proplist);
136 pa_hashmap_free(data->ports);
138 pa_xfree(data->name);
139 pa_xfree(data->active_port);
142 /* Called from main context */
143 static void reset_callbacks(pa_source *s) {
147 s->get_volume = NULL;
148 s->set_volume = NULL;
149 s->write_volume = NULL;
152 s->update_requested_latency = NULL;
154 s->get_formats = NULL;
155 s->update_rate = NULL;
158 /* Called from main context */
159 pa_source* pa_source_new(
161 pa_source_new_data *data,
162 pa_source_flags_t flags) {
166 char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
171 pa_assert(data->name);
172 pa_assert_ctl_context();
174 s = pa_msgobject_new(pa_source);
176 if (!(name = pa_namereg_register(core, data->name, PA_NAMEREG_SOURCE, s, data->namereg_fail))) {
177 pa_log_debug("Failed to register name %s.", data->name);
182 pa_source_new_data_set_name(data, name);
184 if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_NEW], data) < 0) {
186 pa_namereg_unregister(core, name);
190 /* FIXME, need to free s here on failure */
192 pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver));
193 pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]);
195 pa_return_null_if_fail(data->sample_spec_is_set && pa_sample_spec_valid(&data->sample_spec));
197 if (!data->channel_map_is_set)
198 pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
200 pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
201 pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
203 /* FIXME: There should probably be a general function for checking whether
204 * the source volume is allowed to be set, like there is for source outputs. */
205 pa_assert(!data->volume_is_set || !(flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
207 if (!data->volume_is_set) {
208 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
209 data->save_volume = false;
212 pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
213 pa_return_null_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec));
215 if (!data->muted_is_set)
219 pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
221 pa_device_init_description(data->proplist);
222 pa_device_init_icon(data->proplist, false);
223 pa_device_init_intended_roles(data->proplist);
225 if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_FIXATE], data) < 0) {
227 pa_namereg_unregister(core, name);
231 s->parent.parent.free = source_free;
232 s->parent.process_msg = pa_source_process_msg;
235 s->state = PA_SOURCE_INIT;
238 s->suspend_cause = data->suspend_cause;
239 pa_source_set_mixer_dirty(s, false);
240 s->name = pa_xstrdup(name);
241 s->proplist = pa_proplist_copy(data->proplist);
242 s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
243 s->module = data->module;
244 s->card = data->card;
246 s->priority = pa_device_init_priority(s->proplist);
248 s->sample_spec = data->sample_spec;
249 s->channel_map = data->channel_map;
250 s->default_sample_rate = s->sample_spec.rate;
252 if (data->alternate_sample_rate_is_set)
253 s->alternate_sample_rate = data->alternate_sample_rate;
255 s->alternate_sample_rate = s->core->alternate_sample_rate;
257 if (s->sample_spec.rate == s->alternate_sample_rate) {
258 pa_log_warn("Default and alternate sample rates are the same.");
259 s->alternate_sample_rate = 0;
262 s->outputs = pa_idxset_new(NULL, NULL);
264 s->monitor_of = NULL;
265 s->output_from_master = NULL;
267 s->reference_volume = s->real_volume = data->volume;
268 pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
269 s->base_volume = PA_VOLUME_NORM;
270 s->n_volume_steps = PA_VOLUME_NORM+1;
271 s->muted = data->muted;
272 s->refresh_volume = s->refresh_muted = false;
279 /* As a minor optimization we just steal the list instead of
281 s->ports = data->ports;
284 s->active_port = NULL;
285 s->save_port = false;
287 if (data->active_port)
288 if ((s->active_port = pa_hashmap_get(s->ports, data->active_port)))
289 s->save_port = data->save_port;
291 if (!s->active_port) {
295 PA_HASHMAP_FOREACH(p, s->ports, state)
296 if (!s->active_port || p->priority > s->active_port->priority)
301 s->latency_offset = s->active_port->latency_offset;
303 s->latency_offset = 0;
305 s->save_volume = data->save_volume;
306 s->save_muted = data->save_muted;
308 pa_silence_memchunk_get(
309 &core->silence_cache,
315 s->thread_info.rtpoll = NULL;
316 s->thread_info.outputs = pa_hashmap_new_full(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func, NULL,
317 (pa_free_cb_t) pa_source_output_unref);
318 s->thread_info.soft_volume = s->soft_volume;
319 s->thread_info.soft_muted = s->muted;
320 s->thread_info.state = s->state;
321 s->thread_info.max_rewind = 0;
322 s->thread_info.requested_latency_valid = false;
323 s->thread_info.requested_latency = 0;
324 s->thread_info.min_latency = ABSOLUTE_MIN_LATENCY;
325 s->thread_info.max_latency = ABSOLUTE_MAX_LATENCY;
326 s->thread_info.fixed_latency = flags & PA_SOURCE_DYNAMIC_LATENCY ? 0 : DEFAULT_FIXED_LATENCY;
328 PA_LLIST_HEAD_INIT(pa_source_volume_change, s->thread_info.volume_changes);
329 s->thread_info.volume_changes_tail = NULL;
330 pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
331 s->thread_info.volume_change_safety_margin = core->deferred_volume_safety_margin_usec;
332 s->thread_info.volume_change_extra_delay = core->deferred_volume_extra_delay_usec;
333 s->thread_info.latency_offset = s->latency_offset;
335 /* FIXME: This should probably be moved to pa_source_put() */
336 pa_assert_se(pa_idxset_put(core->sources, s, &s->index) >= 0);
339 pa_assert_se(pa_idxset_put(s->card->sources, s, NULL) >= 0);
341 pt = pa_proplist_to_string_sep(s->proplist, "\n ");
342 pa_log_info("Created source %u \"%s\" with sample spec %s and channel map %s\n %s",
345 pa_sample_spec_snprint(st, sizeof(st), &s->sample_spec),
346 pa_channel_map_snprint(cm, sizeof(cm), &s->channel_map),
353 /* Called from main context */
354 static int source_set_state(pa_source *s, pa_source_state_t state) {
357 pa_source_state_t original_state;
360 pa_assert_ctl_context();
362 if (s->state == state)
365 original_state = s->state;
368 (original_state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(state)) ||
369 (PA_SOURCE_IS_OPENED(original_state) && state == PA_SOURCE_SUSPENDED);
372 if ((ret = s->set_state(s, state)) < 0)
376 if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_STATE, PA_UINT_TO_PTR(state), 0, NULL)) < 0) {
379 s->set_state(s, original_state);
386 if (state != PA_SOURCE_UNLINKED) { /* if we enter UNLINKED state pa_source_unlink() will fire the appropriate events */
387 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_STATE_CHANGED], s);
388 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
391 if (suspend_change) {
395 /* We're suspending or resuming, tell everyone about it */
397 PA_IDXSET_FOREACH(o, s->outputs, idx)
398 if (s->state == PA_SOURCE_SUSPENDED &&
399 (o->flags & PA_SOURCE_OUTPUT_KILL_ON_SUSPEND))
400 pa_source_output_kill(o);
402 o->suspend(o, state == PA_SOURCE_SUSPENDED);
408 void pa_source_set_get_volume_callback(pa_source *s, pa_source_cb_t cb) {
414 void pa_source_set_set_volume_callback(pa_source *s, pa_source_cb_t cb) {
415 pa_source_flags_t flags;
418 pa_assert(!s->write_volume || cb);
422 /* Save the current flags so we can tell if they've changed */
426 /* The source implementor is responsible for setting decibel volume support */
427 s->flags |= PA_SOURCE_HW_VOLUME_CTRL;
429 s->flags &= ~PA_SOURCE_HW_VOLUME_CTRL;
430 /* See note below in pa_source_put() about volume sharing and decibel volumes */
431 pa_source_enable_decibel_volume(s, !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
434 /* If the flags have changed after init, let any clients know via a change event */
435 if (s->state != PA_SOURCE_INIT && flags != s->flags)
436 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
439 void pa_source_set_write_volume_callback(pa_source *s, pa_source_cb_t cb) {
440 pa_source_flags_t flags;
443 pa_assert(!cb || s->set_volume);
445 s->write_volume = cb;
447 /* Save the current flags so we can tell if they've changed */
451 s->flags |= PA_SOURCE_DEFERRED_VOLUME;
453 s->flags &= ~PA_SOURCE_DEFERRED_VOLUME;
455 /* If the flags have changed after init, let any clients know via a change event */
456 if (s->state != PA_SOURCE_INIT && flags != s->flags)
457 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
460 void pa_source_set_get_mute_callback(pa_source *s, pa_source_cb_t cb) {
466 void pa_source_set_set_mute_callback(pa_source *s, pa_source_cb_t cb) {
467 pa_source_flags_t flags;
473 /* Save the current flags so we can tell if they've changed */
477 s->flags |= PA_SOURCE_HW_MUTE_CTRL;
479 s->flags &= ~PA_SOURCE_HW_MUTE_CTRL;
481 /* If the flags have changed after init, let any clients know via a change event */
482 if (s->state != PA_SOURCE_INIT && flags != s->flags)
483 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
486 static void enable_flat_volume(pa_source *s, bool enable) {
487 pa_source_flags_t flags;
491 /* Always follow the overall user preference here */
492 enable = enable && s->core->flat_volumes;
494 /* Save the current flags so we can tell if they've changed */
498 s->flags |= PA_SOURCE_FLAT_VOLUME;
500 s->flags &= ~PA_SOURCE_FLAT_VOLUME;
502 /* If the flags have changed after init, let any clients know via a change event */
503 if (s->state != PA_SOURCE_INIT && flags != s->flags)
504 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
507 void pa_source_enable_decibel_volume(pa_source *s, bool enable) {
508 pa_source_flags_t flags;
512 /* Save the current flags so we can tell if they've changed */
516 s->flags |= PA_SOURCE_DECIBEL_VOLUME;
517 enable_flat_volume(s, true);
519 s->flags &= ~PA_SOURCE_DECIBEL_VOLUME;
520 enable_flat_volume(s, false);
523 /* If the flags have changed after init, let any clients know via a change event */
524 if (s->state != PA_SOURCE_INIT && flags != s->flags)
525 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
528 /* Called from main context */
529 void pa_source_put(pa_source *s) {
530 pa_source_assert_ref(s);
531 pa_assert_ctl_context();
533 pa_assert(s->state == PA_SOURCE_INIT);
534 pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) || s->output_from_master);
536 /* The following fields must be initialized properly when calling _put() */
537 pa_assert(s->asyncmsgq);
538 pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency);
540 /* Generally, flags should be initialized via pa_source_new(). As a
541 * special exception we allow some volume related flags to be set
542 * between _new() and _put() by the callback setter functions above.
544 * Thus we implement a couple safeguards here which ensure the above
545 * setters were used (or at least the implementor made manual changes
546 * in a compatible way).
548 * Note: All of these flags set here can change over the life time
550 pa_assert(!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) || s->set_volume);
551 pa_assert(!(s->flags & PA_SOURCE_DEFERRED_VOLUME) || s->write_volume);
552 pa_assert(!(s->flags & PA_SOURCE_HW_MUTE_CTRL) || s->set_mute);
554 /* XXX: Currently decibel volume is disabled for all sources that use volume
555 * sharing. When the master source supports decibel volume, it would be good
556 * to have the flag also in the filter source, but currently we don't do that
557 * so that the flags of the filter source never change when it's moved from
558 * a master source to another. One solution for this problem would be to
559 * remove user-visible volume altogether from filter sources when volume
560 * sharing is used, but the current approach was easier to implement... */
561 /* We always support decibel volumes in software, otherwise we leave it to
562 * the source implementor to set this flag as needed.
564 * Note: This flag can also change over the life time of the source. */
565 if (!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) && !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
566 pa_source_enable_decibel_volume(s, true);
568 /* If the source implementor support DB volumes by itself, we should always
569 * try and enable flat volumes too */
570 if ((s->flags & PA_SOURCE_DECIBEL_VOLUME))
571 enable_flat_volume(s, true);
573 if (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) {
574 pa_source *root_source = pa_source_get_master(s);
576 pa_assert(PA_LIKELY(root_source));
578 s->reference_volume = root_source->reference_volume;
579 pa_cvolume_remap(&s->reference_volume, &root_source->channel_map, &s->channel_map);
581 s->real_volume = root_source->real_volume;
582 pa_cvolume_remap(&s->real_volume, &root_source->channel_map, &s->channel_map);
584 /* We assume that if the sink implementor changed the default
585 * volume he did so in real_volume, because that is the usual
586 * place where he is supposed to place his changes. */
587 s->reference_volume = s->real_volume;
589 s->thread_info.soft_volume = s->soft_volume;
590 s->thread_info.soft_muted = s->muted;
591 pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
593 pa_assert((s->flags & PA_SOURCE_HW_VOLUME_CTRL)
594 || (s->base_volume == PA_VOLUME_NORM
595 && ((s->flags & PA_SOURCE_DECIBEL_VOLUME || (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)))));
596 pa_assert(!(s->flags & PA_SOURCE_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1);
597 pa_assert(!(s->flags & PA_SOURCE_DYNAMIC_LATENCY) == (s->thread_info.fixed_latency != 0));
599 if (s->suspend_cause)
600 pa_assert_se(source_set_state(s, PA_SOURCE_SUSPENDED) == 0);
602 pa_assert_se(source_set_state(s, PA_SOURCE_IDLE) == 0);
604 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_NEW, s->index);
605 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PUT], s);
608 /* Called from main context */
609 void pa_source_unlink(pa_source *s) {
611 pa_source_output *o, *j = NULL;
614 pa_assert_ctl_context();
616 /* See pa_sink_unlink() for a couple of comments how this function
619 linked = PA_SOURCE_IS_LINKED(s->state);
622 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], s);
624 if (s->state != PA_SOURCE_UNLINKED)
625 pa_namereg_unregister(s->core, s->name);
626 pa_idxset_remove_by_data(s->core->sources, s, NULL);
629 pa_idxset_remove_by_data(s->card->sources, s, NULL);
631 while ((o = pa_idxset_first(s->outputs, NULL))) {
633 pa_source_output_kill(o);
638 source_set_state(s, PA_SOURCE_UNLINKED);
640 s->state = PA_SOURCE_UNLINKED;
645 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
646 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK_POST], s);
650 /* Called from main context */
651 static void source_free(pa_object *o) {
652 pa_source *s = PA_SOURCE(o);
655 pa_assert_ctl_context();
656 pa_assert(pa_source_refcnt(s) == 0);
658 if (PA_SOURCE_IS_LINKED(s->state))
661 pa_log_info("Freeing source %u \"%s\"", s->index, s->name);
663 pa_idxset_free(s->outputs, NULL);
664 pa_hashmap_free(s->thread_info.outputs);
666 if (s->silence.memblock)
667 pa_memblock_unref(s->silence.memblock);
673 pa_proplist_free(s->proplist);
676 pa_hashmap_free(s->ports);
681 /* Called from main context, and not while the IO thread is active, please */
682 void pa_source_set_asyncmsgq(pa_source *s, pa_asyncmsgq *q) {
683 pa_source_assert_ref(s);
684 pa_assert_ctl_context();
689 /* Called from main context, and not while the IO thread is active, please */
690 void pa_source_update_flags(pa_source *s, pa_source_flags_t mask, pa_source_flags_t value) {
691 pa_source_flags_t old_flags;
692 pa_source_output *output;
695 pa_source_assert_ref(s);
696 pa_assert_ctl_context();
698 /* For now, allow only a minimal set of flags to be changed. */
699 pa_assert((mask & ~(PA_SOURCE_DYNAMIC_LATENCY|PA_SOURCE_LATENCY)) == 0);
701 old_flags = s->flags;
702 s->flags = (s->flags & ~mask) | (value & mask);
704 if (s->flags == old_flags)
707 if ((s->flags & PA_SOURCE_LATENCY) != (old_flags & PA_SOURCE_LATENCY))
708 pa_log_debug("Source %s: LATENCY flag %s.", s->name, (s->flags & PA_SOURCE_LATENCY) ? "enabled" : "disabled");
710 if ((s->flags & PA_SOURCE_DYNAMIC_LATENCY) != (old_flags & PA_SOURCE_DYNAMIC_LATENCY))
711 pa_log_debug("Source %s: DYNAMIC_LATENCY flag %s.",
712 s->name, (s->flags & PA_SOURCE_DYNAMIC_LATENCY) ? "enabled" : "disabled");
714 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
715 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_FLAGS_CHANGED], s);
717 PA_IDXSET_FOREACH(output, s->outputs, idx) {
718 if (output->destination_source)
719 pa_source_update_flags(output->destination_source, mask, value);
723 /* Called from IO context, or before _put() from main context */
724 void pa_source_set_rtpoll(pa_source *s, pa_rtpoll *p) {
725 pa_source_assert_ref(s);
726 pa_source_assert_io_context(s);
728 s->thread_info.rtpoll = p;
731 /* Called from main context */
732 int pa_source_update_status(pa_source*s) {
733 pa_source_assert_ref(s);
734 pa_assert_ctl_context();
735 pa_assert(PA_SOURCE_IS_LINKED(s->state));
737 if (s->state == PA_SOURCE_SUSPENDED)
740 return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
743 /* Called from any context - must be threadsafe */
744 void pa_source_set_mixer_dirty(pa_source *s, bool is_dirty) {
745 pa_atomic_store(&s->mixer_dirty, is_dirty ? 1 : 0);
748 /* Called from main context */
749 int pa_source_suspend(pa_source *s, bool suspend, pa_suspend_cause_t cause) {
750 pa_source_assert_ref(s);
751 pa_assert_ctl_context();
752 pa_assert(PA_SOURCE_IS_LINKED(s->state));
753 pa_assert(cause != 0);
755 if (s->monitor_of && cause != PA_SUSPEND_PASSTHROUGH)
756 return -PA_ERR_NOTSUPPORTED;
759 s->suspend_cause |= cause;
761 s->suspend_cause &= ~cause;
763 if (!(s->suspend_cause & PA_SUSPEND_SESSION) && (pa_atomic_load(&s->mixer_dirty) != 0)) {
764 /* This might look racy but isn't: If somebody sets mixer_dirty exactly here,
765 it'll be handled just fine. */
766 pa_source_set_mixer_dirty(s, false);
767 pa_log_debug("Mixer is now accessible. Updating alsa mixer settings.");
768 if (s->active_port && s->set_port) {
769 if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
770 struct source_message_set_port msg = { .port = s->active_port, .ret = 0 };
771 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
774 s->set_port(s, s->active_port);
784 if ((pa_source_get_state(s) == PA_SOURCE_SUSPENDED) == !!s->suspend_cause)
787 pa_log_debug("Suspend cause of source %s is 0x%04x, %s", s->name, s->suspend_cause, s->suspend_cause ? "suspending" : "resuming");
789 if (s->suspend_cause)
790 return source_set_state(s, PA_SOURCE_SUSPENDED);
792 return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
795 /* Called from main context */
796 int pa_source_sync_suspend(pa_source *s) {
797 pa_sink_state_t state;
799 pa_source_assert_ref(s);
800 pa_assert_ctl_context();
801 pa_assert(PA_SOURCE_IS_LINKED(s->state));
802 pa_assert(s->monitor_of);
804 state = pa_sink_get_state(s->monitor_of);
806 if (state == PA_SINK_SUSPENDED)
807 return source_set_state(s, PA_SOURCE_SUSPENDED);
809 pa_assert(PA_SINK_IS_OPENED(state));
811 return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
814 /* Called from main context */
815 pa_queue *pa_source_move_all_start(pa_source *s, pa_queue *q) {
816 pa_source_output *o, *n;
819 pa_source_assert_ref(s);
820 pa_assert_ctl_context();
821 pa_assert(PA_SOURCE_IS_LINKED(s->state));
826 for (o = PA_SOURCE_OUTPUT(pa_idxset_first(s->outputs, &idx)); o; o = n) {
827 n = PA_SOURCE_OUTPUT(pa_idxset_next(s->outputs, &idx));
829 pa_source_output_ref(o);
831 if (pa_source_output_start_move(o) >= 0)
834 pa_source_output_unref(o);
840 /* Called from main context */
841 void pa_source_move_all_finish(pa_source *s, pa_queue *q, bool save) {
844 pa_source_assert_ref(s);
845 pa_assert_ctl_context();
846 pa_assert(PA_SOURCE_IS_LINKED(s->state));
849 while ((o = PA_SOURCE_OUTPUT(pa_queue_pop(q)))) {
850 if (pa_source_output_finish_move(o, s, save) < 0)
851 pa_source_output_fail_move(o);
853 pa_source_output_unref(o);
856 pa_queue_free(q, NULL);
859 /* Called from main context */
860 void pa_source_move_all_fail(pa_queue *q) {
863 pa_assert_ctl_context();
866 while ((o = PA_SOURCE_OUTPUT(pa_queue_pop(q)))) {
867 pa_source_output_fail_move(o);
868 pa_source_output_unref(o);
871 pa_queue_free(q, NULL);
874 /* Called from IO thread context */
875 void pa_source_process_rewind(pa_source *s, size_t nbytes) {
879 pa_source_assert_ref(s);
880 pa_source_assert_io_context(s);
881 pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
886 if (s->thread_info.state == PA_SOURCE_SUSPENDED)
889 pa_log_debug("Processing rewind...");
891 PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state) {
892 pa_source_output_assert_ref(o);
893 pa_source_output_process_rewind(o, nbytes);
897 /* Called from IO thread context */
898 void pa_source_post(pa_source*s, const pa_memchunk *chunk) {
902 pa_source_assert_ref(s);
903 pa_source_assert_io_context(s);
904 pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
907 if (s->thread_info.state == PA_SOURCE_SUSPENDED)
910 if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&s->thread_info.soft_volume)) {
911 pa_memchunk vchunk = *chunk;
913 pa_memblock_ref(vchunk.memblock);
914 pa_memchunk_make_writable(&vchunk, 0);
916 if (s->thread_info.soft_muted || pa_cvolume_is_muted(&s->thread_info.soft_volume))
917 pa_silence_memchunk(&vchunk, &s->sample_spec);
919 pa_volume_memchunk(&vchunk, &s->sample_spec, &s->thread_info.soft_volume);
921 while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL))) {
922 pa_source_output_assert_ref(o);
924 if (!o->thread_info.direct_on_input)
925 pa_source_output_push(o, &vchunk);
928 pa_memblock_unref(vchunk.memblock);
931 while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL))) {
932 pa_source_output_assert_ref(o);
934 if (!o->thread_info.direct_on_input)
935 pa_source_output_push(o, chunk);
940 /* Called from IO thread context */
941 void pa_source_post_direct(pa_source*s, pa_source_output *o, const pa_memchunk *chunk) {
942 pa_source_assert_ref(s);
943 pa_source_assert_io_context(s);
944 pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
945 pa_source_output_assert_ref(o);
946 pa_assert(o->thread_info.direct_on_input);
949 if (s->thread_info.state == PA_SOURCE_SUSPENDED)
952 if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&s->thread_info.soft_volume)) {
953 pa_memchunk vchunk = *chunk;
955 pa_memblock_ref(vchunk.memblock);
956 pa_memchunk_make_writable(&vchunk, 0);
958 if (s->thread_info.soft_muted || pa_cvolume_is_muted(&s->thread_info.soft_volume))
959 pa_silence_memchunk(&vchunk, &s->sample_spec);
961 pa_volume_memchunk(&vchunk, &s->sample_spec, &s->thread_info.soft_volume);
963 pa_source_output_push(o, &vchunk);
965 pa_memblock_unref(vchunk.memblock);
967 pa_source_output_push(o, chunk);
970 /* Called from main thread */
971 int pa_source_update_rate(pa_source *s, uint32_t rate, bool passthrough) {
973 uint32_t desired_rate = rate;
974 uint32_t default_rate = s->default_sample_rate;
975 uint32_t alternate_rate = s->alternate_sample_rate;
976 bool use_alternate = false;
978 if (rate == s->sample_spec.rate)
981 if (!s->update_rate && !s->monitor_of)
984 if (PA_UNLIKELY(default_rate == alternate_rate && !passthrough)) {
985 pa_log_debug("Default and alternate sample rates are the same.");
989 if (PA_SOURCE_IS_RUNNING(s->state)) {
990 pa_log_info("Cannot update rate, SOURCE_IS_RUNNING, will keep using %u Hz",
991 s->sample_spec.rate);
996 if (PA_SINK_IS_RUNNING(s->monitor_of->state)) {
997 pa_log_info("Cannot update rate, this is a monitor source and the sink is running.");
1002 if (PA_UNLIKELY (desired_rate < 8000 ||
1003 desired_rate > PA_RATE_MAX))
1007 pa_assert((default_rate % 4000 == 0) || (default_rate % 11025 == 0));
1008 pa_assert((alternate_rate % 4000 == 0) || (alternate_rate % 11025 == 0));
1010 if (default_rate % 11025 == 0) {
1011 if ((alternate_rate % 4000 == 0) && (desired_rate % 4000 == 0))
1014 /* default is 4000 multiple */
1015 if ((alternate_rate % 11025 == 0) && (desired_rate % 11025 == 0))
1020 desired_rate = alternate_rate;
1022 desired_rate = default_rate;
1024 desired_rate = rate; /* use stream sampling rate, discard default/alternate settings */
1027 if (desired_rate == s->sample_spec.rate)
1030 if (!passthrough && pa_source_used_by(s) > 0)
1033 pa_log_debug("Suspending source %s due to changing the sample rate.", s->name);
1034 pa_source_suspend(s, true, PA_SUSPEND_INTERNAL);
1037 ret = s->update_rate(s, desired_rate);
1039 /* This is a monitor source. */
1041 /* XXX: This code is written with non-passthrough streams in mind. I
1042 * have no idea whether the behaviour with passthrough streams is
1045 uint32_t old_rate = s->sample_spec.rate;
1047 s->sample_spec.rate = desired_rate;
1048 ret = pa_sink_update_rate(s->monitor_of, desired_rate, false);
1051 /* Changing the sink rate failed, roll back the old rate for
1052 * the monitor source. Why did we set the source rate before
1053 * calling pa_sink_update_rate(), you may ask. The reason is
1054 * that pa_sink_update_rate() tries to update the monitor
1055 * source rate, but we are already in the process of updating
1056 * the monitor source rate, so there's a risk of entering an
1057 * infinite loop. Setting the source rate before calling
1058 * pa_sink_update_rate() makes the rate == s->sample_spec.rate
1059 * check in the beginning of this function return early, so we
1061 s->sample_spec.rate = old_rate;
1069 pa_source_output *o;
1071 PA_IDXSET_FOREACH(o, s->outputs, idx) {
1072 if (o->state == PA_SOURCE_OUTPUT_CORKED)
1073 pa_source_output_update_rate(o);
1076 pa_log_info("Changed sampling rate successfully");
1079 pa_source_suspend(s, false, PA_SUSPEND_INTERNAL);
1084 /* Called from main thread */
1085 pa_usec_t pa_source_get_latency(pa_source *s) {
1088 pa_source_assert_ref(s);
1089 pa_assert_ctl_context();
1090 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1092 if (s->state == PA_SOURCE_SUSPENDED)
1095 if (!(s->flags & PA_SOURCE_LATENCY))
1098 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
1100 /* usec is unsigned, so check that the offset can be added to usec without
1102 if (-s->latency_offset <= (int64_t) usec)
1103 usec += s->latency_offset;
1110 /* Called from IO thread */
1111 pa_usec_t pa_source_get_latency_within_thread(pa_source *s) {
1115 pa_source_assert_ref(s);
1116 pa_source_assert_io_context(s);
1117 pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
1119 /* The returned value is supposed to be in the time domain of the sound card! */
1121 if (s->thread_info.state == PA_SOURCE_SUSPENDED)
1124 if (!(s->flags & PA_SOURCE_LATENCY))
1127 o = PA_MSGOBJECT(s);
1129 /* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
1131 if (o->process_msg(o, PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1134 /* usec is unsigned, so check that the offset can be added to usec without
1136 if (-s->thread_info.latency_offset <= (int64_t) usec)
1137 usec += s->thread_info.latency_offset;
1144 /* Called from the main thread (and also from the IO thread while the main
1145 * thread is waiting).
1147 * When a source uses volume sharing, it never has the PA_SOURCE_FLAT_VOLUME flag
1148 * set. Instead, flat volume mode is detected by checking whether the root source
1149 * has the flag set. */
1150 bool pa_source_flat_volume_enabled(pa_source *s) {
1151 pa_source_assert_ref(s);
1153 s = pa_source_get_master(s);
1156 return (s->flags & PA_SOURCE_FLAT_VOLUME);
1161 /* Called from the main thread (and also from the IO thread while the main
1162 * thread is waiting). */
1163 pa_source *pa_source_get_master(pa_source *s) {
1164 pa_source_assert_ref(s);
1166 while (s && (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1167 if (PA_UNLIKELY(!s->output_from_master))
1170 s = s->output_from_master->source;
1176 /* Called from main context */
1177 bool pa_source_is_passthrough(pa_source *s) {
1179 pa_source_assert_ref(s);
1181 /* NB Currently only monitor sources support passthrough mode */
1182 return (s->monitor_of && pa_sink_is_passthrough(s->monitor_of));
1185 /* Called from main context */
1186 void pa_source_enter_passthrough(pa_source *s) {
1189 /* set the volume to NORM */
1190 s->saved_volume = *pa_source_get_volume(s, true);
1191 s->saved_save_volume = s->save_volume;
1193 pa_cvolume_set(&volume, s->sample_spec.channels, PA_MIN(s->base_volume, PA_VOLUME_NORM));
1194 pa_source_set_volume(s, &volume, true, false);
1197 /* Called from main context */
1198 void pa_source_leave_passthrough(pa_source *s) {
1199 /* Restore source volume to what it was before we entered passthrough mode */
1200 pa_source_set_volume(s, &s->saved_volume, true, s->saved_save_volume);
1202 pa_cvolume_init(&s->saved_volume);
1203 s->saved_save_volume = false;
1206 /* Called from main context. */
1207 static void compute_reference_ratio(pa_source_output *o) {
1209 pa_cvolume remapped;
1212 pa_assert(pa_source_flat_volume_enabled(o->source));
1215 * Calculates the reference ratio from the source's reference
1216 * volume. This basically calculates:
1218 * o->reference_ratio = o->volume / o->source->reference_volume
1221 remapped = o->source->reference_volume;
1222 pa_cvolume_remap(&remapped, &o->source->channel_map, &o->channel_map);
1224 o->reference_ratio.channels = o->sample_spec.channels;
1226 for (c = 0; c < o->sample_spec.channels; c++) {
1228 /* We don't update when the source volume is 0 anyway */
1229 if (remapped.values[c] <= PA_VOLUME_MUTED)
1232 /* Don't update the reference ratio unless necessary */
1233 if (pa_sw_volume_multiply(
1234 o->reference_ratio.values[c],
1235 remapped.values[c]) == o->volume.values[c])
1238 o->reference_ratio.values[c] = pa_sw_volume_divide(
1239 o->volume.values[c],
1240 remapped.values[c]);
1244 /* Called from main context. Only called for the root source in volume sharing
1245 * cases, except for internal recursive calls. */
1246 static void compute_reference_ratios(pa_source *s) {
1248 pa_source_output *o;
1250 pa_source_assert_ref(s);
1251 pa_assert_ctl_context();
1252 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1253 pa_assert(pa_source_flat_volume_enabled(s));
1255 PA_IDXSET_FOREACH(o, s->outputs, idx) {
1256 compute_reference_ratio(o);
1258 if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1259 compute_reference_ratios(o->destination_source);
1263 /* Called from main context. Only called for the root source in volume sharing
1264 * cases, except for internal recursive calls. */
1265 static void compute_real_ratios(pa_source *s) {
1266 pa_source_output *o;
1269 pa_source_assert_ref(s);
1270 pa_assert_ctl_context();
1271 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1272 pa_assert(pa_source_flat_volume_enabled(s));
1274 PA_IDXSET_FOREACH(o, s->outputs, idx) {
1276 pa_cvolume remapped;
1278 if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1279 /* The origin source uses volume sharing, so this input's real ratio
1280 * is handled as a special case - the real ratio must be 0 dB, and
1281 * as a result i->soft_volume must equal i->volume_factor. */
1282 pa_cvolume_reset(&o->real_ratio, o->real_ratio.channels);
1283 o->soft_volume = o->volume_factor;
1285 compute_real_ratios(o->destination_source);
1291 * This basically calculates:
1293 * i->real_ratio := i->volume / s->real_volume
1294 * i->soft_volume := i->real_ratio * i->volume_factor
1297 remapped = s->real_volume;
1298 pa_cvolume_remap(&remapped, &s->channel_map, &o->channel_map);
1300 o->real_ratio.channels = o->sample_spec.channels;
1301 o->soft_volume.channels = o->sample_spec.channels;
1303 for (c = 0; c < o->sample_spec.channels; c++) {
1305 if (remapped.values[c] <= PA_VOLUME_MUTED) {
1306 /* We leave o->real_ratio untouched */
1307 o->soft_volume.values[c] = PA_VOLUME_MUTED;
1311 /* Don't lose accuracy unless necessary */
1312 if (pa_sw_volume_multiply(
1313 o->real_ratio.values[c],
1314 remapped.values[c]) != o->volume.values[c])
1316 o->real_ratio.values[c] = pa_sw_volume_divide(
1317 o->volume.values[c],
1318 remapped.values[c]);
1320 o->soft_volume.values[c] = pa_sw_volume_multiply(
1321 o->real_ratio.values[c],
1322 o->volume_factor.values[c]);
1325 /* We don't copy the soft_volume to the thread_info data
1326 * here. That must be done by the caller */
1330 static pa_cvolume *cvolume_remap_minimal_impact(
1332 const pa_cvolume *template,
1333 const pa_channel_map *from,
1334 const pa_channel_map *to) {
1339 pa_assert(template);
1342 pa_assert(pa_cvolume_compatible_with_channel_map(v, from));
1343 pa_assert(pa_cvolume_compatible_with_channel_map(template, to));
1345 /* Much like pa_cvolume_remap(), but tries to minimize impact when
1346 * mapping from source output to source volumes:
1348 * If template is a possible remapping from v it is used instead
1349 * of remapping anew.
1351 * If the channel maps don't match we set an all-channel volume on
1352 * the source to ensure that changing a volume on one stream has no
1353 * effect that cannot be compensated for in another stream that
1354 * does not have the same channel map as the source. */
1356 if (pa_channel_map_equal(from, to))
1360 if (pa_cvolume_equal(pa_cvolume_remap(&t, to, from), v)) {
1365 pa_cvolume_set(v, to->channels, pa_cvolume_max(v));
1369 /* Called from main thread. Only called for the root source in volume sharing
1370 * cases, except for internal recursive calls. */
1371 static void get_maximum_output_volume(pa_source *s, pa_cvolume *max_volume, const pa_channel_map *channel_map) {
1372 pa_source_output *o;
1375 pa_source_assert_ref(s);
1376 pa_assert(max_volume);
1377 pa_assert(channel_map);
1378 pa_assert(pa_source_flat_volume_enabled(s));
1380 PA_IDXSET_FOREACH(o, s->outputs, idx) {
1381 pa_cvolume remapped;
1383 if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1384 get_maximum_output_volume(o->destination_source, max_volume, channel_map);
1386 /* Ignore this output. The origin source uses volume sharing, so this
1387 * output's volume will be set to be equal to the root source's real
1388 * volume. Obviously this output's current volume must not then
1389 * affect what the root source's real volume will be. */
1393 remapped = o->volume;
1394 cvolume_remap_minimal_impact(&remapped, max_volume, &o->channel_map, channel_map);
1395 pa_cvolume_merge(max_volume, max_volume, &remapped);
1399 /* Called from main thread. Only called for the root source in volume sharing
1400 * cases, except for internal recursive calls. */
1401 static bool has_outputs(pa_source *s) {
1402 pa_source_output *o;
1405 pa_source_assert_ref(s);
1407 PA_IDXSET_FOREACH(o, s->outputs, idx) {
1408 if (!o->destination_source || !(o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) || has_outputs(o->destination_source))
1415 /* Called from main thread. Only called for the root source in volume sharing
1416 * cases, except for internal recursive calls. */
1417 static void update_real_volume(pa_source *s, const pa_cvolume *new_volume, pa_channel_map *channel_map) {
1418 pa_source_output *o;
1421 pa_source_assert_ref(s);
1422 pa_assert(new_volume);
1423 pa_assert(channel_map);
1425 s->real_volume = *new_volume;
1426 pa_cvolume_remap(&s->real_volume, channel_map, &s->channel_map);
1428 PA_IDXSET_FOREACH(o, s->outputs, idx) {
1429 if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1430 if (pa_source_flat_volume_enabled(s)) {
1431 pa_cvolume old_volume = o->volume;
1433 /* Follow the root source's real volume. */
1434 o->volume = *new_volume;
1435 pa_cvolume_remap(&o->volume, channel_map, &o->channel_map);
1436 compute_reference_ratio(o);
1438 /* The volume changed, let's tell people so */
1439 if (!pa_cvolume_equal(&old_volume, &o->volume)) {
1440 if (o->volume_changed)
1441 o->volume_changed(o);
1443 pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
1447 update_real_volume(o->destination_source, new_volume, channel_map);
1452 /* Called from main thread. Only called for the root source in shared volume
1454 static void compute_real_volume(pa_source *s) {
1455 pa_source_assert_ref(s);
1456 pa_assert_ctl_context();
1457 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1458 pa_assert(pa_source_flat_volume_enabled(s));
1459 pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1461 /* This determines the maximum volume of all streams and sets
1462 * s->real_volume accordingly. */
1464 if (!has_outputs(s)) {
1465 /* In the special case that we have no source outputs we leave the
1466 * volume unmodified. */
1467 update_real_volume(s, &s->reference_volume, &s->channel_map);
1471 pa_cvolume_mute(&s->real_volume, s->channel_map.channels);
1473 /* First let's determine the new maximum volume of all outputs
1474 * connected to this source */
1475 get_maximum_output_volume(s, &s->real_volume, &s->channel_map);
1476 update_real_volume(s, &s->real_volume, &s->channel_map);
1478 /* Then, let's update the real ratios/soft volumes of all outputs
1479 * connected to this source */
1480 compute_real_ratios(s);
1483 /* Called from main thread. Only called for the root source in shared volume
1484 * cases, except for internal recursive calls. */
1485 static void propagate_reference_volume(pa_source *s) {
1486 pa_source_output *o;
1489 pa_source_assert_ref(s);
1490 pa_assert_ctl_context();
1491 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1492 pa_assert(pa_source_flat_volume_enabled(s));
1494 /* This is called whenever the source volume changes that is not
1495 * caused by a source output volume change. We need to fix up the
1496 * source output volumes accordingly */
1498 PA_IDXSET_FOREACH(o, s->outputs, idx) {
1499 pa_cvolume old_volume;
1501 if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1502 propagate_reference_volume(o->destination_source);
1504 /* Since the origin source uses volume sharing, this output's volume
1505 * needs to be updated to match the root source's real volume, but
1506 * that will be done later in update_shared_real_volume(). */
1510 old_volume = o->volume;
1512 /* This basically calculates:
1514 * o->volume := o->reference_volume * o->reference_ratio */
1516 o->volume = s->reference_volume;
1517 pa_cvolume_remap(&o->volume, &s->channel_map, &o->channel_map);
1518 pa_sw_cvolume_multiply(&o->volume, &o->volume, &o->reference_ratio);
1520 /* The volume changed, let's tell people so */
1521 if (!pa_cvolume_equal(&old_volume, &o->volume)) {
1523 if (o->volume_changed)
1524 o->volume_changed(o);
1526 pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
1531 /* Called from main thread. Only called for the root source in volume sharing
1532 * cases, except for internal recursive calls. The return value indicates
1533 * whether any reference volume actually changed. */
1534 static bool update_reference_volume(pa_source *s, const pa_cvolume *v, const pa_channel_map *channel_map, bool save) {
1536 bool reference_volume_changed;
1537 pa_source_output *o;
1540 pa_source_assert_ref(s);
1541 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1543 pa_assert(channel_map);
1544 pa_assert(pa_cvolume_valid(v));
1547 pa_cvolume_remap(&volume, channel_map, &s->channel_map);
1549 reference_volume_changed = !pa_cvolume_equal(&volume, &s->reference_volume);
1550 s->reference_volume = volume;
1552 s->save_volume = (!reference_volume_changed && s->save_volume) || save;
1554 if (reference_volume_changed)
1555 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1556 else if (!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1557 /* If the root source's volume doesn't change, then there can't be any
1558 * changes in the other source in the source tree either.
1560 * It's probably theoretically possible that even if the root source's
1561 * volume changes slightly, some filter source doesn't change its volume
1562 * due to rounding errors. If that happens, we still want to propagate
1563 * the changed root source volume to the sources connected to the
1564 * intermediate source that didn't change its volume. This theoretical
1565 * possibility is the reason why we have that !(s->flags &
1566 * PA_SOURCE_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
1567 * notice even if we returned here false always if
1568 * reference_volume_changed is false. */
1571 PA_IDXSET_FOREACH(o, s->outputs, idx) {
1572 if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1573 update_reference_volume(o->destination_source, v, channel_map, false);
1579 /* Called from main thread */
1580 void pa_source_set_volume(
1582 const pa_cvolume *volume,
1586 pa_cvolume new_reference_volume;
1587 pa_source *root_source;
1589 pa_source_assert_ref(s);
1590 pa_assert_ctl_context();
1591 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1592 pa_assert(!volume || pa_cvolume_valid(volume));
1593 pa_assert(volume || pa_source_flat_volume_enabled(s));
1594 pa_assert(!volume || volume->channels == 1 || pa_cvolume_compatible(volume, &s->sample_spec));
1596 /* make sure we don't change the volume in PASSTHROUGH mode ...
1597 * ... *except* if we're being invoked to reset the volume to ensure 0 dB gain */
1598 if (pa_source_is_passthrough(s) && (!volume || !pa_cvolume_is_norm(volume))) {
1599 pa_log_warn("Cannot change volume, source is monitor of a PASSTHROUGH sink");
1603 /* In case of volume sharing, the volume is set for the root source first,
1604 * from which it's then propagated to the sharing sources. */
1605 root_source = pa_source_get_master(s);
1607 if (PA_UNLIKELY(!root_source))
1610 /* As a special exception we accept mono volumes on all sources --
1611 * even on those with more complex channel maps */
1614 if (pa_cvolume_compatible(volume, &s->sample_spec))
1615 new_reference_volume = *volume;
1617 new_reference_volume = s->reference_volume;
1618 pa_cvolume_scale(&new_reference_volume, pa_cvolume_max(volume));
1621 pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_source->channel_map);
1623 if (update_reference_volume(root_source, &new_reference_volume, &root_source->channel_map, save)) {
1624 if (pa_source_flat_volume_enabled(root_source)) {
1625 /* OK, propagate this volume change back to the outputs */
1626 propagate_reference_volume(root_source);
1628 /* And now recalculate the real volume */
1629 compute_real_volume(root_source);
1631 update_real_volume(root_source, &root_source->reference_volume, &root_source->channel_map);
1635 /* If volume is NULL we synchronize the source's real and
1636 * reference volumes with the stream volumes. */
1638 pa_assert(pa_source_flat_volume_enabled(root_source));
1640 /* Ok, let's determine the new real volume */
1641 compute_real_volume(root_source);
1643 /* Let's 'push' the reference volume if necessary */
1644 pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_source->real_volume);
1645 /* If the source and it's root don't have the same number of channels, we need to remap */
1646 if (s != root_source && !pa_channel_map_equal(&s->channel_map, &root_source->channel_map))
1647 pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_source->channel_map);
1648 update_reference_volume(root_source, &new_reference_volume, &root_source->channel_map, save);
1650 /* Now that the reference volume is updated, we can update the streams'
1651 * reference ratios. */
1652 compute_reference_ratios(root_source);
1655 if (root_source->set_volume) {
1656 /* If we have a function set_volume(), then we do not apply a
1657 * soft volume by default. However, set_volume() is free to
1658 * apply one to root_source->soft_volume */
1660 pa_cvolume_reset(&root_source->soft_volume, root_source->sample_spec.channels);
1661 if (!(root_source->flags & PA_SOURCE_DEFERRED_VOLUME))
1662 root_source->set_volume(root_source);
1665 /* If we have no function set_volume(), then the soft volume
1666 * becomes the real volume */
1667 root_source->soft_volume = root_source->real_volume;
1669 /* This tells the source that soft volume and/or real volume changed */
1671 pa_assert_se(pa_asyncmsgq_send(root_source->asyncmsgq, PA_MSGOBJECT(root_source), PA_SOURCE_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL) == 0);
1674 /* Called from the io thread if sync volume is used, otherwise from the main thread.
1675 * Only to be called by source implementor */
1676 void pa_source_set_soft_volume(pa_source *s, const pa_cvolume *volume) {
1678 pa_source_assert_ref(s);
1679 pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1681 if (s->flags & PA_SOURCE_DEFERRED_VOLUME)
1682 pa_source_assert_io_context(s);
1684 pa_assert_ctl_context();
1687 pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
1689 s->soft_volume = *volume;
1691 if (PA_SOURCE_IS_LINKED(s->state) && !(s->flags & PA_SOURCE_DEFERRED_VOLUME))
1692 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
1694 s->thread_info.soft_volume = s->soft_volume;
1697 /* Called from the main thread. Only called for the root source in volume sharing
1698 * cases, except for internal recursive calls. */
1699 static void propagate_real_volume(pa_source *s, const pa_cvolume *old_real_volume) {
1700 pa_source_output *o;
1703 pa_source_assert_ref(s);
1704 pa_assert(old_real_volume);
1705 pa_assert_ctl_context();
1706 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1708 /* This is called when the hardware's real volume changes due to
1709 * some external event. We copy the real volume into our
1710 * reference volume and then rebuild the stream volumes based on
1711 * i->real_ratio which should stay fixed. */
1713 if (!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1714 if (pa_cvolume_equal(old_real_volume, &s->real_volume))
1717 /* 1. Make the real volume the reference volume */
1718 update_reference_volume(s, &s->real_volume, &s->channel_map, true);
1721 if (pa_source_flat_volume_enabled(s)) {
1723 PA_IDXSET_FOREACH(o, s->outputs, idx) {
1724 pa_cvolume old_volume = o->volume;
1726 /* 2. Since the source's reference and real volumes are equal
1727 * now our ratios should be too. */
1728 o->reference_ratio = o->real_ratio;
1730 /* 3. Recalculate the new stream reference volume based on the
1731 * reference ratio and the sink's reference volume.
1733 * This basically calculates:
1735 * o->volume = s->reference_volume * o->reference_ratio
1737 * This is identical to propagate_reference_volume() */
1738 o->volume = s->reference_volume;
1739 pa_cvolume_remap(&o->volume, &s->channel_map, &o->channel_map);
1740 pa_sw_cvolume_multiply(&o->volume, &o->volume, &o->reference_ratio);
1742 /* Notify if something changed */
1743 if (!pa_cvolume_equal(&old_volume, &o->volume)) {
1745 if (o->volume_changed)
1746 o->volume_changed(o);
1748 pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
1751 if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1752 propagate_real_volume(o->destination_source, old_real_volume);
1756 /* Something got changed in the hardware. It probably makes sense
1757 * to save changed hw settings given that hw volume changes not
1758 * triggered by PA are almost certainly done by the user. */
1759 if (!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1760 s->save_volume = true;
1763 /* Called from io thread */
1764 void pa_source_update_volume_and_mute(pa_source *s) {
1766 pa_source_assert_io_context(s);
1768 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE, NULL, 0, NULL, NULL);
1771 /* Called from main thread */
1772 const pa_cvolume *pa_source_get_volume(pa_source *s, bool force_refresh) {
1773 pa_source_assert_ref(s);
1774 pa_assert_ctl_context();
1775 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1777 if (s->refresh_volume || force_refresh) {
1778 struct pa_cvolume old_real_volume;
1780 pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1782 old_real_volume = s->real_volume;
1784 if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_volume)
1787 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
1789 update_real_volume(s, &s->real_volume, &s->channel_map);
1790 propagate_real_volume(s, &old_real_volume);
1793 return &s->reference_volume;
1796 /* Called from main thread. In volume sharing cases, only the root source may
1798 void pa_source_volume_changed(pa_source *s, const pa_cvolume *new_real_volume) {
1799 pa_cvolume old_real_volume;
1801 pa_source_assert_ref(s);
1802 pa_assert_ctl_context();
1803 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1804 pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1806 /* The source implementor may call this if the volume changed to make sure everyone is notified */
1808 old_real_volume = s->real_volume;
1809 update_real_volume(s, new_real_volume, &s->channel_map);
1810 propagate_real_volume(s, &old_real_volume);
1813 /* Called from main thread */
1814 void pa_source_set_mute(pa_source *s, bool mute, bool save) {
1817 pa_source_assert_ref(s);
1818 pa_assert_ctl_context();
1819 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1821 old_muted = s->muted;
1823 s->save_muted = (old_muted == s->muted && s->save_muted) || save;
1825 if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->set_mute)
1828 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1830 if (old_muted != s->muted)
1831 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1834 /* Called from main thread */
1835 bool pa_source_get_mute(pa_source *s, bool force_refresh) {
1837 pa_source_assert_ref(s);
1838 pa_assert_ctl_context();
1839 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1841 if (s->refresh_muted || force_refresh) {
1842 bool old_muted = s->muted;
1844 if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_mute)
1847 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
1849 if (old_muted != s->muted) {
1850 s->save_muted = true;
1852 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1854 /* Make sure the soft mute status stays in sync */
1855 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1862 /* Called from main thread */
1863 void pa_source_mute_changed(pa_source *s, bool new_muted) {
1864 pa_source_assert_ref(s);
1865 pa_assert_ctl_context();
1866 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1868 /* The source implementor may call this if the mute state changed to make sure everyone is notified */
1870 if (s->muted == new_muted)
1873 s->muted = new_muted;
1874 s->save_muted = true;
1876 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1879 /* Called from main thread */
1880 bool pa_source_update_proplist(pa_source *s, pa_update_mode_t mode, pa_proplist *p) {
1881 pa_source_assert_ref(s);
1882 pa_assert_ctl_context();
1885 pa_proplist_update(s->proplist, mode, p);
1887 if (PA_SOURCE_IS_LINKED(s->state)) {
1888 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED], s);
1889 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1895 /* Called from main thread */
1896 /* FIXME -- this should be dropped and be merged into pa_source_update_proplist() */
1897 void pa_source_set_description(pa_source *s, const char *description) {
1899 pa_source_assert_ref(s);
1900 pa_assert_ctl_context();
1902 if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
1905 old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1907 if (old && description && pa_streq(old, description))
1911 pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
1913 pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1915 if (PA_SOURCE_IS_LINKED(s->state)) {
1916 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1917 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED], s);
1921 /* Called from main thread */
1922 unsigned pa_source_linked_by(pa_source *s) {
1923 pa_source_assert_ref(s);
1924 pa_assert_ctl_context();
1925 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1927 return pa_idxset_size(s->outputs);
1930 /* Called from main thread */
1931 unsigned pa_source_used_by(pa_source *s) {
1934 pa_source_assert_ref(s);
1935 pa_assert_ctl_context();
1936 pa_assert(PA_SOURCE_IS_LINKED(s->state));
1938 ret = pa_idxset_size(s->outputs);
1939 pa_assert(ret >= s->n_corked);
1941 return ret - s->n_corked;
1944 /* Called from main thread */
1945 unsigned pa_source_check_suspend(pa_source *s) {
1947 pa_source_output *o;
1950 pa_source_assert_ref(s);
1951 pa_assert_ctl_context();
1953 if (!PA_SOURCE_IS_LINKED(s->state))
1958 PA_IDXSET_FOREACH(o, s->outputs, idx) {
1959 pa_source_output_state_t st;
1961 st = pa_source_output_get_state(o);
1963 /* We do not assert here. It is perfectly valid for a source output to
1964 * be in the INIT state (i.e. created, marked done but not yet put)
1965 * and we should not care if it's unlinked as it won't contribute
1966 * towards our busy status.
1968 if (!PA_SOURCE_OUTPUT_IS_LINKED(st))
1971 if (st == PA_SOURCE_OUTPUT_CORKED)
1974 if (o->flags & PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND)
1983 /* Called from the IO thread */
1984 static void sync_output_volumes_within_thread(pa_source *s) {
1985 pa_source_output *o;
1988 pa_source_assert_ref(s);
1989 pa_source_assert_io_context(s);
1991 PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state) {
1992 if (pa_cvolume_equal(&o->thread_info.soft_volume, &o->soft_volume))
1995 o->thread_info.soft_volume = o->soft_volume;
1996 //pa_source_output_request_rewind(o, 0, true, false, false);
2000 /* Called from the IO thread. Only called for the root source in volume sharing
2001 * cases, except for internal recursive calls. */
2002 static void set_shared_volume_within_thread(pa_source *s) {
2003 pa_source_output *o;
2006 pa_source_assert_ref(s);
2008 PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
2010 PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state) {
2011 if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
2012 set_shared_volume_within_thread(o->destination_source);
2016 /* Called from IO thread, except when it is not */
2017 int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2018 pa_source *s = PA_SOURCE(object);
2019 pa_source_assert_ref(s);
2021 switch ((pa_source_message_t) code) {
2023 case PA_SOURCE_MESSAGE_ADD_OUTPUT: {
2024 pa_source_output *o = PA_SOURCE_OUTPUT(userdata);
2026 pa_hashmap_put(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index), pa_source_output_ref(o));
2028 if (o->direct_on_input) {
2029 o->thread_info.direct_on_input = o->direct_on_input;
2030 pa_hashmap_put(o->thread_info.direct_on_input->thread_info.direct_outputs, PA_UINT32_TO_PTR(o->index), o);
2033 pa_assert(!o->thread_info.attached);
2034 o->thread_info.attached = true;
2039 pa_source_output_set_state_within_thread(o, o->state);
2041 if (o->thread_info.requested_source_latency != (pa_usec_t) -1)
2042 pa_source_output_set_requested_latency_within_thread(o, o->thread_info.requested_source_latency);
2044 pa_source_output_update_max_rewind(o, s->thread_info.max_rewind);
2046 /* We don't just invalidate the requested latency here,
2047 * because if we are in a move we might need to fix up the
2048 * requested latency. */
2049 pa_source_output_set_requested_latency_within_thread(o, o->thread_info.requested_source_latency);
2051 /* In flat volume mode we need to update the volume as
2053 return object->process_msg(object, PA_SOURCE_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2056 case PA_SOURCE_MESSAGE_REMOVE_OUTPUT: {
2057 pa_source_output *o = PA_SOURCE_OUTPUT(userdata);
2059 pa_source_output_set_state_within_thread(o, o->state);
2064 pa_assert(o->thread_info.attached);
2065 o->thread_info.attached = false;
2067 if (o->thread_info.direct_on_input) {
2068 pa_hashmap_remove(o->thread_info.direct_on_input->thread_info.direct_outputs, PA_UINT32_TO_PTR(o->index));
2069 o->thread_info.direct_on_input = NULL;
2072 if (pa_hashmap_remove(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index)))
2073 pa_source_output_unref(o);
2075 pa_source_invalidate_requested_latency(s, true);
2077 /* In flat volume mode we need to update the volume as
2079 return object->process_msg(object, PA_SOURCE_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2082 case PA_SOURCE_MESSAGE_SET_SHARED_VOLUME: {
2083 pa_source *root_source = pa_source_get_master(s);
2085 if (PA_LIKELY(root_source))
2086 set_shared_volume_within_thread(root_source);
2091 case PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED:
2093 if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
2095 pa_source_volume_change_push(s);
2097 /* Fall through ... */
2099 case PA_SOURCE_MESSAGE_SET_VOLUME:
2101 if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2102 s->thread_info.soft_volume = s->soft_volume;
2105 /* Fall through ... */
2107 case PA_SOURCE_MESSAGE_SYNC_VOLUMES:
2108 sync_output_volumes_within_thread(s);
2111 case PA_SOURCE_MESSAGE_GET_VOLUME:
2113 if ((s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_volume) {
2115 pa_source_volume_change_flush(s);
2116 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2119 /* In case source implementor reset SW volume. */
2120 if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2121 s->thread_info.soft_volume = s->soft_volume;
2126 case PA_SOURCE_MESSAGE_SET_MUTE:
2128 if (s->thread_info.soft_muted != s->muted) {
2129 s->thread_info.soft_muted = s->muted;
2132 if (s->flags & PA_SOURCE_DEFERRED_VOLUME && s->set_mute)
2137 case PA_SOURCE_MESSAGE_GET_MUTE:
2139 if (s->flags & PA_SOURCE_DEFERRED_VOLUME && s->get_mute)
2144 case PA_SOURCE_MESSAGE_SET_STATE: {
2146 bool suspend_change =
2147 (s->thread_info.state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
2148 (PA_SOURCE_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SOURCE_SUSPENDED);
2150 s->thread_info.state = PA_PTR_TO_UINT(userdata);
2152 if (suspend_change) {
2153 pa_source_output *o;
2156 while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
2157 if (o->suspend_within_thread)
2158 o->suspend_within_thread(o, s->thread_info.state == PA_SOURCE_SUSPENDED);
2164 case PA_SOURCE_MESSAGE_DETACH:
2166 /* Detach all streams */
2167 pa_source_detach_within_thread(s);
2170 case PA_SOURCE_MESSAGE_ATTACH:
2172 /* Reattach all streams */
2173 pa_source_attach_within_thread(s);
2176 case PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY: {
2178 pa_usec_t *usec = userdata;
2179 *usec = pa_source_get_requested_latency_within_thread(s);
2181 /* Yes, that's right, the IO thread will see -1 when no
2182 * explicit requested latency is configured, the main
2183 * thread will see max_latency */
2184 if (*usec == (pa_usec_t) -1)
2185 *usec = s->thread_info.max_latency;
2190 case PA_SOURCE_MESSAGE_SET_LATENCY_RANGE: {
2191 pa_usec_t *r = userdata;
2193 pa_source_set_latency_range_within_thread(s, r[0], r[1]);
2198 case PA_SOURCE_MESSAGE_GET_LATENCY_RANGE: {
2199 pa_usec_t *r = userdata;
2201 r[0] = s->thread_info.min_latency;
2202 r[1] = s->thread_info.max_latency;
2207 case PA_SOURCE_MESSAGE_GET_FIXED_LATENCY:
2209 *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2212 case PA_SOURCE_MESSAGE_SET_FIXED_LATENCY:
2214 pa_source_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2217 case PA_SOURCE_MESSAGE_GET_MAX_REWIND:
2219 *((size_t*) userdata) = s->thread_info.max_rewind;
2222 case PA_SOURCE_MESSAGE_SET_MAX_REWIND:
2224 pa_source_set_max_rewind_within_thread(s, (size_t) offset);
2227 case PA_SOURCE_MESSAGE_GET_LATENCY:
2229 if (s->monitor_of) {
2230 *((pa_usec_t*) userdata) = 0;
2234 /* Implementors need to overwrite this implementation! */
2237 case PA_SOURCE_MESSAGE_SET_PORT:
2239 pa_assert(userdata);
2241 struct source_message_set_port *msg_data = userdata;
2242 msg_data->ret = s->set_port(s, msg_data->port);
2246 case PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2247 /* This message is sent from IO-thread and handled in main thread. */
2248 pa_assert_ctl_context();
2250 /* Make sure we're not messing with main thread when no longer linked */
2251 if (!PA_SOURCE_IS_LINKED(s->state))
2254 pa_source_get_volume(s, true);
2255 pa_source_get_mute(s, true);
2258 case PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET:
2259 s->thread_info.latency_offset = offset;
2262 case PA_SOURCE_MESSAGE_MAX:
2269 /* Called from main thread */
2270 int pa_source_suspend_all(pa_core *c, bool suspend, pa_suspend_cause_t cause) {
2275 pa_core_assert_ref(c);
2276 pa_assert_ctl_context();
2277 pa_assert(cause != 0);
2279 for (source = PA_SOURCE(pa_idxset_first(c->sources, &idx)); source; source = PA_SOURCE(pa_idxset_next(c->sources, &idx))) {
2282 if (source->monitor_of)
2285 if ((r = pa_source_suspend(source, suspend, cause)) < 0)
2292 /* Called from main thread */
2293 void pa_source_detach(pa_source *s) {
2294 pa_source_assert_ref(s);
2295 pa_assert_ctl_context();
2296 pa_assert(PA_SOURCE_IS_LINKED(s->state));
2298 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_DETACH, NULL, 0, NULL) == 0);
2301 /* Called from main thread */
2302 void pa_source_attach(pa_source *s) {
2303 pa_source_assert_ref(s);
2304 pa_assert_ctl_context();
2305 pa_assert(PA_SOURCE_IS_LINKED(s->state));
2307 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_ATTACH, NULL, 0, NULL) == 0);
2310 /* Called from IO thread */
2311 void pa_source_detach_within_thread(pa_source *s) {
2312 pa_source_output *o;
2315 pa_source_assert_ref(s);
2316 pa_source_assert_io_context(s);
2317 pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
2319 PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2324 /* Called from IO thread */
2325 void pa_source_attach_within_thread(pa_source *s) {
2326 pa_source_output *o;
2329 pa_source_assert_ref(s);
2330 pa_source_assert_io_context(s);
2331 pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
2333 PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2338 /* Called from IO thread */
2339 pa_usec_t pa_source_get_requested_latency_within_thread(pa_source *s) {
2340 pa_usec_t result = (pa_usec_t) -1;
2341 pa_source_output *o;
2344 pa_source_assert_ref(s);
2345 pa_source_assert_io_context(s);
2347 if (!(s->flags & PA_SOURCE_DYNAMIC_LATENCY))
2348 return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
2350 if (s->thread_info.requested_latency_valid)
2351 return s->thread_info.requested_latency;
2353 PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2354 if (o->thread_info.requested_source_latency != (pa_usec_t) -1 &&
2355 (result == (pa_usec_t) -1 || result > o->thread_info.requested_source_latency))
2356 result = o->thread_info.requested_source_latency;
2358 if (result != (pa_usec_t) -1)
2359 result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
2361 if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2362 /* Only cache this if we are fully set up */
2363 s->thread_info.requested_latency = result;
2364 s->thread_info.requested_latency_valid = true;
2370 /* Called from main thread */
2371 pa_usec_t pa_source_get_requested_latency(pa_source *s) {
2374 pa_source_assert_ref(s);
2375 pa_assert_ctl_context();
2376 pa_assert(PA_SOURCE_IS_LINKED(s->state));
2378 if (s->state == PA_SOURCE_SUSPENDED)
2381 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
2386 /* Called from IO thread */
2387 void pa_source_set_max_rewind_within_thread(pa_source *s, size_t max_rewind) {
2388 pa_source_output *o;
2391 pa_source_assert_ref(s);
2392 pa_source_assert_io_context(s);
2394 if (max_rewind == s->thread_info.max_rewind)
2397 s->thread_info.max_rewind = max_rewind;
2399 if (PA_SOURCE_IS_LINKED(s->thread_info.state))
2400 PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2401 pa_source_output_update_max_rewind(o, s->thread_info.max_rewind);
2404 /* Called from main thread */
2405 void pa_source_set_max_rewind(pa_source *s, size_t max_rewind) {
2406 pa_source_assert_ref(s);
2407 pa_assert_ctl_context();
2409 if (PA_SOURCE_IS_LINKED(s->state))
2410 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
2412 pa_source_set_max_rewind_within_thread(s, max_rewind);
2415 /* Called from IO thread */
2416 void pa_source_invalidate_requested_latency(pa_source *s, bool dynamic) {
2417 pa_source_output *o;
2420 pa_source_assert_ref(s);
2421 pa_source_assert_io_context(s);
2423 if ((s->flags & PA_SOURCE_DYNAMIC_LATENCY))
2424 s->thread_info.requested_latency_valid = false;
2428 if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2430 if (s->update_requested_latency)
2431 s->update_requested_latency(s);
2433 while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
2434 if (o->update_source_requested_latency)
2435 o->update_source_requested_latency(o);
2439 pa_sink_invalidate_requested_latency(s->monitor_of, dynamic);
2442 /* Called from main thread */
2443 void pa_source_set_latency_range(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2444 pa_source_assert_ref(s);
2445 pa_assert_ctl_context();
2447 /* min_latency == 0: no limit
2448 * min_latency anything else: specified limit
2450 * Similar for max_latency */
2452 if (min_latency < ABSOLUTE_MIN_LATENCY)
2453 min_latency = ABSOLUTE_MIN_LATENCY;
2455 if (max_latency <= 0 ||
2456 max_latency > ABSOLUTE_MAX_LATENCY)
2457 max_latency = ABSOLUTE_MAX_LATENCY;
2459 pa_assert(min_latency <= max_latency);
2461 /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2462 pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2463 max_latency == ABSOLUTE_MAX_LATENCY) ||
2464 (s->flags & PA_SOURCE_DYNAMIC_LATENCY));
2466 if (PA_SOURCE_IS_LINKED(s->state)) {
2472 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
2474 pa_source_set_latency_range_within_thread(s, min_latency, max_latency);
2477 /* Called from main thread */
2478 void pa_source_get_latency_range(pa_source *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
2479 pa_source_assert_ref(s);
2480 pa_assert_ctl_context();
2481 pa_assert(min_latency);
2482 pa_assert(max_latency);
2484 if (PA_SOURCE_IS_LINKED(s->state)) {
2485 pa_usec_t r[2] = { 0, 0 };
2487 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
2489 *min_latency = r[0];
2490 *max_latency = r[1];
2492 *min_latency = s->thread_info.min_latency;
2493 *max_latency = s->thread_info.max_latency;
2497 /* Called from IO thread, and from main thread before pa_source_put() is called */
2498 void pa_source_set_latency_range_within_thread(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2499 pa_source_assert_ref(s);
2500 pa_source_assert_io_context(s);
2502 pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
2503 pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
2504 pa_assert(min_latency <= max_latency);
2506 /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2507 pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2508 max_latency == ABSOLUTE_MAX_LATENCY) ||
2509 (s->flags & PA_SOURCE_DYNAMIC_LATENCY) ||
2512 if (s->thread_info.min_latency == min_latency &&
2513 s->thread_info.max_latency == max_latency)
2516 s->thread_info.min_latency = min_latency;
2517 s->thread_info.max_latency = max_latency;
2519 if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2520 pa_source_output *o;
2523 PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2524 if (o->update_source_latency_range)
2525 o->update_source_latency_range(o);
2528 pa_source_invalidate_requested_latency(s, false);
2531 /* Called from main thread, before the source is put */
2532 void pa_source_set_fixed_latency(pa_source *s, pa_usec_t latency) {
2533 pa_source_assert_ref(s);
2534 pa_assert_ctl_context();
2536 if (s->flags & PA_SOURCE_DYNAMIC_LATENCY) {
2537 pa_assert(latency == 0);
2541 if (latency < ABSOLUTE_MIN_LATENCY)
2542 latency = ABSOLUTE_MIN_LATENCY;
2544 if (latency > ABSOLUTE_MAX_LATENCY)
2545 latency = ABSOLUTE_MAX_LATENCY;
2547 if (PA_SOURCE_IS_LINKED(s->state))
2548 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
2550 s->thread_info.fixed_latency = latency;
2553 /* Called from main thread */
2554 pa_usec_t pa_source_get_fixed_latency(pa_source *s) {
2557 pa_source_assert_ref(s);
2558 pa_assert_ctl_context();
2560 if (s->flags & PA_SOURCE_DYNAMIC_LATENCY)
2563 if (PA_SOURCE_IS_LINKED(s->state))
2564 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
2566 latency = s->thread_info.fixed_latency;
2571 /* Called from IO thread */
2572 void pa_source_set_fixed_latency_within_thread(pa_source *s, pa_usec_t latency) {
2573 pa_source_assert_ref(s);
2574 pa_source_assert_io_context(s);
2576 if (s->flags & PA_SOURCE_DYNAMIC_LATENCY) {
2577 pa_assert(latency == 0);
2578 s->thread_info.fixed_latency = 0;
2583 pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
2584 pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
2586 if (s->thread_info.fixed_latency == latency)
2589 s->thread_info.fixed_latency = latency;
2591 if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2592 pa_source_output *o;
2595 PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2596 if (o->update_source_fixed_latency)
2597 o->update_source_fixed_latency(o);
2600 pa_source_invalidate_requested_latency(s, false);
2603 /* Called from main thread */
2604 void pa_source_set_latency_offset(pa_source *s, int64_t offset) {
2605 pa_source_assert_ref(s);
2607 s->latency_offset = offset;
2609 if (PA_SOURCE_IS_LINKED(s->state))
2610 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET, NULL, offset, NULL) == 0);
2612 s->thread_info.latency_offset = offset;
2615 /* Called from main thread */
2616 size_t pa_source_get_max_rewind(pa_source *s) {
2618 pa_assert_ctl_context();
2619 pa_source_assert_ref(s);
2621 if (!PA_SOURCE_IS_LINKED(s->state))
2622 return s->thread_info.max_rewind;
2624 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
2629 /* Called from main context */
2630 int pa_source_set_port(pa_source *s, const char *name, bool save) {
2631 pa_device_port *port;
2634 pa_source_assert_ref(s);
2635 pa_assert_ctl_context();
2638 pa_log_debug("set_port() operation not implemented for source %u \"%s\"", s->index, s->name);
2639 return -PA_ERR_NOTIMPLEMENTED;
2643 return -PA_ERR_NOENTITY;
2645 if (!(port = pa_hashmap_get(s->ports, name)))
2646 return -PA_ERR_NOENTITY;
2648 if (s->active_port == port) {
2649 s->save_port = s->save_port || save;
2653 if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
2654 struct source_message_set_port msg = { .port = port, .ret = 0 };
2655 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
2659 ret = s->set_port(s, port);
2662 return -PA_ERR_NOENTITY;
2664 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2666 pa_log_info("Changed port of source %u \"%s\" to %s", s->index, s->name, port->name);
2668 s->active_port = port;
2669 s->save_port = save;
2671 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PORT_CHANGED], s);
2676 PA_STATIC_FLIST_DECLARE(pa_source_volume_change, 0, pa_xfree);
2678 /* Called from the IO thread. */
2679 static pa_source_volume_change *pa_source_volume_change_new(pa_source *s) {
2680 pa_source_volume_change *c;
2681 if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_source_volume_change))))
2682 c = pa_xnew(pa_source_volume_change, 1);
2684 PA_LLIST_INIT(pa_source_volume_change, c);
2686 pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
2690 /* Called from the IO thread. */
2691 static void pa_source_volume_change_free(pa_source_volume_change *c) {
2693 if (pa_flist_push(PA_STATIC_FLIST_GET(pa_source_volume_change), c) < 0)
2697 /* Called from the IO thread. */
2698 void pa_source_volume_change_push(pa_source *s) {
2699 pa_source_volume_change *c = NULL;
2700 pa_source_volume_change *nc = NULL;
2701 uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
2703 const char *direction = NULL;
2706 nc = pa_source_volume_change_new(s);
2708 /* NOTE: There is already more different volumes in pa_source that I can remember.
2709 * Adding one more volume for HW would get us rid of this, but I am trying
2710 * to survive with the ones we already have. */
2711 pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
2713 if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
2714 pa_log_debug("Volume not changing");
2715 pa_source_volume_change_free(nc);
2719 nc->at = pa_source_get_latency_within_thread(s);
2720 nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
2722 if (s->thread_info.volume_changes_tail) {
2723 for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
2724 /* If volume is going up let's do it a bit late. If it is going
2725 * down let's do it a bit early. */
2726 if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
2727 if (nc->at + safety_margin > c->at) {
2728 nc->at += safety_margin;
2733 else if (nc->at - safety_margin > c->at) {
2734 nc->at -= safety_margin;
2742 if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
2743 nc->at += safety_margin;
2746 nc->at -= safety_margin;
2749 PA_LLIST_PREPEND(pa_source_volume_change, s->thread_info.volume_changes, nc);
2752 PA_LLIST_INSERT_AFTER(pa_source_volume_change, s->thread_info.volume_changes, c, nc);
2755 pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
2757 /* We can ignore volume events that came earlier but should happen later than this. */
2758 PA_LLIST_FOREACH(c, nc->next) {
2759 pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
2760 pa_source_volume_change_free(c);
2763 s->thread_info.volume_changes_tail = nc;
2766 /* Called from the IO thread. */
2767 static void pa_source_volume_change_flush(pa_source *s) {
2768 pa_source_volume_change *c = s->thread_info.volume_changes;
2770 s->thread_info.volume_changes = NULL;
2771 s->thread_info.volume_changes_tail = NULL;
2773 pa_source_volume_change *next = c->next;
2774 pa_source_volume_change_free(c);
2779 /* Called from the IO thread. */
2780 bool pa_source_volume_change_apply(pa_source *s, pa_usec_t *usec_to_next) {
2786 if (!s->thread_info.volume_changes || !PA_SOURCE_IS_LINKED(s->state)) {
2792 pa_assert(s->write_volume);
2794 now = pa_rtclock_now();
2796 while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
2797 pa_source_volume_change *c = s->thread_info.volume_changes;
2798 PA_LLIST_REMOVE(pa_source_volume_change, s->thread_info.volume_changes, c);
2799 pa_log_debug("Volume change to %d at %llu was written %llu usec late",
2800 pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
2802 s->thread_info.current_hw_volume = c->hw_volume;
2803 pa_source_volume_change_free(c);
2809 if (s->thread_info.volume_changes) {
2811 *usec_to_next = s->thread_info.volume_changes->at - now;
2812 if (pa_log_ratelimit(PA_LOG_DEBUG))
2813 pa_log_debug("Next volume change in %lld usec", (long long) (s->thread_info.volume_changes->at - now));
2818 s->thread_info.volume_changes_tail = NULL;
2823 /* Called from the main thread */
2824 /* Gets the list of formats supported by the source. The members and idxset must
2825 * be freed by the caller. */
2826 pa_idxset* pa_source_get_formats(pa_source *s) {
2831 if (s->get_formats) {
2832 /* Source supports format query, all is good */
2833 ret = s->get_formats(s);
2835 /* Source doesn't support format query, so assume it does PCM */
2836 pa_format_info *f = pa_format_info_new();
2837 f->encoding = PA_ENCODING_PCM;
2839 ret = pa_idxset_new(NULL, NULL);
2840 pa_idxset_put(ret, f, NULL);
2846 /* Called from the main thread */
2847 /* Checks if the source can accept this format */
2848 bool pa_source_check_format(pa_source *s, pa_format_info *f) {
2849 pa_idxset *formats = NULL;
2855 formats = pa_source_get_formats(s);
2858 pa_format_info *finfo_device;
2861 PA_IDXSET_FOREACH(finfo_device, formats, i) {
2862 if (pa_format_info_is_compatible(finfo_device, f)) {
2868 pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
2874 /* Called from the main thread */
2875 /* Calculates the intersection between formats supported by the source and
2876 * in_formats, and returns these, in the order of the source's formats. */
2877 pa_idxset* pa_source_check_formats(pa_source *s, pa_idxset *in_formats) {
2878 pa_idxset *out_formats = pa_idxset_new(NULL, NULL), *source_formats = NULL;
2879 pa_format_info *f_source, *f_in;
2884 if (!in_formats || pa_idxset_isempty(in_formats))
2887 source_formats = pa_source_get_formats(s);
2889 PA_IDXSET_FOREACH(f_source, source_formats, i) {
2890 PA_IDXSET_FOREACH(f_in, in_formats, j) {
2891 if (pa_format_info_is_compatible(f_source, f_in))
2892 pa_idxset_put(out_formats, pa_format_info_copy(f_in), NULL);
2898 pa_idxset_free(source_formats, (pa_free_cb_t) pa_format_info_free);