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/utf8.h>
31 #include <pulse/xmalloc.h>
32 #include <pulse/timeval.h>
33 #include <pulse/util.h>
34 #include <pulse/rtclock.h>
35 #include <pulse/internal.h>
37 #include <pulsecore/core-util.h>
38 #include <pulsecore/source-output.h>
39 #include <pulsecore/namereg.h>
40 #include <pulsecore/core-subscribe.h>
41 #include <pulsecore/log.h>
42 #include <pulsecore/sample-util.h>
43 #include <pulsecore/flist.h>
47 #define ABSOLUTE_MIN_LATENCY (500)
48 #define ABSOLUTE_MAX_LATENCY (10*PA_USEC_PER_SEC)
49 #define DEFAULT_FIXED_LATENCY (250*PA_USEC_PER_MSEC)
51 PA_DEFINE_PUBLIC_CLASS(pa_source
, pa_msgobject
);
53 struct pa_source_volume_change
{
57 PA_LLIST_FIELDS(pa_source_volume_change
);
60 struct source_message_set_port
{
65 static void source_free(pa_object
*o
);
67 static void pa_source_volume_change_push(pa_source
*s
);
68 static void pa_source_volume_change_flush(pa_source
*s
);
70 pa_source_new_data
* pa_source_new_data_init(pa_source_new_data
*data
) {
74 data
->proplist
= pa_proplist_new();
79 void pa_source_new_data_set_name(pa_source_new_data
*data
, const char *name
) {
83 data
->name
= pa_xstrdup(name
);
86 void pa_source_new_data_set_sample_spec(pa_source_new_data
*data
, const pa_sample_spec
*spec
) {
89 if ((data
->sample_spec_is_set
= !!spec
))
90 data
->sample_spec
= *spec
;
93 void pa_source_new_data_set_channel_map(pa_source_new_data
*data
, const pa_channel_map
*map
) {
96 if ((data
->channel_map_is_set
= !!map
))
97 data
->channel_map
= *map
;
100 void pa_source_new_data_set_volume(pa_source_new_data
*data
, const pa_cvolume
*volume
) {
103 if ((data
->volume_is_set
= !!volume
))
104 data
->volume
= *volume
;
107 void pa_source_new_data_set_muted(pa_source_new_data
*data
, pa_bool_t mute
) {
110 data
->muted_is_set
= TRUE
;
111 data
->muted
= !!mute
;
114 void pa_source_new_data_set_port(pa_source_new_data
*data
, const char *port
) {
117 pa_xfree(data
->active_port
);
118 data
->active_port
= pa_xstrdup(port
);
121 void pa_source_new_data_done(pa_source_new_data
*data
) {
124 pa_proplist_free(data
->proplist
);
129 while ((p
= pa_hashmap_steal_first(data
->ports
)))
130 pa_device_port_free(p
);
132 pa_hashmap_free(data
->ports
, NULL
, NULL
);
135 pa_xfree(data
->name
);
136 pa_xfree(data
->active_port
);
139 /* Called from main context */
140 static void reset_callbacks(pa_source
*s
) {
144 s
->get_volume
= NULL
;
145 s
->set_volume
= NULL
;
148 s
->update_requested_latency
= NULL
;
150 s
->get_formats
= NULL
;
153 /* Called from main context */
154 pa_source
* pa_source_new(
156 pa_source_new_data
*data
,
157 pa_source_flags_t flags
) {
161 char st
[PA_SAMPLE_SPEC_SNPRINT_MAX
], cm
[PA_CHANNEL_MAP_SNPRINT_MAX
];
166 pa_assert(data
->name
);
167 pa_assert_ctl_context();
169 s
= pa_msgobject_new(pa_source
);
171 if (!(name
= pa_namereg_register(core
, data
->name
, PA_NAMEREG_SOURCE
, s
, data
->namereg_fail
))) {
172 pa_log_debug("Failed to register name %s.", data
->name
);
177 pa_source_new_data_set_name(data
, name
);
179 if (pa_hook_fire(&core
->hooks
[PA_CORE_HOOK_SOURCE_NEW
], data
) < 0) {
181 pa_namereg_unregister(core
, name
);
185 /* FIXME, need to free s here on failure */
187 pa_return_null_if_fail(!data
->driver
|| pa_utf8_valid(data
->driver
));
188 pa_return_null_if_fail(data
->name
&& pa_utf8_valid(data
->name
) && data
->name
[0]);
190 pa_return_null_if_fail(data
->sample_spec_is_set
&& pa_sample_spec_valid(&data
->sample_spec
));
192 if (!data
->channel_map_is_set
)
193 pa_return_null_if_fail(pa_channel_map_init_auto(&data
->channel_map
, data
->sample_spec
.channels
, PA_CHANNEL_MAP_DEFAULT
));
195 pa_return_null_if_fail(pa_channel_map_valid(&data
->channel_map
));
196 pa_return_null_if_fail(data
->channel_map
.channels
== data
->sample_spec
.channels
);
198 /* FIXME: There should probably be a general function for checking whether
199 * the source volume is allowed to be set, like there is for source outputs. */
200 pa_assert(!data
->volume_is_set
|| !(flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
));
202 if (!data
->volume_is_set
) {
203 pa_cvolume_reset(&data
->volume
, data
->sample_spec
.channels
);
204 data
->save_volume
= FALSE
;
207 pa_return_null_if_fail(pa_cvolume_valid(&data
->volume
));
208 pa_return_null_if_fail(pa_cvolume_compatible(&data
->volume
, &data
->sample_spec
));
210 if (!data
->muted_is_set
)
214 pa_proplist_update(data
->proplist
, PA_UPDATE_MERGE
, data
->card
->proplist
);
216 pa_device_init_description(data
->proplist
);
217 pa_device_init_icon(data
->proplist
, FALSE
);
218 pa_device_init_intended_roles(data
->proplist
);
220 if (pa_hook_fire(&core
->hooks
[PA_CORE_HOOK_SOURCE_FIXATE
], data
) < 0) {
222 pa_namereg_unregister(core
, name
);
226 s
->parent
.parent
.free
= source_free
;
227 s
->parent
.process_msg
= pa_source_process_msg
;
230 s
->state
= PA_SOURCE_INIT
;
233 s
->suspend_cause
= 0;
234 s
->name
= pa_xstrdup(name
);
235 s
->proplist
= pa_proplist_copy(data
->proplist
);
236 s
->driver
= pa_xstrdup(pa_path_get_filename(data
->driver
));
237 s
->module
= data
->module
;
238 s
->card
= data
->card
;
240 s
->priority
= pa_device_init_priority(s
->proplist
);
242 s
->sample_spec
= data
->sample_spec
;
243 s
->channel_map
= data
->channel_map
;
245 s
->outputs
= pa_idxset_new(NULL
, NULL
);
247 s
->monitor_of
= NULL
;
248 s
->output_from_master
= NULL
;
250 s
->reference_volume
= s
->real_volume
= data
->volume
;
251 pa_cvolume_reset(&s
->soft_volume
, s
->sample_spec
.channels
);
252 s
->base_volume
= PA_VOLUME_NORM
;
253 s
->n_volume_steps
= PA_VOLUME_NORM
+1;
254 s
->muted
= data
->muted
;
255 s
->refresh_volume
= s
->refresh_muted
= FALSE
;
262 /* As a minor optimization we just steal the list instead of
264 s
->ports
= data
->ports
;
267 s
->active_port
= NULL
;
268 s
->save_port
= FALSE
;
270 if (data
->active_port
&& s
->ports
)
271 if ((s
->active_port
= pa_hashmap_get(s
->ports
, data
->active_port
)))
272 s
->save_port
= data
->save_port
;
274 if (!s
->active_port
&& s
->ports
) {
278 PA_HASHMAP_FOREACH(p
, s
->ports
, state
)
279 if (!s
->active_port
|| p
->priority
> s
->active_port
->priority
)
283 s
->save_volume
= data
->save_volume
;
284 s
->save_muted
= data
->save_muted
;
286 pa_silence_memchunk_get(
287 &core
->silence_cache
,
293 s
->thread_info
.rtpoll
= NULL
;
294 s
->thread_info
.outputs
= pa_hashmap_new(pa_idxset_trivial_hash_func
, pa_idxset_trivial_compare_func
);
295 s
->thread_info
.soft_volume
= s
->soft_volume
;
296 s
->thread_info
.soft_muted
= s
->muted
;
297 s
->thread_info
.state
= s
->state
;
298 s
->thread_info
.max_rewind
= 0;
299 s
->thread_info
.requested_latency_valid
= FALSE
;
300 s
->thread_info
.requested_latency
= 0;
301 s
->thread_info
.min_latency
= ABSOLUTE_MIN_LATENCY
;
302 s
->thread_info
.max_latency
= ABSOLUTE_MAX_LATENCY
;
303 s
->thread_info
.fixed_latency
= flags
& PA_SOURCE_DYNAMIC_LATENCY
? 0 : DEFAULT_FIXED_LATENCY
;
305 PA_LLIST_HEAD_INIT(pa_source_volume_change
, s
->thread_info
.volume_changes
);
306 s
->thread_info
.volume_changes_tail
= NULL
;
307 pa_sw_cvolume_multiply(&s
->thread_info
.current_hw_volume
, &s
->soft_volume
, &s
->real_volume
);
308 s
->thread_info
.volume_change_safety_margin
= core
->sync_volume_safety_margin_usec
;
309 s
->thread_info
.volume_change_extra_delay
= core
->sync_volume_extra_delay_usec
;
311 /* FIXME: This should probably be moved to pa_source_put() */
312 pa_assert_se(pa_idxset_put(core
->sources
, s
, &s
->index
) >= 0);
315 pa_assert_se(pa_idxset_put(s
->card
->sources
, s
, NULL
) >= 0);
317 pt
= pa_proplist_to_string_sep(s
->proplist
, "\n ");
318 pa_log_info("Created source %u \"%s\" with sample spec %s and channel map %s\n %s",
321 pa_sample_spec_snprint(st
, sizeof(st
), &s
->sample_spec
),
322 pa_channel_map_snprint(cm
, sizeof(cm
), &s
->channel_map
),
329 /* Called from main context */
330 static int source_set_state(pa_source
*s
, pa_source_state_t state
) {
332 pa_bool_t suspend_change
;
333 pa_source_state_t original_state
;
336 pa_assert_ctl_context();
338 if (s
->state
== state
)
341 original_state
= s
->state
;
344 (original_state
== PA_SOURCE_SUSPENDED
&& PA_SOURCE_IS_OPENED(state
)) ||
345 (PA_SOURCE_IS_OPENED(original_state
) && state
== PA_SOURCE_SUSPENDED
);
348 if ((ret
= s
->set_state(s
, state
)) < 0)
352 if ((ret
= pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_STATE
, PA_UINT_TO_PTR(state
), 0, NULL
)) < 0) {
355 s
->set_state(s
, original_state
);
362 if (state
!= PA_SOURCE_UNLINKED
) { /* if we enter UNLINKED state pa_source_unlink() will fire the apropriate events */
363 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_STATE_CHANGED
], s
);
364 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
| PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
367 if (suspend_change
) {
371 /* We're suspending or resuming, tell everyone about it */
373 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
)
374 if (s
->state
== PA_SOURCE_SUSPENDED
&&
375 (o
->flags
& PA_SOURCE_OUTPUT_KILL_ON_SUSPEND
))
376 pa_source_output_kill(o
);
378 o
->suspend(o
, state
== PA_SOURCE_SUSPENDED
);
384 void pa_source_set_get_volume_callback(pa_source
*s
, pa_source_cb_t cb
) {
390 void pa_source_set_set_volume_callback(pa_source
*s
, pa_source_cb_t cb
) {
391 pa_source_flags_t flags
;
394 pa_assert(!s
->write_volume
|| cb
);
398 /* Save the current flags so we can tell if they've changed */
402 /* The source implementor is responsible for setting decibel volume support */
403 s
->flags
|= PA_SOURCE_HW_VOLUME_CTRL
;
405 s
->flags
&= ~PA_SOURCE_HW_VOLUME_CTRL
;
406 /* See note below in pa_source_put() about volume sharing and decibel volumes */
407 pa_source_enable_decibel_volume(s
, !(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
));
410 /* If the flags have changed after init, let any clients know via a change event */
411 if (s
->state
!= PA_SOURCE_INIT
&& flags
!= s
->flags
)
412 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
415 void pa_source_set_write_volume_callback(pa_source
*s
, pa_source_cb_t cb
) {
416 pa_source_flags_t flags
;
419 pa_assert(!cb
|| s
->set_volume
);
421 s
->write_volume
= cb
;
423 /* Save the current flags so we can tell if they've changed */
427 s
->flags
|= PA_SOURCE_SYNC_VOLUME
;
429 s
->flags
&= ~PA_SOURCE_SYNC_VOLUME
;
431 /* If the flags have changed after init, let any clients know via a change event */
432 if (s
->state
!= PA_SOURCE_INIT
&& flags
!= s
->flags
)
433 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
436 void pa_source_set_get_mute_callback(pa_source
*s
, pa_source_cb_t cb
) {
442 void pa_source_set_set_mute_callback(pa_source
*s
, pa_source_cb_t cb
) {
443 pa_source_flags_t flags
;
449 /* Save the current flags so we can tell if they've changed */
453 s
->flags
|= PA_SOURCE_HW_MUTE_CTRL
;
455 s
->flags
&= ~PA_SOURCE_HW_MUTE_CTRL
;
457 /* If the flags have changed after init, let any clients know via a change event */
458 if (s
->state
!= PA_SOURCE_INIT
&& flags
!= s
->flags
)
459 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
462 static void enable_flat_volume(pa_source
*s
, pa_bool_t enable
) {
463 pa_source_flags_t flags
;
467 /* Always follow the overall user preference here */
468 enable
= enable
&& s
->core
->flat_volumes
;
470 /* Save the current flags so we can tell if they've changed */
474 s
->flags
|= PA_SOURCE_FLAT_VOLUME
;
476 s
->flags
&= ~PA_SOURCE_FLAT_VOLUME
;
478 /* If the flags have changed after init, let any clients know via a change event */
479 if (s
->state
!= PA_SOURCE_INIT
&& flags
!= s
->flags
)
480 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
483 void pa_source_enable_decibel_volume(pa_source
*s
, pa_bool_t enable
) {
484 pa_source_flags_t flags
;
488 /* Save the current flags so we can tell if they've changed */
492 s
->flags
|= PA_SOURCE_DECIBEL_VOLUME
;
493 enable_flat_volume(s
, TRUE
);
495 s
->flags
&= ~PA_SOURCE_DECIBEL_VOLUME
;
496 enable_flat_volume(s
, FALSE
);
499 /* If the flags have changed after init, let any clients know via a change event */
500 if (s
->state
!= PA_SOURCE_INIT
&& flags
!= s
->flags
)
501 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
504 /* Called from main context */
505 void pa_source_put(pa_source
*s
) {
506 pa_source_assert_ref(s
);
507 pa_assert_ctl_context();
509 pa_assert(s
->state
== PA_SOURCE_INIT
);
510 pa_assert(!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
) || s
->output_from_master
);
512 /* The following fields must be initialized properly when calling _put() */
513 pa_assert(s
->asyncmsgq
);
514 pa_assert(s
->thread_info
.min_latency
<= s
->thread_info
.max_latency
);
516 /* Generally, flags should be initialized via pa_source_new(). As a
517 * special exception we allow some volume related flags to be set
518 * between _new() and _put() by the callback setter functions above.
520 * Thus we implement a couple safeguards here which ensure the above
521 * setters were used (or at least the implementor made manual changes
522 * in a compatible way).
524 * Note: All of these flags set here can change over the life time
526 pa_assert(!(s
->flags
& PA_SOURCE_HW_VOLUME_CTRL
) || s
->set_volume
);
527 pa_assert(!(s
->flags
& PA_SOURCE_SYNC_VOLUME
) || s
->write_volume
);
528 pa_assert(!(s
->flags
& PA_SOURCE_HW_MUTE_CTRL
) || s
->set_mute
);
530 /* XXX: Currently decibel volume is disabled for all sources that use volume
531 * sharing. When the master source supports decibel volume, it would be good
532 * to have the flag also in the filter source, but currently we don't do that
533 * so that the flags of the filter source never change when it's moved from
534 * a master source to another. One solution for this problem would be to
535 * remove user-visible volume altogether from filter sources when volume
536 * sharing is used, but the current approach was easier to implement... */
537 /* We always support decibel volumes in software, otherwise we leave it to
538 * the source implementor to set this flag as needed.
540 * Note: This flag can also change over the life time of the source. */
541 if (!(s
->flags
& PA_SOURCE_HW_VOLUME_CTRL
) && !(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
542 pa_source_enable_decibel_volume(s
, TRUE
);
544 /* If the source implementor support DB volumes by itself, we should always
545 * try and enable flat volumes too */
546 if ((s
->flags
& PA_SOURCE_DECIBEL_VOLUME
))
547 enable_flat_volume(s
, TRUE
);
549 if (s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
) {
550 pa_source
*root_source
= s
->output_from_master
->source
;
552 while (root_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)
553 root_source
= root_source
->output_from_master
->source
;
555 s
->reference_volume
= root_source
->reference_volume
;
556 pa_cvolume_remap(&s
->reference_volume
, &root_source
->channel_map
, &s
->channel_map
);
558 s
->real_volume
= root_source
->real_volume
;
559 pa_cvolume_remap(&s
->real_volume
, &root_source
->channel_map
, &s
->channel_map
);
561 /* We assume that if the sink implementor changed the default
562 * volume he did so in real_volume, because that is the usual
563 * place where he is supposed to place his changes. */
564 s
->reference_volume
= s
->real_volume
;
566 s
->thread_info
.soft_volume
= s
->soft_volume
;
567 s
->thread_info
.soft_muted
= s
->muted
;
568 pa_sw_cvolume_multiply(&s
->thread_info
.current_hw_volume
, &s
->soft_volume
, &s
->real_volume
);
570 pa_assert((s
->flags
& PA_SOURCE_HW_VOLUME_CTRL
)
571 || (s
->base_volume
== PA_VOLUME_NORM
572 && ((s
->flags
& PA_SOURCE_DECIBEL_VOLUME
|| (s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)))));
573 pa_assert(!(s
->flags
& PA_SOURCE_DECIBEL_VOLUME
) || s
->n_volume_steps
== PA_VOLUME_NORM
+1);
574 pa_assert(!(s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
) == (s
->thread_info
.fixed_latency
!= 0));
576 pa_assert_se(source_set_state(s
, PA_SOURCE_IDLE
) == 0);
578 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
| PA_SUBSCRIPTION_EVENT_NEW
, s
->index
);
579 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_PUT
], s
);
582 /* Called from main context */
583 void pa_source_unlink(pa_source
*s
) {
585 pa_source_output
*o
, *j
= NULL
;
588 pa_assert_ctl_context();
590 /* See pa_sink_unlink() for a couple of comments how this function
593 linked
= PA_SOURCE_IS_LINKED(s
->state
);
596 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_UNLINK
], s
);
598 if (s
->state
!= PA_SOURCE_UNLINKED
)
599 pa_namereg_unregister(s
->core
, s
->name
);
600 pa_idxset_remove_by_data(s
->core
->sources
, s
, NULL
);
603 pa_idxset_remove_by_data(s
->card
->sources
, s
, NULL
);
605 while ((o
= pa_idxset_first(s
->outputs
, NULL
))) {
607 pa_source_output_kill(o
);
612 source_set_state(s
, PA_SOURCE_UNLINKED
);
614 s
->state
= PA_SOURCE_UNLINKED
;
619 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
| PA_SUBSCRIPTION_EVENT_REMOVE
, s
->index
);
620 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_UNLINK_POST
], s
);
624 /* Called from main context */
625 static void source_free(pa_object
*o
) {
626 pa_source_output
*so
;
627 pa_source
*s
= PA_SOURCE(o
);
630 pa_assert_ctl_context();
631 pa_assert(pa_source_refcnt(s
) == 0);
633 if (PA_SOURCE_IS_LINKED(s
->state
))
636 pa_log_info("Freeing source %u \"%s\"", s
->index
, s
->name
);
638 pa_idxset_free(s
->outputs
, NULL
, NULL
);
640 while ((so
= pa_hashmap_steal_first(s
->thread_info
.outputs
)))
641 pa_source_output_unref(so
);
643 pa_hashmap_free(s
->thread_info
.outputs
, NULL
, NULL
);
645 if (s
->silence
.memblock
)
646 pa_memblock_unref(s
->silence
.memblock
);
652 pa_proplist_free(s
->proplist
);
657 while ((p
= pa_hashmap_steal_first(s
->ports
)))
658 pa_device_port_free(p
);
660 pa_hashmap_free(s
->ports
, NULL
, NULL
);
666 /* Called from main context, and not while the IO thread is active, please */
667 void pa_source_set_asyncmsgq(pa_source
*s
, pa_asyncmsgq
*q
) {
668 pa_source_assert_ref(s
);
669 pa_assert_ctl_context();
674 /* Called from main context, and not while the IO thread is active, please */
675 void pa_source_update_flags(pa_source
*s
, pa_source_flags_t mask
, pa_source_flags_t value
) {
676 pa_source_assert_ref(s
);
677 pa_assert_ctl_context();
682 /* For now, allow only a minimal set of flags to be changed. */
683 pa_assert((mask
& ~(PA_SOURCE_DYNAMIC_LATENCY
|PA_SOURCE_LATENCY
)) == 0);
685 s
->flags
= (s
->flags
& ~mask
) | (value
& mask
);
688 /* Called from IO context, or before _put() from main context */
689 void pa_source_set_rtpoll(pa_source
*s
, pa_rtpoll
*p
) {
690 pa_source_assert_ref(s
);
691 pa_source_assert_io_context(s
);
693 s
->thread_info
.rtpoll
= p
;
696 /* Called from main context */
697 int pa_source_update_status(pa_source
*s
) {
698 pa_source_assert_ref(s
);
699 pa_assert_ctl_context();
700 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
702 if (s
->state
== PA_SOURCE_SUSPENDED
)
705 return source_set_state(s
, pa_source_used_by(s
) ? PA_SOURCE_RUNNING
: PA_SOURCE_IDLE
);
708 /* Called from main context */
709 int pa_source_suspend(pa_source
*s
, pa_bool_t suspend
, pa_suspend_cause_t cause
) {
710 pa_source_assert_ref(s
);
711 pa_assert_ctl_context();
712 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
713 pa_assert(cause
!= 0);
715 if (s
->monitor_of
&& cause
!= PA_SUSPEND_PASSTHROUGH
)
716 return -PA_ERR_NOTSUPPORTED
;
719 s
->suspend_cause
|= cause
;
721 s
->suspend_cause
&= ~cause
;
723 if ((pa_source_get_state(s
) == PA_SOURCE_SUSPENDED
) == !!s
->suspend_cause
)
726 pa_log_debug("Suspend cause of source %s is 0x%04x, %s", s
->name
, s
->suspend_cause
, s
->suspend_cause
? "suspending" : "resuming");
728 if (s
->suspend_cause
)
729 return source_set_state(s
, PA_SOURCE_SUSPENDED
);
731 return source_set_state(s
, pa_source_used_by(s
) ? PA_SOURCE_RUNNING
: PA_SOURCE_IDLE
);
734 /* Called from main context */
735 int pa_source_sync_suspend(pa_source
*s
) {
736 pa_sink_state_t state
;
738 pa_source_assert_ref(s
);
739 pa_assert_ctl_context();
740 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
741 pa_assert(s
->monitor_of
);
743 state
= pa_sink_get_state(s
->monitor_of
);
745 if (state
== PA_SINK_SUSPENDED
)
746 return source_set_state(s
, PA_SOURCE_SUSPENDED
);
748 pa_assert(PA_SINK_IS_OPENED(state
));
750 return source_set_state(s
, pa_source_used_by(s
) ? PA_SOURCE_RUNNING
: PA_SOURCE_IDLE
);
753 /* Called from main context */
754 pa_queue
*pa_source_move_all_start(pa_source
*s
, pa_queue
*q
) {
755 pa_source_output
*o
, *n
;
758 pa_source_assert_ref(s
);
759 pa_assert_ctl_context();
760 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
765 for (o
= PA_SOURCE_OUTPUT(pa_idxset_first(s
->outputs
, &idx
)); o
; o
= n
) {
766 n
= PA_SOURCE_OUTPUT(pa_idxset_next(s
->outputs
, &idx
));
768 pa_source_output_ref(o
);
770 if (pa_source_output_start_move(o
) >= 0)
773 pa_source_output_unref(o
);
779 /* Called from main context */
780 void pa_source_move_all_finish(pa_source
*s
, pa_queue
*q
, pa_bool_t save
) {
783 pa_source_assert_ref(s
);
784 pa_assert_ctl_context();
785 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
788 while ((o
= PA_SOURCE_OUTPUT(pa_queue_pop(q
)))) {
789 if (pa_source_output_finish_move(o
, s
, save
) < 0)
790 pa_source_output_fail_move(o
);
792 pa_source_output_unref(o
);
795 pa_queue_free(q
, NULL
, NULL
);
798 /* Called from main context */
799 void pa_source_move_all_fail(pa_queue
*q
) {
802 pa_assert_ctl_context();
805 while ((o
= PA_SOURCE_OUTPUT(pa_queue_pop(q
)))) {
806 pa_source_output_fail_move(o
);
807 pa_source_output_unref(o
);
810 pa_queue_free(q
, NULL
, NULL
);
813 /* Called from IO thread context */
814 void pa_source_process_rewind(pa_source
*s
, size_t nbytes
) {
818 pa_source_assert_ref(s
);
819 pa_source_assert_io_context(s
);
820 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
825 if (s
->thread_info
.state
== PA_SOURCE_SUSPENDED
)
828 pa_log_debug("Processing rewind...");
830 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
) {
831 pa_source_output_assert_ref(o
);
832 pa_source_output_process_rewind(o
, nbytes
);
836 /* Called from IO thread context */
837 void pa_source_post(pa_source
*s
, const pa_memchunk
*chunk
) {
841 pa_source_assert_ref(s
);
842 pa_source_assert_io_context(s
);
843 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
846 if (s
->thread_info
.state
== PA_SOURCE_SUSPENDED
)
849 if (s
->thread_info
.soft_muted
|| !pa_cvolume_is_norm(&s
->thread_info
.soft_volume
)) {
850 pa_memchunk vchunk
= *chunk
;
852 pa_memblock_ref(vchunk
.memblock
);
853 pa_memchunk_make_writable(&vchunk
, 0);
855 if (s
->thread_info
.soft_muted
|| pa_cvolume_is_muted(&s
->thread_info
.soft_volume
))
856 pa_silence_memchunk(&vchunk
, &s
->sample_spec
);
858 pa_volume_memchunk(&vchunk
, &s
->sample_spec
, &s
->thread_info
.soft_volume
);
860 while ((o
= pa_hashmap_iterate(s
->thread_info
.outputs
, &state
, NULL
))) {
861 pa_source_output_assert_ref(o
);
863 if (!o
->thread_info
.direct_on_input
)
864 pa_source_output_push(o
, &vchunk
);
867 pa_memblock_unref(vchunk
.memblock
);
870 while ((o
= pa_hashmap_iterate(s
->thread_info
.outputs
, &state
, NULL
))) {
871 pa_source_output_assert_ref(o
);
873 if (!o
->thread_info
.direct_on_input
)
874 pa_source_output_push(o
, chunk
);
879 /* Called from IO thread context */
880 void pa_source_post_direct(pa_source
*s
, pa_source_output
*o
, const pa_memchunk
*chunk
) {
881 pa_source_assert_ref(s
);
882 pa_source_assert_io_context(s
);
883 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
884 pa_source_output_assert_ref(o
);
885 pa_assert(o
->thread_info
.direct_on_input
);
888 if (s
->thread_info
.state
== PA_SOURCE_SUSPENDED
)
891 if (s
->thread_info
.soft_muted
|| !pa_cvolume_is_norm(&s
->thread_info
.soft_volume
)) {
892 pa_memchunk vchunk
= *chunk
;
894 pa_memblock_ref(vchunk
.memblock
);
895 pa_memchunk_make_writable(&vchunk
, 0);
897 if (s
->thread_info
.soft_muted
|| pa_cvolume_is_muted(&s
->thread_info
.soft_volume
))
898 pa_silence_memchunk(&vchunk
, &s
->sample_spec
);
900 pa_volume_memchunk(&vchunk
, &s
->sample_spec
, &s
->thread_info
.soft_volume
);
902 pa_source_output_push(o
, &vchunk
);
904 pa_memblock_unref(vchunk
.memblock
);
906 pa_source_output_push(o
, chunk
);
909 /* Called from main thread */
910 pa_usec_t
pa_source_get_latency(pa_source
*s
) {
913 pa_source_assert_ref(s
);
914 pa_assert_ctl_context();
915 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
917 if (s
->state
== PA_SOURCE_SUSPENDED
)
920 if (!(s
->flags
& PA_SOURCE_LATENCY
))
923 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_LATENCY
, &usec
, 0, NULL
) == 0);
928 /* Called from IO thread */
929 pa_usec_t
pa_source_get_latency_within_thread(pa_source
*s
) {
933 pa_source_assert_ref(s
);
934 pa_source_assert_io_context(s
);
935 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
937 /* The returned value is supposed to be in the time domain of the sound card! */
939 if (s
->thread_info
.state
== PA_SOURCE_SUSPENDED
)
942 if (!(s
->flags
& PA_SOURCE_LATENCY
))
947 /* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
949 if (o
->process_msg(o
, PA_SOURCE_MESSAGE_GET_LATENCY
, &usec
, 0, NULL
) < 0)
955 /* Called from the main thread (and also from the IO thread while the main
956 * thread is waiting).
958 * When a source uses volume sharing, it never has the PA_SOURCE_FLAT_VOLUME flag
959 * set. Instead, flat volume mode is detected by checking whether the root source
960 * has the flag set. */
961 pa_bool_t
pa_source_flat_volume_enabled(pa_source
*s
) {
962 pa_source_assert_ref(s
);
964 while (s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)
965 s
= s
->output_from_master
->source
;
967 return (s
->flags
& PA_SOURCE_FLAT_VOLUME
);
970 /* Called from main context */
971 pa_bool_t
pa_source_is_passthrough(pa_source
*s
) {
973 pa_source_assert_ref(s
);
975 /* NB Currently only monitor sources support passthrough mode */
976 return (s
->monitor_of
&& pa_sink_is_passthrough(s
->monitor_of
));
979 /* Called from main context. */
980 static void compute_reference_ratio(pa_source_output
*o
) {
985 pa_assert(pa_source_flat_volume_enabled(o
->source
));
988 * Calculates the reference ratio from the source's reference
989 * volume. This basically calculates:
991 * o->reference_ratio = o->volume / o->source->reference_volume
994 remapped
= o
->source
->reference_volume
;
995 pa_cvolume_remap(&remapped
, &o
->source
->channel_map
, &o
->channel_map
);
997 o
->reference_ratio
.channels
= o
->sample_spec
.channels
;
999 for (c
= 0; c
< o
->sample_spec
.channels
; c
++) {
1001 /* We don't update when the source volume is 0 anyway */
1002 if (remapped
.values
[c
] <= PA_VOLUME_MUTED
)
1005 /* Don't update the reference ratio unless necessary */
1006 if (pa_sw_volume_multiply(
1007 o
->reference_ratio
.values
[c
],
1008 remapped
.values
[c
]) == o
->volume
.values
[c
])
1011 o
->reference_ratio
.values
[c
] = pa_sw_volume_divide(
1012 o
->volume
.values
[c
],
1013 remapped
.values
[c
]);
1017 /* Called from main context. Only called for the root source in volume sharing
1018 * cases, except for internal recursive calls. */
1019 static void compute_reference_ratios(pa_source
*s
) {
1021 pa_source_output
*o
;
1023 pa_source_assert_ref(s
);
1024 pa_assert_ctl_context();
1025 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1026 pa_assert(pa_source_flat_volume_enabled(s
));
1028 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1029 compute_reference_ratio(o
);
1031 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
1032 compute_reference_ratios(o
->destination_source
);
1036 /* Called from main context. Only called for the root source in volume sharing
1037 * cases, except for internal recursive calls. */
1038 static void compute_real_ratios(pa_source
*s
) {
1039 pa_source_output
*o
;
1042 pa_source_assert_ref(s
);
1043 pa_assert_ctl_context();
1044 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1045 pa_assert(pa_source_flat_volume_enabled(s
));
1047 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1049 pa_cvolume remapped
;
1051 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)) {
1052 /* The origin source uses volume sharing, so this input's real ratio
1053 * is handled as a special case - the real ratio must be 0 dB, and
1054 * as a result i->soft_volume must equal i->volume_factor. */
1055 pa_cvolume_reset(&o
->real_ratio
, o
->real_ratio
.channels
);
1056 o
->soft_volume
= o
->volume_factor
;
1058 compute_real_ratios(o
->destination_source
);
1064 * This basically calculates:
1066 * i->real_ratio := i->volume / s->real_volume
1067 * i->soft_volume := i->real_ratio * i->volume_factor
1070 remapped
= s
->real_volume
;
1071 pa_cvolume_remap(&remapped
, &s
->channel_map
, &o
->channel_map
);
1073 o
->real_ratio
.channels
= o
->sample_spec
.channels
;
1074 o
->soft_volume
.channels
= o
->sample_spec
.channels
;
1076 for (c
= 0; c
< o
->sample_spec
.channels
; c
++) {
1078 if (remapped
.values
[c
] <= PA_VOLUME_MUTED
) {
1079 /* We leave o->real_ratio untouched */
1080 o
->soft_volume
.values
[c
] = PA_VOLUME_MUTED
;
1084 /* Don't lose accuracy unless necessary */
1085 if (pa_sw_volume_multiply(
1086 o
->real_ratio
.values
[c
],
1087 remapped
.values
[c
]) != o
->volume
.values
[c
])
1089 o
->real_ratio
.values
[c
] = pa_sw_volume_divide(
1090 o
->volume
.values
[c
],
1091 remapped
.values
[c
]);
1093 o
->soft_volume
.values
[c
] = pa_sw_volume_multiply(
1094 o
->real_ratio
.values
[c
],
1095 o
->volume_factor
.values
[c
]);
1098 /* We don't copy the soft_volume to the thread_info data
1099 * here. That must be done by the caller */
1103 static pa_cvolume
*cvolume_remap_minimal_impact(
1105 const pa_cvolume
*template,
1106 const pa_channel_map
*from
,
1107 const pa_channel_map
*to
) {
1112 pa_assert(template);
1115 pa_assert(pa_cvolume_compatible_with_channel_map(v
, from
));
1116 pa_assert(pa_cvolume_compatible_with_channel_map(template, to
));
1118 /* Much like pa_cvolume_remap(), but tries to minimize impact when
1119 * mapping from source output to source volumes:
1121 * If template is a possible remapping from v it is used instead
1122 * of remapping anew.
1124 * If the channel maps don't match we set an all-channel volume on
1125 * the source to ensure that changing a volume on one stream has no
1126 * effect that cannot be compensated for in another stream that
1127 * does not have the same channel map as the source. */
1129 if (pa_channel_map_equal(from
, to
))
1133 if (pa_cvolume_equal(pa_cvolume_remap(&t
, to
, from
), v
)) {
1138 pa_cvolume_set(v
, to
->channels
, pa_cvolume_max(v
));
1142 /* Called from main thread. Only called for the root source in volume sharing
1143 * cases, except for internal recursive calls. */
1144 static void get_maximum_output_volume(pa_source
*s
, pa_cvolume
*max_volume
, const pa_channel_map
*channel_map
) {
1145 pa_source_output
*o
;
1148 pa_source_assert_ref(s
);
1149 pa_assert(max_volume
);
1150 pa_assert(channel_map
);
1151 pa_assert(pa_source_flat_volume_enabled(s
));
1153 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1154 pa_cvolume remapped
;
1156 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)) {
1157 get_maximum_output_volume(o
->destination_source
, max_volume
, channel_map
);
1159 /* Ignore this output. The origin source uses volume sharing, so this
1160 * output's volume will be set to be equal to the root source's real
1161 * volume. Obviously this outputs's current volume must not then
1162 * affect what the root source's real volume will be. */
1166 remapped
= o
->volume
;
1167 cvolume_remap_minimal_impact(&remapped
, max_volume
, &o
->channel_map
, channel_map
);
1168 pa_cvolume_merge(max_volume
, max_volume
, &remapped
);
1172 /* Called from main thread. Only called for the root source in volume sharing
1173 * cases, except for internal recursive calls. */
1174 static pa_bool_t
has_outputs(pa_source
*s
) {
1175 pa_source_output
*o
;
1178 pa_source_assert_ref(s
);
1180 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1181 if (!o
->destination_source
|| !(o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
) || has_outputs(o
->destination_source
))
1188 /* Called from main thread. Only called for the root source in volume sharing
1189 * cases, except for internal recursive calls. */
1190 static void update_real_volume(pa_source
*s
, const pa_cvolume
*new_volume
, pa_channel_map
*channel_map
) {
1191 pa_source_output
*o
;
1194 pa_source_assert_ref(s
);
1195 pa_assert(new_volume
);
1196 pa_assert(channel_map
);
1198 s
->real_volume
= *new_volume
;
1199 pa_cvolume_remap(&s
->real_volume
, channel_map
, &s
->channel_map
);
1201 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1202 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)) {
1203 if (pa_source_flat_volume_enabled(s
)) {
1204 pa_cvolume old_volume
= o
->volume
;
1206 /* Follow the root source's real volume. */
1207 o
->volume
= *new_volume
;
1208 pa_cvolume_remap(&o
->volume
, channel_map
, &o
->channel_map
);
1209 compute_reference_ratio(o
);
1211 /* The volume changed, let's tell people so */
1212 if (!pa_cvolume_equal(&old_volume
, &o
->volume
)) {
1213 if (o
->volume_changed
)
1214 o
->volume_changed(o
);
1216 pa_subscription_post(o
->core
, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, o
->index
);
1220 update_real_volume(o
->destination_source
, new_volume
, channel_map
);
1225 /* Called from main thread. Only called for the root source in shared volume
1227 static void compute_real_volume(pa_source
*s
) {
1228 pa_source_assert_ref(s
);
1229 pa_assert_ctl_context();
1230 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1231 pa_assert(pa_source_flat_volume_enabled(s
));
1232 pa_assert(!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
));
1234 /* This determines the maximum volume of all streams and sets
1235 * s->real_volume accordingly. */
1237 if (!has_outputs(s
)) {
1238 /* In the special case that we have no source outputs we leave the
1239 * volume unmodified. */
1240 update_real_volume(s
, &s
->reference_volume
, &s
->channel_map
);
1244 pa_cvolume_mute(&s
->real_volume
, s
->channel_map
.channels
);
1246 /* First let's determine the new maximum volume of all outputs
1247 * connected to this source */
1248 get_maximum_output_volume(s
, &s
->real_volume
, &s
->channel_map
);
1249 update_real_volume(s
, &s
->real_volume
, &s
->channel_map
);
1251 /* Then, let's update the real ratios/soft volumes of all outputs
1252 * connected to this source */
1253 compute_real_ratios(s
);
1256 /* Called from main thread. Only called for the root source in shared volume
1257 * cases, except for internal recursive calls. */
1258 static void propagate_reference_volume(pa_source
*s
) {
1259 pa_source_output
*o
;
1262 pa_source_assert_ref(s
);
1263 pa_assert_ctl_context();
1264 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1265 pa_assert(pa_source_flat_volume_enabled(s
));
1267 /* This is called whenever the source volume changes that is not
1268 * caused by a source output volume change. We need to fix up the
1269 * source output volumes accordingly */
1271 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1272 pa_cvolume old_volume
;
1274 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)) {
1275 propagate_reference_volume(o
->destination_source
);
1277 /* Since the origin source uses volume sharing, this output's volume
1278 * needs to be updated to match the root source's real volume, but
1279 * that will be done later in update_shared_real_volume(). */
1283 old_volume
= o
->volume
;
1285 /* This basically calculates:
1287 * o->volume := o->reference_volume * o->reference_ratio */
1289 o
->volume
= s
->reference_volume
;
1290 pa_cvolume_remap(&o
->volume
, &s
->channel_map
, &o
->channel_map
);
1291 pa_sw_cvolume_multiply(&o
->volume
, &o
->volume
, &o
->reference_ratio
);
1293 /* The volume changed, let's tell people so */
1294 if (!pa_cvolume_equal(&old_volume
, &o
->volume
)) {
1296 if (o
->volume_changed
)
1297 o
->volume_changed(o
);
1299 pa_subscription_post(o
->core
, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, o
->index
);
1304 /* Called from main thread. Only called for the root source in volume sharing
1305 * cases, except for internal recursive calls. The return value indicates
1306 * whether any reference volume actually changed. */
1307 static pa_bool_t
update_reference_volume(pa_source
*s
, const pa_cvolume
*v
, const pa_channel_map
*channel_map
, pa_bool_t save
) {
1309 pa_bool_t reference_volume_changed
;
1310 pa_source_output
*o
;
1313 pa_source_assert_ref(s
);
1314 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1316 pa_assert(channel_map
);
1317 pa_assert(pa_cvolume_valid(v
));
1320 pa_cvolume_remap(&volume
, channel_map
, &s
->channel_map
);
1322 reference_volume_changed
= !pa_cvolume_equal(&volume
, &s
->reference_volume
);
1323 s
->reference_volume
= volume
;
1325 s
->save_volume
= (!reference_volume_changed
&& s
->save_volume
) || save
;
1327 if (reference_volume_changed
)
1328 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1329 else if (!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
1330 /* If the root source's volume doesn't change, then there can't be any
1331 * changes in the other source in the source tree either.
1333 * It's probably theoretically possible that even if the root source's
1334 * volume changes slightly, some filter source doesn't change its volume
1335 * due to rounding errors. If that happens, we still want to propagate
1336 * the changed root source volume to the sources connected to the
1337 * intermediate source that didn't change its volume. This theoretical
1338 * possiblity is the reason why we have that !(s->flags &
1339 * PA_SOURCE_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
1340 * notice even if we returned here FALSE always if
1341 * reference_volume_changed is FALSE. */
1344 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1345 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
1346 update_reference_volume(o
->destination_source
, v
, channel_map
, FALSE
);
1352 /* Called from main thread */
1353 void pa_source_set_volume(
1355 const pa_cvolume
*volume
,
1359 pa_cvolume new_reference_volume
;
1360 pa_source
*root_source
= s
;
1362 pa_source_assert_ref(s
);
1363 pa_assert_ctl_context();
1364 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1365 pa_assert(!volume
|| pa_cvolume_valid(volume
));
1366 pa_assert(volume
|| pa_source_flat_volume_enabled(s
));
1367 pa_assert(!volume
|| volume
->channels
== 1 || pa_cvolume_compatible(volume
, &s
->sample_spec
));
1369 /* make sure we don't change the volume when a PASSTHROUGH output is connected */
1370 if (pa_source_is_passthrough(s
)) {
1371 /* FIXME: Need to notify client that volume control is disabled */
1372 pa_log_warn("Cannot change volume, Source is monitor of a PASSTHROUGH sink");
1376 /* In case of volume sharing, the volume is set for the root source first,
1377 * from which it's then propagated to the sharing sources. */
1378 while (root_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)
1379 root_source
= root_source
->output_from_master
->source
;
1381 /* As a special exception we accept mono volumes on all sources --
1382 * even on those with more complex channel maps */
1385 if (pa_cvolume_compatible(volume
, &s
->sample_spec
))
1386 new_reference_volume
= *volume
;
1388 new_reference_volume
= s
->reference_volume
;
1389 pa_cvolume_scale(&new_reference_volume
, pa_cvolume_max(volume
));
1392 pa_cvolume_remap(&new_reference_volume
, &s
->channel_map
, &root_source
->channel_map
);
1395 /* If volume is NULL we synchronize the source's real and reference
1396 * volumes with the stream volumes. If it is not NULL we update
1397 * the reference_volume with it. */
1400 if (update_reference_volume(root_source
, &new_reference_volume
, &root_source
->channel_map
, save
)) {
1401 if (pa_source_flat_volume_enabled(root_source
)) {
1402 /* OK, propagate this volume change back to the outputs */
1403 propagate_reference_volume(root_source
);
1405 /* And now recalculate the real volume */
1406 compute_real_volume(root_source
);
1408 update_real_volume(root_source
, &root_source
->reference_volume
, &root_source
->channel_map
);
1412 pa_assert(pa_source_flat_volume_enabled(root_source
));
1414 /* Ok, let's determine the new real volume */
1415 compute_real_volume(root_source
);
1417 /* Let's 'push' the reference volume if necessary */
1418 pa_cvolume_merge(&new_reference_volume
, &s
->reference_volume
, &root_source
->real_volume
);
1419 update_reference_volume(root_source
, &new_reference_volume
, &root_source
->channel_map
, save
);
1421 /* Now that the reference volume is updated, we can update the streams'
1422 * reference ratios. */
1423 compute_reference_ratios(root_source
);
1426 if (root_source
->set_volume
) {
1427 /* If we have a function set_volume(), then we do not apply a
1428 * soft volume by default. However, set_volume() is free to
1429 * apply one to root_source->soft_volume */
1431 pa_cvolume_reset(&root_source
->soft_volume
, root_source
->sample_spec
.channels
);
1432 if (!(root_source
->flags
& PA_SOURCE_SYNC_VOLUME
))
1433 root_source
->set_volume(root_source
);
1436 /* If we have no function set_volume(), then the soft volume
1437 * becomes the real volume */
1438 root_source
->soft_volume
= root_source
->real_volume
;
1440 /* This tells the source that soft volume and/or real volume changed */
1442 pa_assert_se(pa_asyncmsgq_send(root_source
->asyncmsgq
, PA_MSGOBJECT(root_source
), PA_SOURCE_MESSAGE_SET_SHARED_VOLUME
, NULL
, 0, NULL
) == 0);
1445 /* Called from the io thread if sync volume is used, otherwise from the main thread.
1446 * Only to be called by source implementor */
1447 void pa_source_set_soft_volume(pa_source
*s
, const pa_cvolume
*volume
) {
1449 pa_source_assert_ref(s
);
1450 pa_assert(!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
));
1452 if (s
->flags
& PA_SOURCE_SYNC_VOLUME
)
1453 pa_source_assert_io_context(s
);
1455 pa_assert_ctl_context();
1458 pa_cvolume_reset(&s
->soft_volume
, s
->sample_spec
.channels
);
1460 s
->soft_volume
= *volume
;
1462 if (PA_SOURCE_IS_LINKED(s
->state
) && !(s
->flags
& PA_SOURCE_SYNC_VOLUME
))
1463 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_VOLUME
, NULL
, 0, NULL
) == 0);
1465 s
->thread_info
.soft_volume
= s
->soft_volume
;
1468 /* Called from the main thread. Only called for the root source in volume sharing
1469 * cases, except for internal recursive calls. */
1470 static void propagate_real_volume(pa_source
*s
, const pa_cvolume
*old_real_volume
) {
1471 pa_source_output
*o
;
1474 pa_source_assert_ref(s
);
1475 pa_assert(old_real_volume
);
1476 pa_assert_ctl_context();
1477 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1479 /* This is called when the hardware's real volume changes due to
1480 * some external event. We copy the real volume into our
1481 * reference volume and then rebuild the stream volumes based on
1482 * i->real_ratio which should stay fixed. */
1484 if (!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)) {
1485 if (pa_cvolume_equal(old_real_volume
, &s
->real_volume
))
1488 /* 1. Make the real volume the reference volume */
1489 update_reference_volume(s
, &s
->real_volume
, &s
->channel_map
, TRUE
);
1492 if (pa_source_flat_volume_enabled(s
)) {
1494 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1495 pa_cvolume old_volume
= o
->volume
;
1497 /* 2. Since the source's reference and real volumes are equal
1498 * now our ratios should be too. */
1499 o
->reference_ratio
= o
->real_ratio
;
1501 /* 3. Recalculate the new stream reference volume based on the
1502 * reference ratio and the sink's reference volume.
1504 * This basically calculates:
1506 * o->volume = s->reference_volume * o->reference_ratio
1508 * This is identical to propagate_reference_volume() */
1509 o
->volume
= s
->reference_volume
;
1510 pa_cvolume_remap(&o
->volume
, &s
->channel_map
, &o
->channel_map
);
1511 pa_sw_cvolume_multiply(&o
->volume
, &o
->volume
, &o
->reference_ratio
);
1513 /* Notify if something changed */
1514 if (!pa_cvolume_equal(&old_volume
, &o
->volume
)) {
1516 if (o
->volume_changed
)
1517 o
->volume_changed(o
);
1519 pa_subscription_post(o
->core
, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, o
->index
);
1522 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
1523 propagate_real_volume(o
->destination_source
, old_real_volume
);
1527 /* Something got changed in the hardware. It probably makes sense
1528 * to save changed hw settings given that hw volume changes not
1529 * triggered by PA are almost certainly done by the user. */
1530 if (!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
1531 s
->save_volume
= TRUE
;
1534 /* Called from io thread */
1535 void pa_source_update_volume_and_mute(pa_source
*s
) {
1537 pa_source_assert_io_context(s
);
1539 pa_asyncmsgq_post(pa_thread_mq_get()->outq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE
, NULL
, 0, NULL
, NULL
);
1542 /* Called from main thread */
1543 const pa_cvolume
*pa_source_get_volume(pa_source
*s
, pa_bool_t force_refresh
) {
1544 pa_source_assert_ref(s
);
1545 pa_assert_ctl_context();
1546 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1548 if (s
->refresh_volume
|| force_refresh
) {
1549 struct pa_cvolume old_real_volume
;
1551 pa_assert(!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
));
1553 old_real_volume
= s
->real_volume
;
1555 if (!(s
->flags
& PA_SOURCE_SYNC_VOLUME
) && s
->get_volume
)
1558 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_VOLUME
, NULL
, 0, NULL
) == 0);
1560 update_real_volume(s
, &s
->real_volume
, &s
->channel_map
);
1561 propagate_real_volume(s
, &old_real_volume
);
1564 return &s
->reference_volume
;
1567 /* Called from main thread. In volume sharing cases, only the root source may
1569 void pa_source_volume_changed(pa_source
*s
, const pa_cvolume
*new_real_volume
) {
1570 pa_cvolume old_real_volume
;
1572 pa_source_assert_ref(s
);
1573 pa_assert_ctl_context();
1574 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1575 pa_assert(!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
));
1577 /* The source implementor may call this if the volume changed to make sure everyone is notified */
1579 old_real_volume
= s
->real_volume
;
1580 update_real_volume(s
, new_real_volume
, &s
->channel_map
);
1581 propagate_real_volume(s
, &old_real_volume
);
1584 /* Called from main thread */
1585 void pa_source_set_mute(pa_source
*s
, pa_bool_t mute
, pa_bool_t save
) {
1586 pa_bool_t old_muted
;
1588 pa_source_assert_ref(s
);
1589 pa_assert_ctl_context();
1590 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1592 old_muted
= s
->muted
;
1594 s
->save_muted
= (old_muted
== s
->muted
&& s
->save_muted
) || save
;
1596 if (!(s
->flags
& PA_SOURCE_SYNC_VOLUME
) && s
->set_mute
)
1599 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_MUTE
, NULL
, 0, NULL
) == 0);
1601 if (old_muted
!= s
->muted
)
1602 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1605 /* Called from main thread */
1606 pa_bool_t
pa_source_get_mute(pa_source
*s
, pa_bool_t force_refresh
) {
1608 pa_source_assert_ref(s
);
1609 pa_assert_ctl_context();
1610 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1612 if (s
->refresh_muted
|| force_refresh
) {
1613 pa_bool_t old_muted
= s
->muted
;
1615 if (!(s
->flags
& PA_SOURCE_SYNC_VOLUME
) && s
->get_mute
)
1618 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_MUTE
, NULL
, 0, NULL
) == 0);
1620 if (old_muted
!= s
->muted
) {
1621 s
->save_muted
= TRUE
;
1623 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1625 /* Make sure the soft mute status stays in sync */
1626 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_MUTE
, NULL
, 0, NULL
) == 0);
1633 /* Called from main thread */
1634 void pa_source_mute_changed(pa_source
*s
, pa_bool_t new_muted
) {
1635 pa_source_assert_ref(s
);
1636 pa_assert_ctl_context();
1637 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1639 /* The source implementor may call this if the mute state changed to make sure everyone is notified */
1641 if (s
->muted
== new_muted
)
1644 s
->muted
= new_muted
;
1645 s
->save_muted
= TRUE
;
1647 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1650 /* Called from main thread */
1651 pa_bool_t
pa_source_update_proplist(pa_source
*s
, pa_update_mode_t mode
, pa_proplist
*p
) {
1652 pa_source_assert_ref(s
);
1653 pa_assert_ctl_context();
1656 pa_proplist_update(s
->proplist
, mode
, p
);
1658 if (PA_SOURCE_IS_LINKED(s
->state
)) {
1659 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED
], s
);
1660 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1666 /* Called from main thread */
1667 /* FIXME -- this should be dropped and be merged into pa_source_update_proplist() */
1668 void pa_source_set_description(pa_source
*s
, const char *description
) {
1670 pa_source_assert_ref(s
);
1671 pa_assert_ctl_context();
1673 if (!description
&& !pa_proplist_contains(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
))
1676 old
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1678 if (old
&& description
&& pa_streq(old
, description
))
1682 pa_proplist_sets(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
, description
);
1684 pa_proplist_unset(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1686 if (PA_SOURCE_IS_LINKED(s
->state
)) {
1687 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1688 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED
], s
);
1692 /* Called from main thread */
1693 unsigned pa_source_linked_by(pa_source
*s
) {
1694 pa_source_assert_ref(s
);
1695 pa_assert_ctl_context();
1696 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1698 return pa_idxset_size(s
->outputs
);
1701 /* Called from main thread */
1702 unsigned pa_source_used_by(pa_source
*s
) {
1705 pa_source_assert_ref(s
);
1706 pa_assert_ctl_context();
1707 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1709 ret
= pa_idxset_size(s
->outputs
);
1710 pa_assert(ret
>= s
->n_corked
);
1712 return ret
- s
->n_corked
;
1715 /* Called from main thread */
1716 unsigned pa_source_check_suspend(pa_source
*s
) {
1718 pa_source_output
*o
;
1721 pa_source_assert_ref(s
);
1722 pa_assert_ctl_context();
1724 if (!PA_SOURCE_IS_LINKED(s
->state
))
1729 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1730 pa_source_output_state_t st
;
1732 st
= pa_source_output_get_state(o
);
1734 /* We do not assert here. It is perfectly valid for a source output to
1735 * be in the INIT state (i.e. created, marked done but not yet put)
1736 * and we should not care if it's unlinked as it won't contribute
1737 * towarards our busy status.
1739 if (!PA_SOURCE_OUTPUT_IS_LINKED(st
))
1742 if (st
== PA_SOURCE_OUTPUT_CORKED
)
1745 if (o
->flags
& PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND
)
1754 /* Called from the IO thread */
1755 static void sync_output_volumes_within_thread(pa_source
*s
) {
1756 pa_source_output
*o
;
1759 pa_source_assert_ref(s
);
1760 pa_source_assert_io_context(s
);
1762 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
) {
1763 if (pa_cvolume_equal(&o
->thread_info
.soft_volume
, &o
->soft_volume
))
1766 o
->thread_info
.soft_volume
= o
->soft_volume
;
1767 //pa_source_output_request_rewind(o, 0, TRUE, FALSE, FALSE);
1771 /* Called from the IO thread. Only called for the root source in volume sharing
1772 * cases, except for internal recursive calls. */
1773 static void set_shared_volume_within_thread(pa_source
*s
) {
1774 pa_source_output
*o
;
1777 pa_source_assert_ref(s
);
1779 PA_MSGOBJECT(s
)->process_msg(PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED
, NULL
, 0, NULL
);
1781 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
) {
1782 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
1783 set_shared_volume_within_thread(o
->destination_source
);
1787 /* Called from IO thread, except when it is not */
1788 int pa_source_process_msg(pa_msgobject
*object
, int code
, void *userdata
, int64_t offset
, pa_memchunk
*chunk
) {
1789 pa_source
*s
= PA_SOURCE(object
);
1790 pa_source_assert_ref(s
);
1792 switch ((pa_source_message_t
) code
) {
1794 case PA_SOURCE_MESSAGE_ADD_OUTPUT
: {
1795 pa_source_output
*o
= PA_SOURCE_OUTPUT(userdata
);
1797 pa_hashmap_put(s
->thread_info
.outputs
, PA_UINT32_TO_PTR(o
->index
), pa_source_output_ref(o
));
1799 if (o
->direct_on_input
) {
1800 o
->thread_info
.direct_on_input
= o
->direct_on_input
;
1801 pa_hashmap_put(o
->thread_info
.direct_on_input
->thread_info
.direct_outputs
, PA_UINT32_TO_PTR(o
->index
), o
);
1804 pa_assert(!o
->thread_info
.attached
);
1805 o
->thread_info
.attached
= TRUE
;
1810 pa_source_output_set_state_within_thread(o
, o
->state
);
1812 if (o
->thread_info
.requested_source_latency
!= (pa_usec_t
) -1)
1813 pa_source_output_set_requested_latency_within_thread(o
, o
->thread_info
.requested_source_latency
);
1815 pa_source_output_update_max_rewind(o
, s
->thread_info
.max_rewind
);
1817 /* We don't just invalidate the requested latency here,
1818 * because if we are in a move we might need to fix up the
1819 * requested latency. */
1820 pa_source_output_set_requested_latency_within_thread(o
, o
->thread_info
.requested_source_latency
);
1822 /* In flat volume mode we need to update the volume as
1824 return object
->process_msg(object
, PA_SOURCE_MESSAGE_SET_SHARED_VOLUME
, NULL
, 0, NULL
);
1827 case PA_SOURCE_MESSAGE_REMOVE_OUTPUT
: {
1828 pa_source_output
*o
= PA_SOURCE_OUTPUT(userdata
);
1830 pa_source_output_set_state_within_thread(o
, o
->state
);
1835 pa_assert(o
->thread_info
.attached
);
1836 o
->thread_info
.attached
= FALSE
;
1838 if (o
->thread_info
.direct_on_input
) {
1839 pa_hashmap_remove(o
->thread_info
.direct_on_input
->thread_info
.direct_outputs
, PA_UINT32_TO_PTR(o
->index
));
1840 o
->thread_info
.direct_on_input
= NULL
;
1843 if (pa_hashmap_remove(s
->thread_info
.outputs
, PA_UINT32_TO_PTR(o
->index
)))
1844 pa_source_output_unref(o
);
1846 pa_source_invalidate_requested_latency(s
, TRUE
);
1848 /* In flat volume mode we need to update the volume as
1850 return object
->process_msg(object
, PA_SOURCE_MESSAGE_SET_SHARED_VOLUME
, NULL
, 0, NULL
);
1853 case PA_SOURCE_MESSAGE_SET_SHARED_VOLUME
: {
1854 pa_source
*root_source
= s
;
1856 while (root_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)
1857 root_source
= root_source
->output_from_master
->source
;
1859 set_shared_volume_within_thread(root_source
);
1863 case PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED
:
1865 if (s
->flags
& PA_SOURCE_SYNC_VOLUME
) {
1867 pa_source_volume_change_push(s
);
1869 /* Fall through ... */
1871 case PA_SOURCE_MESSAGE_SET_VOLUME
:
1873 if (!pa_cvolume_equal(&s
->thread_info
.soft_volume
, &s
->soft_volume
)) {
1874 s
->thread_info
.soft_volume
= s
->soft_volume
;
1877 /* Fall through ... */
1879 case PA_SOURCE_MESSAGE_SYNC_VOLUMES
:
1880 sync_output_volumes_within_thread(s
);
1883 case PA_SOURCE_MESSAGE_GET_VOLUME
:
1885 if ((s
->flags
& PA_SOURCE_SYNC_VOLUME
) && s
->get_volume
) {
1887 pa_source_volume_change_flush(s
);
1888 pa_sw_cvolume_divide(&s
->thread_info
.current_hw_volume
, &s
->real_volume
, &s
->soft_volume
);
1891 /* In case source implementor reset SW volume. */
1892 if (!pa_cvolume_equal(&s
->thread_info
.soft_volume
, &s
->soft_volume
)) {
1893 s
->thread_info
.soft_volume
= s
->soft_volume
;
1898 case PA_SOURCE_MESSAGE_SET_MUTE
:
1900 if (s
->thread_info
.soft_muted
!= s
->muted
) {
1901 s
->thread_info
.soft_muted
= s
->muted
;
1904 if (s
->flags
& PA_SOURCE_SYNC_VOLUME
&& s
->set_mute
)
1909 case PA_SOURCE_MESSAGE_GET_MUTE
:
1911 if (s
->flags
& PA_SOURCE_SYNC_VOLUME
&& s
->get_mute
)
1916 case PA_SOURCE_MESSAGE_SET_STATE
: {
1918 pa_bool_t suspend_change
=
1919 (s
->thread_info
.state
== PA_SOURCE_SUSPENDED
&& PA_SOURCE_IS_OPENED(PA_PTR_TO_UINT(userdata
))) ||
1920 (PA_SOURCE_IS_OPENED(s
->thread_info
.state
) && PA_PTR_TO_UINT(userdata
) == PA_SOURCE_SUSPENDED
);
1922 s
->thread_info
.state
= PA_PTR_TO_UINT(userdata
);
1924 if (suspend_change
) {
1925 pa_source_output
*o
;
1928 while ((o
= pa_hashmap_iterate(s
->thread_info
.outputs
, &state
, NULL
)))
1929 if (o
->suspend_within_thread
)
1930 o
->suspend_within_thread(o
, s
->thread_info
.state
== PA_SOURCE_SUSPENDED
);
1936 case PA_SOURCE_MESSAGE_DETACH
:
1938 /* Detach all streams */
1939 pa_source_detach_within_thread(s
);
1942 case PA_SOURCE_MESSAGE_ATTACH
:
1944 /* Reattach all streams */
1945 pa_source_attach_within_thread(s
);
1948 case PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY
: {
1950 pa_usec_t
*usec
= userdata
;
1951 *usec
= pa_source_get_requested_latency_within_thread(s
);
1953 /* Yes, that's right, the IO thread will see -1 when no
1954 * explicit requested latency is configured, the main
1955 * thread will see max_latency */
1956 if (*usec
== (pa_usec_t
) -1)
1957 *usec
= s
->thread_info
.max_latency
;
1962 case PA_SOURCE_MESSAGE_SET_LATENCY_RANGE
: {
1963 pa_usec_t
*r
= userdata
;
1965 pa_source_set_latency_range_within_thread(s
, r
[0], r
[1]);
1970 case PA_SOURCE_MESSAGE_GET_LATENCY_RANGE
: {
1971 pa_usec_t
*r
= userdata
;
1973 r
[0] = s
->thread_info
.min_latency
;
1974 r
[1] = s
->thread_info
.max_latency
;
1979 case PA_SOURCE_MESSAGE_GET_FIXED_LATENCY
:
1981 *((pa_usec_t
*) userdata
) = s
->thread_info
.fixed_latency
;
1984 case PA_SOURCE_MESSAGE_SET_FIXED_LATENCY
:
1986 pa_source_set_fixed_latency_within_thread(s
, (pa_usec_t
) offset
);
1989 case PA_SOURCE_MESSAGE_GET_MAX_REWIND
:
1991 *((size_t*) userdata
) = s
->thread_info
.max_rewind
;
1994 case PA_SOURCE_MESSAGE_SET_MAX_REWIND
:
1996 pa_source_set_max_rewind_within_thread(s
, (size_t) offset
);
1999 case PA_SOURCE_MESSAGE_GET_LATENCY
:
2001 if (s
->monitor_of
) {
2002 *((pa_usec_t
*) userdata
) = 0;
2006 /* Implementors need to overwrite this implementation! */
2009 case PA_SOURCE_MESSAGE_SET_PORT
:
2011 pa_assert(userdata
);
2013 struct source_message_set_port
*msg_data
= userdata
;
2014 msg_data
->ret
= s
->set_port(s
, msg_data
->port
);
2018 case PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE
:
2019 /* This message is sent from IO-thread and handled in main thread. */
2020 pa_assert_ctl_context();
2022 pa_source_get_volume(s
, TRUE
);
2023 pa_source_get_mute(s
, TRUE
);
2026 case PA_SOURCE_MESSAGE_MAX
:
2033 /* Called from main thread */
2034 int pa_source_suspend_all(pa_core
*c
, pa_bool_t suspend
, pa_suspend_cause_t cause
) {
2039 pa_core_assert_ref(c
);
2040 pa_assert_ctl_context();
2041 pa_assert(cause
!= 0);
2043 for (source
= PA_SOURCE(pa_idxset_first(c
->sources
, &idx
)); source
; source
= PA_SOURCE(pa_idxset_next(c
->sources
, &idx
))) {
2046 if (source
->monitor_of
)
2049 if ((r
= pa_source_suspend(source
, suspend
, cause
)) < 0)
2056 /* Called from main thread */
2057 void pa_source_detach(pa_source
*s
) {
2058 pa_source_assert_ref(s
);
2059 pa_assert_ctl_context();
2060 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
2062 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_DETACH
, NULL
, 0, NULL
) == 0);
2065 /* Called from main thread */
2066 void pa_source_attach(pa_source
*s
) {
2067 pa_source_assert_ref(s
);
2068 pa_assert_ctl_context();
2069 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
2071 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_ATTACH
, NULL
, 0, NULL
) == 0);
2074 /* Called from IO thread */
2075 void pa_source_detach_within_thread(pa_source
*s
) {
2076 pa_source_output
*o
;
2079 pa_source_assert_ref(s
);
2080 pa_source_assert_io_context(s
);
2081 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
2083 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2088 /* Called from IO thread */
2089 void pa_source_attach_within_thread(pa_source
*s
) {
2090 pa_source_output
*o
;
2093 pa_source_assert_ref(s
);
2094 pa_source_assert_io_context(s
);
2095 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
2097 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2102 /* Called from IO thread */
2103 pa_usec_t
pa_source_get_requested_latency_within_thread(pa_source
*s
) {
2104 pa_usec_t result
= (pa_usec_t
) -1;
2105 pa_source_output
*o
;
2108 pa_source_assert_ref(s
);
2109 pa_source_assert_io_context(s
);
2111 if (!(s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
))
2112 return PA_CLAMP(s
->thread_info
.fixed_latency
, s
->thread_info
.min_latency
, s
->thread_info
.max_latency
);
2114 if (s
->thread_info
.requested_latency_valid
)
2115 return s
->thread_info
.requested_latency
;
2117 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2118 if (o
->thread_info
.requested_source_latency
!= (pa_usec_t
) -1 &&
2119 (result
== (pa_usec_t
) -1 || result
> o
->thread_info
.requested_source_latency
))
2120 result
= o
->thread_info
.requested_source_latency
;
2122 if (result
!= (pa_usec_t
) -1)
2123 result
= PA_CLAMP(result
, s
->thread_info
.min_latency
, s
->thread_info
.max_latency
);
2125 if (PA_SOURCE_IS_LINKED(s
->thread_info
.state
)) {
2126 /* Only cache this if we are fully set up */
2127 s
->thread_info
.requested_latency
= result
;
2128 s
->thread_info
.requested_latency_valid
= TRUE
;
2134 /* Called from main thread */
2135 pa_usec_t
pa_source_get_requested_latency(pa_source
*s
) {
2138 pa_source_assert_ref(s
);
2139 pa_assert_ctl_context();
2140 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
2142 if (s
->state
== PA_SOURCE_SUSPENDED
)
2145 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY
, &usec
, 0, NULL
) == 0);
2150 /* Called from IO thread */
2151 void pa_source_set_max_rewind_within_thread(pa_source
*s
, size_t max_rewind
) {
2152 pa_source_output
*o
;
2155 pa_source_assert_ref(s
);
2156 pa_source_assert_io_context(s
);
2158 if (max_rewind
== s
->thread_info
.max_rewind
)
2161 s
->thread_info
.max_rewind
= max_rewind
;
2163 if (PA_SOURCE_IS_LINKED(s
->thread_info
.state
))
2164 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2165 pa_source_output_update_max_rewind(o
, s
->thread_info
.max_rewind
);
2168 /* Called from main thread */
2169 void pa_source_set_max_rewind(pa_source
*s
, size_t max_rewind
) {
2170 pa_source_assert_ref(s
);
2171 pa_assert_ctl_context();
2173 if (PA_SOURCE_IS_LINKED(s
->state
))
2174 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_MAX_REWIND
, NULL
, max_rewind
, NULL
) == 0);
2176 pa_source_set_max_rewind_within_thread(s
, max_rewind
);
2179 /* Called from IO thread */
2180 void pa_source_invalidate_requested_latency(pa_source
*s
, pa_bool_t dynamic
) {
2181 pa_source_output
*o
;
2184 pa_source_assert_ref(s
);
2185 pa_source_assert_io_context(s
);
2187 if ((s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
))
2188 s
->thread_info
.requested_latency_valid
= FALSE
;
2192 if (PA_SOURCE_IS_LINKED(s
->thread_info
.state
)) {
2194 if (s
->update_requested_latency
)
2195 s
->update_requested_latency(s
);
2197 while ((o
= pa_hashmap_iterate(s
->thread_info
.outputs
, &state
, NULL
)))
2198 if (o
->update_source_requested_latency
)
2199 o
->update_source_requested_latency(o
);
2203 pa_sink_invalidate_requested_latency(s
->monitor_of
, dynamic
);
2206 /* Called from main thread */
2207 void pa_source_set_latency_range(pa_source
*s
, pa_usec_t min_latency
, pa_usec_t max_latency
) {
2208 pa_source_assert_ref(s
);
2209 pa_assert_ctl_context();
2211 /* min_latency == 0: no limit
2212 * min_latency anything else: specified limit
2214 * Similar for max_latency */
2216 if (min_latency
< ABSOLUTE_MIN_LATENCY
)
2217 min_latency
= ABSOLUTE_MIN_LATENCY
;
2219 if (max_latency
<= 0 ||
2220 max_latency
> ABSOLUTE_MAX_LATENCY
)
2221 max_latency
= ABSOLUTE_MAX_LATENCY
;
2223 pa_assert(min_latency
<= max_latency
);
2225 /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2226 pa_assert((min_latency
== ABSOLUTE_MIN_LATENCY
&&
2227 max_latency
== ABSOLUTE_MAX_LATENCY
) ||
2228 (s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
));
2230 if (PA_SOURCE_IS_LINKED(s
->state
)) {
2236 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_LATENCY_RANGE
, r
, 0, NULL
) == 0);
2238 pa_source_set_latency_range_within_thread(s
, min_latency
, max_latency
);
2241 /* Called from main thread */
2242 void pa_source_get_latency_range(pa_source
*s
, pa_usec_t
*min_latency
, pa_usec_t
*max_latency
) {
2243 pa_source_assert_ref(s
);
2244 pa_assert_ctl_context();
2245 pa_assert(min_latency
);
2246 pa_assert(max_latency
);
2248 if (PA_SOURCE_IS_LINKED(s
->state
)) {
2249 pa_usec_t r
[2] = { 0, 0 };
2251 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_LATENCY_RANGE
, r
, 0, NULL
) == 0);
2253 *min_latency
= r
[0];
2254 *max_latency
= r
[1];
2256 *min_latency
= s
->thread_info
.min_latency
;
2257 *max_latency
= s
->thread_info
.max_latency
;
2261 /* Called from IO thread, and from main thread before pa_source_put() is called */
2262 void pa_source_set_latency_range_within_thread(pa_source
*s
, pa_usec_t min_latency
, pa_usec_t max_latency
) {
2263 pa_source_assert_ref(s
);
2264 pa_source_assert_io_context(s
);
2266 pa_assert(min_latency
>= ABSOLUTE_MIN_LATENCY
);
2267 pa_assert(max_latency
<= ABSOLUTE_MAX_LATENCY
);
2268 pa_assert(min_latency
<= max_latency
);
2270 /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2271 pa_assert((min_latency
== ABSOLUTE_MIN_LATENCY
&&
2272 max_latency
== ABSOLUTE_MAX_LATENCY
) ||
2273 (s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
) ||
2276 if (s
->thread_info
.min_latency
== min_latency
&&
2277 s
->thread_info
.max_latency
== max_latency
)
2280 s
->thread_info
.min_latency
= min_latency
;
2281 s
->thread_info
.max_latency
= max_latency
;
2283 if (PA_SOURCE_IS_LINKED(s
->thread_info
.state
)) {
2284 pa_source_output
*o
;
2287 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2288 if (o
->update_source_latency_range
)
2289 o
->update_source_latency_range(o
);
2292 pa_source_invalidate_requested_latency(s
, FALSE
);
2295 /* Called from main thread, before the source is put */
2296 void pa_source_set_fixed_latency(pa_source
*s
, pa_usec_t latency
) {
2297 pa_source_assert_ref(s
);
2298 pa_assert_ctl_context();
2300 if (s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
) {
2301 pa_assert(latency
== 0);
2305 if (latency
< ABSOLUTE_MIN_LATENCY
)
2306 latency
= ABSOLUTE_MIN_LATENCY
;
2308 if (latency
> ABSOLUTE_MAX_LATENCY
)
2309 latency
= ABSOLUTE_MAX_LATENCY
;
2311 if (PA_SOURCE_IS_LINKED(s
->state
))
2312 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_FIXED_LATENCY
, NULL
, (int64_t) latency
, NULL
) == 0);
2314 s
->thread_info
.fixed_latency
= latency
;
2317 /* Called from main thread */
2318 pa_usec_t
pa_source_get_fixed_latency(pa_source
*s
) {
2321 pa_source_assert_ref(s
);
2322 pa_assert_ctl_context();
2324 if (s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
)
2327 if (PA_SOURCE_IS_LINKED(s
->state
))
2328 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_FIXED_LATENCY
, &latency
, 0, NULL
) == 0);
2330 latency
= s
->thread_info
.fixed_latency
;
2335 /* Called from IO thread */
2336 void pa_source_set_fixed_latency_within_thread(pa_source
*s
, pa_usec_t latency
) {
2337 pa_source_assert_ref(s
);
2338 pa_source_assert_io_context(s
);
2340 if (s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
) {
2341 pa_assert(latency
== 0);
2345 pa_assert(latency
>= ABSOLUTE_MIN_LATENCY
);
2346 pa_assert(latency
<= ABSOLUTE_MAX_LATENCY
);
2348 if (s
->thread_info
.fixed_latency
== latency
)
2351 s
->thread_info
.fixed_latency
= latency
;
2353 if (PA_SOURCE_IS_LINKED(s
->thread_info
.state
)) {
2354 pa_source_output
*o
;
2357 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2358 if (o
->update_source_fixed_latency
)
2359 o
->update_source_fixed_latency(o
);
2362 pa_source_invalidate_requested_latency(s
, FALSE
);
2365 /* Called from main thread */
2366 size_t pa_source_get_max_rewind(pa_source
*s
) {
2368 pa_assert_ctl_context();
2369 pa_source_assert_ref(s
);
2371 if (!PA_SOURCE_IS_LINKED(s
->state
))
2372 return s
->thread_info
.max_rewind
;
2374 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_MAX_REWIND
, &r
, 0, NULL
) == 0);
2379 /* Called from main context */
2380 int pa_source_set_port(pa_source
*s
, const char *name
, pa_bool_t save
) {
2381 pa_device_port
*port
;
2384 pa_source_assert_ref(s
);
2385 pa_assert_ctl_context();
2388 pa_log_debug("set_port() operation not implemented for source %u \"%s\"", s
->index
, s
->name
);
2389 return -PA_ERR_NOTIMPLEMENTED
;
2393 return -PA_ERR_NOENTITY
;
2395 if (!(port
= pa_hashmap_get(s
->ports
, name
)))
2396 return -PA_ERR_NOENTITY
;
2398 if (s
->active_port
== port
) {
2399 s
->save_port
= s
->save_port
|| save
;
2403 if (s
->flags
& PA_SOURCE_SYNC_VOLUME
) {
2404 struct source_message_set_port msg
= { .port
= port
, .ret
= 0 };
2405 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_PORT
, &msg
, 0, NULL
) == 0);
2409 ret
= s
->set_port(s
, port
);
2412 return -PA_ERR_NOENTITY
;
2414 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
2416 pa_log_info("Changed port of source %u \"%s\" to %s", s
->index
, s
->name
, port
->name
);
2418 s
->active_port
= port
;
2419 s
->save_port
= save
;
2421 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_PORT_CHANGED
], s
);
2426 PA_STATIC_FLIST_DECLARE(pa_source_volume_change
, 0, pa_xfree
);
2428 /* Called from the IO thread. */
2429 static pa_source_volume_change
*pa_source_volume_change_new(pa_source
*s
) {
2430 pa_source_volume_change
*c
;
2431 if (!(c
= pa_flist_pop(PA_STATIC_FLIST_GET(pa_source_volume_change
))))
2432 c
= pa_xnew(pa_source_volume_change
, 1);
2434 PA_LLIST_INIT(pa_source_volume_change
, c
);
2436 pa_cvolume_reset(&c
->hw_volume
, s
->sample_spec
.channels
);
2440 /* Called from the IO thread. */
2441 static void pa_source_volume_change_free(pa_source_volume_change
*c
) {
2443 if (pa_flist_push(PA_STATIC_FLIST_GET(pa_source_volume_change
), c
) < 0)
2447 /* Called from the IO thread. */
2448 void pa_source_volume_change_push(pa_source
*s
) {
2449 pa_source_volume_change
*c
= NULL
;
2450 pa_source_volume_change
*nc
= NULL
;
2451 uint32_t safety_margin
= s
->thread_info
.volume_change_safety_margin
;
2453 const char *direction
= NULL
;
2456 nc
= pa_source_volume_change_new(s
);
2458 /* NOTE: There is already more different volumes in pa_source that I can remember.
2459 * Adding one more volume for HW would get us rid of this, but I am trying
2460 * to survive with the ones we already have. */
2461 pa_sw_cvolume_divide(&nc
->hw_volume
, &s
->real_volume
, &s
->soft_volume
);
2463 if (!s
->thread_info
.volume_changes
&& pa_cvolume_equal(&nc
->hw_volume
, &s
->thread_info
.current_hw_volume
)) {
2464 pa_log_debug("Volume not changing");
2465 pa_source_volume_change_free(nc
);
2469 nc
->at
= pa_source_get_latency_within_thread(s
);
2470 nc
->at
+= pa_rtclock_now() + s
->thread_info
.volume_change_extra_delay
;
2472 if (s
->thread_info
.volume_changes_tail
) {
2473 for (c
= s
->thread_info
.volume_changes_tail
; c
; c
= c
->prev
) {
2474 /* If volume is going up let's do it a bit late. If it is going
2475 * down let's do it a bit early. */
2476 if (pa_cvolume_avg(&nc
->hw_volume
) > pa_cvolume_avg(&c
->hw_volume
)) {
2477 if (nc
->at
+ safety_margin
> c
->at
) {
2478 nc
->at
+= safety_margin
;
2483 else if (nc
->at
- safety_margin
> c
->at
) {
2484 nc
->at
-= safety_margin
;
2492 if (pa_cvolume_avg(&nc
->hw_volume
) > pa_cvolume_avg(&s
->thread_info
.current_hw_volume
)) {
2493 nc
->at
+= safety_margin
;
2496 nc
->at
-= safety_margin
;
2499 PA_LLIST_PREPEND(pa_source_volume_change
, s
->thread_info
.volume_changes
, nc
);
2502 PA_LLIST_INSERT_AFTER(pa_source_volume_change
, s
->thread_info
.volume_changes
, c
, nc
);
2505 pa_log_debug("Volume going %s to %d at %llu", direction
, pa_cvolume_avg(&nc
->hw_volume
), (long long unsigned) nc
->at
);
2507 /* We can ignore volume events that came earlier but should happen later than this. */
2508 PA_LLIST_FOREACH(c
, nc
->next
) {
2509 pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c
->hw_volume
), (long long unsigned) c
->at
);
2510 pa_source_volume_change_free(c
);
2513 s
->thread_info
.volume_changes_tail
= nc
;
2516 /* Called from the IO thread. */
2517 static void pa_source_volume_change_flush(pa_source
*s
) {
2518 pa_source_volume_change
*c
= s
->thread_info
.volume_changes
;
2520 s
->thread_info
.volume_changes
= NULL
;
2521 s
->thread_info
.volume_changes_tail
= NULL
;
2523 pa_source_volume_change
*next
= c
->next
;
2524 pa_source_volume_change_free(c
);
2529 /* Called from the IO thread. */
2530 pa_bool_t
pa_source_volume_change_apply(pa_source
*s
, pa_usec_t
*usec_to_next
) {
2531 pa_usec_t now
= pa_rtclock_now();
2532 pa_bool_t ret
= FALSE
;
2535 pa_assert(s
->write_volume
);
2537 while (s
->thread_info
.volume_changes
&& now
>= s
->thread_info
.volume_changes
->at
) {
2538 pa_source_volume_change
*c
= s
->thread_info
.volume_changes
;
2539 PA_LLIST_REMOVE(pa_source_volume_change
, s
->thread_info
.volume_changes
, c
);
2540 pa_log_debug("Volume change to %d at %llu was written %llu usec late",
2541 pa_cvolume_avg(&c
->hw_volume
), (long long unsigned) c
->at
, (long long unsigned) (now
- c
->at
));
2543 s
->thread_info
.current_hw_volume
= c
->hw_volume
;
2544 pa_source_volume_change_free(c
);
2547 if (s
->write_volume
&& ret
)
2550 if (s
->thread_info
.volume_changes
) {
2552 *usec_to_next
= s
->thread_info
.volume_changes
->at
- now
;
2553 if (pa_log_ratelimit(PA_LOG_DEBUG
))
2554 pa_log_debug("Next volume change in %lld usec", (long long) (s
->thread_info
.volume_changes
->at
- now
));
2559 s
->thread_info
.volume_changes_tail
= NULL
;
2565 /* Called from the main thread */
2566 /* Gets the list of formats supported by the source. The members and idxset must
2567 * be freed by the caller. */
2568 pa_idxset
* pa_source_get_formats(pa_source
*s
) {
2573 if (s
->get_formats
) {
2574 /* Source supports format query, all is good */
2575 ret
= s
->get_formats(s
);
2577 /* Source doesn't support format query, so assume it does PCM */
2578 pa_format_info
*f
= pa_format_info_new();
2579 f
->encoding
= PA_ENCODING_PCM
;
2581 ret
= pa_idxset_new(NULL
, NULL
);
2582 pa_idxset_put(ret
, f
, NULL
);
2588 /* Called from the main thread */
2589 /* Checks if the source can accept this format */
2590 pa_bool_t
pa_source_check_format(pa_source
*s
, pa_format_info
*f
)
2592 pa_idxset
*formats
= NULL
;
2593 pa_bool_t ret
= FALSE
;
2598 formats
= pa_source_get_formats(s
);
2601 pa_format_info
*finfo_device
;
2604 PA_IDXSET_FOREACH(finfo_device
, formats
, i
) {
2605 if (pa_format_info_is_compatible(finfo_device
, f
)) {
2611 pa_idxset_free(formats
, (pa_free2_cb_t
) pa_format_info_free2
, NULL
);
2617 /* Called from the main thread */
2618 /* Calculates the intersection between formats supported by the source and
2619 * in_formats, and returns these, in the order of the source's formats. */
2620 pa_idxset
* pa_source_check_formats(pa_source
*s
, pa_idxset
*in_formats
) {
2621 pa_idxset
*out_formats
= pa_idxset_new(NULL
, NULL
), *source_formats
= NULL
;
2622 pa_format_info
*f_source
, *f_in
;
2627 if (!in_formats
|| pa_idxset_isempty(in_formats
))
2630 source_formats
= pa_source_get_formats(s
);
2632 PA_IDXSET_FOREACH(f_source
, source_formats
, i
) {
2633 PA_IDXSET_FOREACH(f_in
, in_formats
, j
) {
2634 if (pa_format_info_is_compatible(f_source
, f_in
))
2635 pa_idxset_put(out_formats
, pa_format_info_copy(f_in
), NULL
);
2641 pa_idxset_free(source_formats
, (pa_free2_cb_t
) pa_format_info_free2
, NULL
);