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
) {
393 pa_assert(!s
->write_volume
|| cb
);
398 s
->flags
|= PA_SOURCE_HW_VOLUME_CTRL
;
400 s
->flags
&= ~PA_SOURCE_HW_VOLUME_CTRL
;
403 void pa_source_set_write_volume_callback(pa_source
*s
, pa_source_cb_t cb
) {
406 pa_assert(!cb
|| s
->set_volume
);
408 s
->write_volume
= cb
;
411 s
->flags
|= PA_SOURCE_SYNC_VOLUME
;
413 s
->flags
&= ~PA_SOURCE_SYNC_VOLUME
;
416 void pa_source_set_get_mute_callback(pa_source
*s
, pa_source_cb_t cb
) {
422 void pa_source_set_set_mute_callback(pa_source
*s
, pa_source_cb_t cb
) {
428 s
->flags
|= PA_SOURCE_HW_MUTE_CTRL
;
430 s
->flags
&= ~PA_SOURCE_HW_MUTE_CTRL
;
433 /* Called from main context */
434 void pa_source_put(pa_source
*s
) {
435 pa_source_assert_ref(s
);
436 pa_assert_ctl_context();
438 pa_assert(s
->state
== PA_SOURCE_INIT
);
439 pa_assert(!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
) || s
->output_from_master
);
441 /* The following fields must be initialized properly when calling _put() */
442 pa_assert(s
->asyncmsgq
);
443 pa_assert(s
->thread_info
.min_latency
<= s
->thread_info
.max_latency
);
445 /* Generally, flags should be initialized via pa_source_new(). As a
446 * special exception we allow some volume related flags to be set
447 * between _new() and _put() by the callback setter functions above.
449 * Thus we implement a couple safeguards here which ensure the above
450 * setters were used (or at least the implementor made manual changes
451 * in a compatible way).
453 * Note: All of these flags set here can change over the life time
455 pa_assert(!(s
->flags
& PA_SOURCE_HW_VOLUME_CTRL
) || s
->set_volume
);
456 pa_assert(!(s
->flags
& PA_SOURCE_SYNC_VOLUME
) || s
->write_volume
);
457 pa_assert(!(s
->flags
& PA_SOURCE_HW_MUTE_CTRL
) || s
->set_mute
);
459 /* XXX: Currently decibel volume is disabled for all sources that use volume
460 * sharing. When the master source supports decibel volume, it would be good
461 * to have the flag also in the filter source, but currently we don't do that
462 * so that the flags of the filter source never change when it's moved from
463 * a master source to another. One solution for this problem would be to
464 * remove user-visible volume altogether from filter sources when volume
465 * sharing is used, but the current approach was easier to implement... */
466 /* We always support decibel volumes in software, otherwise we leave it to
467 * the source implementor to set this flag as needed.
469 * Note: This flag can also change over the life time of the source. */
470 if (!(s
->flags
& PA_SOURCE_HW_VOLUME_CTRL
) && !(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
471 s
->flags
|= PA_SOURCE_DECIBEL_VOLUME
;
473 if ((s
->flags
& PA_SOURCE_DECIBEL_VOLUME
) && s
->core
->flat_volumes
)
474 s
->flags
|= PA_SOURCE_FLAT_VOLUME
;
476 if (s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
) {
477 pa_source
*root_source
= s
->output_from_master
->source
;
479 while (root_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)
480 root_source
= root_source
->output_from_master
->source
;
482 s
->reference_volume
= root_source
->reference_volume
;
483 pa_cvolume_remap(&s
->reference_volume
, &root_source
->channel_map
, &s
->channel_map
);
485 s
->real_volume
= root_source
->real_volume
;
486 pa_cvolume_remap(&s
->real_volume
, &root_source
->channel_map
, &s
->channel_map
);
488 /* We assume that if the sink implementor changed the default
489 * volume he did so in real_volume, because that is the usual
490 * place where he is supposed to place his changes. */
491 s
->reference_volume
= s
->real_volume
;
493 s
->thread_info
.soft_volume
= s
->soft_volume
;
494 s
->thread_info
.soft_muted
= s
->muted
;
495 pa_sw_cvolume_multiply(&s
->thread_info
.current_hw_volume
, &s
->soft_volume
, &s
->real_volume
);
497 pa_assert((s
->flags
& PA_SOURCE_HW_VOLUME_CTRL
)
498 || (s
->base_volume
== PA_VOLUME_NORM
499 && ((s
->flags
& PA_SOURCE_DECIBEL_VOLUME
|| (s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)))));
500 pa_assert(!(s
->flags
& PA_SOURCE_DECIBEL_VOLUME
) || s
->n_volume_steps
== PA_VOLUME_NORM
+1);
501 pa_assert(!(s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
) == (s
->thread_info
.fixed_latency
!= 0));
503 pa_assert_se(source_set_state(s
, PA_SOURCE_IDLE
) == 0);
505 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
| PA_SUBSCRIPTION_EVENT_NEW
, s
->index
);
506 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_PUT
], s
);
509 /* Called from main context */
510 void pa_source_unlink(pa_source
*s
) {
512 pa_source_output
*o
, *j
= NULL
;
515 pa_assert_ctl_context();
517 /* See pa_sink_unlink() for a couple of comments how this function
520 linked
= PA_SOURCE_IS_LINKED(s
->state
);
523 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_UNLINK
], s
);
525 if (s
->state
!= PA_SOURCE_UNLINKED
)
526 pa_namereg_unregister(s
->core
, s
->name
);
527 pa_idxset_remove_by_data(s
->core
->sources
, s
, NULL
);
530 pa_idxset_remove_by_data(s
->card
->sources
, s
, NULL
);
532 while ((o
= pa_idxset_first(s
->outputs
, NULL
))) {
534 pa_source_output_kill(o
);
539 source_set_state(s
, PA_SOURCE_UNLINKED
);
541 s
->state
= PA_SOURCE_UNLINKED
;
546 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
| PA_SUBSCRIPTION_EVENT_REMOVE
, s
->index
);
547 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_UNLINK_POST
], s
);
551 /* Called from main context */
552 static void source_free(pa_object
*o
) {
553 pa_source_output
*so
;
554 pa_source
*s
= PA_SOURCE(o
);
557 pa_assert_ctl_context();
558 pa_assert(pa_source_refcnt(s
) == 0);
560 if (PA_SOURCE_IS_LINKED(s
->state
))
563 pa_log_info("Freeing source %u \"%s\"", s
->index
, s
->name
);
565 pa_idxset_free(s
->outputs
, NULL
, NULL
);
567 while ((so
= pa_hashmap_steal_first(s
->thread_info
.outputs
)))
568 pa_source_output_unref(so
);
570 pa_hashmap_free(s
->thread_info
.outputs
, NULL
, NULL
);
572 if (s
->silence
.memblock
)
573 pa_memblock_unref(s
->silence
.memblock
);
579 pa_proplist_free(s
->proplist
);
584 while ((p
= pa_hashmap_steal_first(s
->ports
)))
585 pa_device_port_free(p
);
587 pa_hashmap_free(s
->ports
, NULL
, NULL
);
593 /* Called from main context, and not while the IO thread is active, please */
594 void pa_source_set_asyncmsgq(pa_source
*s
, pa_asyncmsgq
*q
) {
595 pa_source_assert_ref(s
);
596 pa_assert_ctl_context();
601 /* Called from main context, and not while the IO thread is active, please */
602 void pa_source_update_flags(pa_source
*s
, pa_source_flags_t mask
, pa_source_flags_t value
) {
603 pa_source_assert_ref(s
);
604 pa_assert_ctl_context();
609 /* For now, allow only a minimal set of flags to be changed. */
610 pa_assert((mask
& ~(PA_SOURCE_DYNAMIC_LATENCY
|PA_SOURCE_LATENCY
)) == 0);
612 s
->flags
= (s
->flags
& ~mask
) | (value
& mask
);
615 /* Called from IO context, or before _put() from main context */
616 void pa_source_set_rtpoll(pa_source
*s
, pa_rtpoll
*p
) {
617 pa_source_assert_ref(s
);
618 pa_source_assert_io_context(s
);
620 s
->thread_info
.rtpoll
= p
;
623 /* Called from main context */
624 int pa_source_update_status(pa_source
*s
) {
625 pa_source_assert_ref(s
);
626 pa_assert_ctl_context();
627 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
629 if (s
->state
== PA_SOURCE_SUSPENDED
)
632 return source_set_state(s
, pa_source_used_by(s
) ? PA_SOURCE_RUNNING
: PA_SOURCE_IDLE
);
635 /* Called from main context */
636 int pa_source_suspend(pa_source
*s
, pa_bool_t suspend
, pa_suspend_cause_t cause
) {
637 pa_source_assert_ref(s
);
638 pa_assert_ctl_context();
639 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
640 pa_assert(cause
!= 0);
642 if (s
->monitor_of
&& cause
!= PA_SUSPEND_PASSTHROUGH
)
643 return -PA_ERR_NOTSUPPORTED
;
646 s
->suspend_cause
|= cause
;
648 s
->suspend_cause
&= ~cause
;
650 if ((pa_source_get_state(s
) == PA_SOURCE_SUSPENDED
) == !!s
->suspend_cause
)
653 pa_log_debug("Suspend cause of source %s is 0x%04x, %s", s
->name
, s
->suspend_cause
, s
->suspend_cause
? "suspending" : "resuming");
655 if (s
->suspend_cause
)
656 return source_set_state(s
, PA_SOURCE_SUSPENDED
);
658 return source_set_state(s
, pa_source_used_by(s
) ? PA_SOURCE_RUNNING
: PA_SOURCE_IDLE
);
661 /* Called from main context */
662 int pa_source_sync_suspend(pa_source
*s
) {
663 pa_sink_state_t state
;
665 pa_source_assert_ref(s
);
666 pa_assert_ctl_context();
667 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
668 pa_assert(s
->monitor_of
);
670 state
= pa_sink_get_state(s
->monitor_of
);
672 if (state
== PA_SINK_SUSPENDED
)
673 return source_set_state(s
, PA_SOURCE_SUSPENDED
);
675 pa_assert(PA_SINK_IS_OPENED(state
));
677 return source_set_state(s
, pa_source_used_by(s
) ? PA_SOURCE_RUNNING
: PA_SOURCE_IDLE
);
680 /* Called from main context */
681 pa_queue
*pa_source_move_all_start(pa_source
*s
, pa_queue
*q
) {
682 pa_source_output
*o
, *n
;
685 pa_source_assert_ref(s
);
686 pa_assert_ctl_context();
687 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
692 for (o
= PA_SOURCE_OUTPUT(pa_idxset_first(s
->outputs
, &idx
)); o
; o
= n
) {
693 n
= PA_SOURCE_OUTPUT(pa_idxset_next(s
->outputs
, &idx
));
695 pa_source_output_ref(o
);
697 if (pa_source_output_start_move(o
) >= 0)
700 pa_source_output_unref(o
);
706 /* Called from main context */
707 void pa_source_move_all_finish(pa_source
*s
, pa_queue
*q
, pa_bool_t save
) {
710 pa_source_assert_ref(s
);
711 pa_assert_ctl_context();
712 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
715 while ((o
= PA_SOURCE_OUTPUT(pa_queue_pop(q
)))) {
716 if (pa_source_output_finish_move(o
, s
, save
) < 0)
717 pa_source_output_fail_move(o
);
719 pa_source_output_unref(o
);
722 pa_queue_free(q
, NULL
, NULL
);
725 /* Called from main context */
726 void pa_source_move_all_fail(pa_queue
*q
) {
729 pa_assert_ctl_context();
732 while ((o
= PA_SOURCE_OUTPUT(pa_queue_pop(q
)))) {
733 pa_source_output_fail_move(o
);
734 pa_source_output_unref(o
);
737 pa_queue_free(q
, NULL
, NULL
);
740 /* Called from IO thread context */
741 void pa_source_process_rewind(pa_source
*s
, size_t nbytes
) {
745 pa_source_assert_ref(s
);
746 pa_source_assert_io_context(s
);
747 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
752 if (s
->thread_info
.state
== PA_SOURCE_SUSPENDED
)
755 pa_log_debug("Processing rewind...");
757 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
) {
758 pa_source_output_assert_ref(o
);
759 pa_source_output_process_rewind(o
, nbytes
);
763 /* Called from IO thread context */
764 void pa_source_post(pa_source
*s
, const pa_memchunk
*chunk
) {
768 pa_source_assert_ref(s
);
769 pa_source_assert_io_context(s
);
770 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
773 if (s
->thread_info
.state
== PA_SOURCE_SUSPENDED
)
776 if (s
->thread_info
.soft_muted
|| !pa_cvolume_is_norm(&s
->thread_info
.soft_volume
)) {
777 pa_memchunk vchunk
= *chunk
;
779 pa_memblock_ref(vchunk
.memblock
);
780 pa_memchunk_make_writable(&vchunk
, 0);
782 if (s
->thread_info
.soft_muted
|| pa_cvolume_is_muted(&s
->thread_info
.soft_volume
))
783 pa_silence_memchunk(&vchunk
, &s
->sample_spec
);
785 pa_volume_memchunk(&vchunk
, &s
->sample_spec
, &s
->thread_info
.soft_volume
);
787 while ((o
= pa_hashmap_iterate(s
->thread_info
.outputs
, &state
, NULL
))) {
788 pa_source_output_assert_ref(o
);
790 if (!o
->thread_info
.direct_on_input
)
791 pa_source_output_push(o
, &vchunk
);
794 pa_memblock_unref(vchunk
.memblock
);
797 while ((o
= pa_hashmap_iterate(s
->thread_info
.outputs
, &state
, NULL
))) {
798 pa_source_output_assert_ref(o
);
800 if (!o
->thread_info
.direct_on_input
)
801 pa_source_output_push(o
, chunk
);
806 /* Called from IO thread context */
807 void pa_source_post_direct(pa_source
*s
, pa_source_output
*o
, const pa_memchunk
*chunk
) {
808 pa_source_assert_ref(s
);
809 pa_source_assert_io_context(s
);
810 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
811 pa_source_output_assert_ref(o
);
812 pa_assert(o
->thread_info
.direct_on_input
);
815 if (s
->thread_info
.state
== PA_SOURCE_SUSPENDED
)
818 if (s
->thread_info
.soft_muted
|| !pa_cvolume_is_norm(&s
->thread_info
.soft_volume
)) {
819 pa_memchunk vchunk
= *chunk
;
821 pa_memblock_ref(vchunk
.memblock
);
822 pa_memchunk_make_writable(&vchunk
, 0);
824 if (s
->thread_info
.soft_muted
|| pa_cvolume_is_muted(&s
->thread_info
.soft_volume
))
825 pa_silence_memchunk(&vchunk
, &s
->sample_spec
);
827 pa_volume_memchunk(&vchunk
, &s
->sample_spec
, &s
->thread_info
.soft_volume
);
829 pa_source_output_push(o
, &vchunk
);
831 pa_memblock_unref(vchunk
.memblock
);
833 pa_source_output_push(o
, chunk
);
836 /* Called from main thread */
837 pa_usec_t
pa_source_get_latency(pa_source
*s
) {
840 pa_source_assert_ref(s
);
841 pa_assert_ctl_context();
842 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
844 if (s
->state
== PA_SOURCE_SUSPENDED
)
847 if (!(s
->flags
& PA_SOURCE_LATENCY
))
850 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_LATENCY
, &usec
, 0, NULL
) == 0);
855 /* Called from IO thread */
856 pa_usec_t
pa_source_get_latency_within_thread(pa_source
*s
) {
860 pa_source_assert_ref(s
);
861 pa_source_assert_io_context(s
);
862 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
864 /* The returned value is supposed to be in the time domain of the sound card! */
866 if (s
->thread_info
.state
== PA_SOURCE_SUSPENDED
)
869 if (!(s
->flags
& PA_SOURCE_LATENCY
))
874 /* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
876 if (o
->process_msg(o
, PA_SOURCE_MESSAGE_GET_LATENCY
, &usec
, 0, NULL
) < 0)
882 /* Called from the main thread (and also from the IO thread while the main
883 * thread is waiting).
885 * When a source uses volume sharing, it never has the PA_SOURCE_FLAT_VOLUME flag
886 * set. Instead, flat volume mode is detected by checking whether the root source
887 * has the flag set. */
888 pa_bool_t
pa_source_flat_volume_enabled(pa_source
*s
) {
889 pa_source_assert_ref(s
);
891 while (s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)
892 s
= s
->output_from_master
->source
;
894 return (s
->flags
& PA_SOURCE_FLAT_VOLUME
);
897 /* Called from main context */
898 pa_bool_t
pa_source_is_passthrough(pa_source
*s
) {
900 pa_source_assert_ref(s
);
902 /* NB Currently only monitor sources support passthrough mode */
903 return (s
->monitor_of
&& pa_sink_is_passthrough(s
->monitor_of
));
906 /* Called from main context. */
907 static void compute_reference_ratio(pa_source_output
*o
) {
912 pa_assert(pa_source_flat_volume_enabled(o
->source
));
915 * Calculates the reference ratio from the source's reference
916 * volume. This basically calculates:
918 * o->reference_ratio = o->volume / o->source->reference_volume
921 remapped
= o
->source
->reference_volume
;
922 pa_cvolume_remap(&remapped
, &o
->source
->channel_map
, &o
->channel_map
);
924 o
->reference_ratio
.channels
= o
->sample_spec
.channels
;
926 for (c
= 0; c
< o
->sample_spec
.channels
; c
++) {
928 /* We don't update when the source volume is 0 anyway */
929 if (remapped
.values
[c
] <= PA_VOLUME_MUTED
)
932 /* Don't update the reference ratio unless necessary */
933 if (pa_sw_volume_multiply(
934 o
->reference_ratio
.values
[c
],
935 remapped
.values
[c
]) == o
->volume
.values
[c
])
938 o
->reference_ratio
.values
[c
] = pa_sw_volume_divide(
944 /* Called from main context. Only called for the root source in volume sharing
945 * cases, except for internal recursive calls. */
946 static void compute_reference_ratios(pa_source
*s
) {
950 pa_source_assert_ref(s
);
951 pa_assert_ctl_context();
952 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
953 pa_assert(pa_source_flat_volume_enabled(s
));
955 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
956 compute_reference_ratio(o
);
958 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
959 compute_reference_ratios(o
->destination_source
);
963 /* Called from main context. Only called for the root source in volume sharing
964 * cases, except for internal recursive calls. */
965 static void compute_real_ratios(pa_source
*s
) {
969 pa_source_assert_ref(s
);
970 pa_assert_ctl_context();
971 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
972 pa_assert(pa_source_flat_volume_enabled(s
));
974 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
978 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)) {
979 /* The origin source uses volume sharing, so this input's real ratio
980 * is handled as a special case - the real ratio must be 0 dB, and
981 * as a result i->soft_volume must equal i->volume_factor. */
982 pa_cvolume_reset(&o
->real_ratio
, o
->real_ratio
.channels
);
983 o
->soft_volume
= o
->volume_factor
;
985 compute_real_ratios(o
->destination_source
);
991 * This basically calculates:
993 * i->real_ratio := i->volume / s->real_volume
994 * i->soft_volume := i->real_ratio * i->volume_factor
997 remapped
= s
->real_volume
;
998 pa_cvolume_remap(&remapped
, &s
->channel_map
, &o
->channel_map
);
1000 o
->real_ratio
.channels
= o
->sample_spec
.channels
;
1001 o
->soft_volume
.channels
= o
->sample_spec
.channels
;
1003 for (c
= 0; c
< o
->sample_spec
.channels
; c
++) {
1005 if (remapped
.values
[c
] <= PA_VOLUME_MUTED
) {
1006 /* We leave o->real_ratio untouched */
1007 o
->soft_volume
.values
[c
] = PA_VOLUME_MUTED
;
1011 /* Don't lose accuracy unless necessary */
1012 if (pa_sw_volume_multiply(
1013 o
->real_ratio
.values
[c
],
1014 remapped
.values
[c
]) != o
->volume
.values
[c
])
1016 o
->real_ratio
.values
[c
] = pa_sw_volume_divide(
1017 o
->volume
.values
[c
],
1018 remapped
.values
[c
]);
1020 o
->soft_volume
.values
[c
] = pa_sw_volume_multiply(
1021 o
->real_ratio
.values
[c
],
1022 o
->volume_factor
.values
[c
]);
1025 /* We don't copy the soft_volume to the thread_info data
1026 * here. That must be done by the caller */
1030 static pa_cvolume
*cvolume_remap_minimal_impact(
1032 const pa_cvolume
*template,
1033 const pa_channel_map
*from
,
1034 const pa_channel_map
*to
) {
1039 pa_assert(template);
1042 pa_assert(pa_cvolume_compatible_with_channel_map(v
, from
));
1043 pa_assert(pa_cvolume_compatible_with_channel_map(template, to
));
1045 /* Much like pa_cvolume_remap(), but tries to minimize impact when
1046 * mapping from source output to source volumes:
1048 * If template is a possible remapping from v it is used instead
1049 * of remapping anew.
1051 * If the channel maps don't match we set an all-channel volume on
1052 * the source to ensure that changing a volume on one stream has no
1053 * effect that cannot be compensated for in another stream that
1054 * does not have the same channel map as the source. */
1056 if (pa_channel_map_equal(from
, to
))
1060 if (pa_cvolume_equal(pa_cvolume_remap(&t
, to
, from
), v
)) {
1065 pa_cvolume_set(v
, to
->channels
, pa_cvolume_max(v
));
1069 /* Called from main thread. Only called for the root source in volume sharing
1070 * cases, except for internal recursive calls. */
1071 static void get_maximum_output_volume(pa_source
*s
, pa_cvolume
*max_volume
, const pa_channel_map
*channel_map
) {
1072 pa_source_output
*o
;
1075 pa_source_assert_ref(s
);
1076 pa_assert(max_volume
);
1077 pa_assert(channel_map
);
1078 pa_assert(pa_source_flat_volume_enabled(s
));
1080 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1081 pa_cvolume remapped
;
1083 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)) {
1084 get_maximum_output_volume(o
->destination_source
, max_volume
, channel_map
);
1086 /* Ignore this output. The origin source uses volume sharing, so this
1087 * output's volume will be set to be equal to the root source's real
1088 * volume. Obviously this outputs's current volume must not then
1089 * affect what the root source's real volume will be. */
1093 remapped
= o
->volume
;
1094 cvolume_remap_minimal_impact(&remapped
, max_volume
, &o
->channel_map
, channel_map
);
1095 pa_cvolume_merge(max_volume
, max_volume
, &remapped
);
1099 /* Called from main thread. Only called for the root source in volume sharing
1100 * cases, except for internal recursive calls. */
1101 static pa_bool_t
has_outputs(pa_source
*s
) {
1102 pa_source_output
*o
;
1105 pa_source_assert_ref(s
);
1107 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1108 if (!o
->destination_source
|| !(o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
) || has_outputs(o
->destination_source
))
1115 /* Called from main thread. Only called for the root source in volume sharing
1116 * cases, except for internal recursive calls. */
1117 static void update_real_volume(pa_source
*s
, const pa_cvolume
*new_volume
, pa_channel_map
*channel_map
) {
1118 pa_source_output
*o
;
1121 pa_source_assert_ref(s
);
1122 pa_assert(new_volume
);
1123 pa_assert(channel_map
);
1125 s
->real_volume
= *new_volume
;
1126 pa_cvolume_remap(&s
->real_volume
, channel_map
, &s
->channel_map
);
1128 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1129 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)) {
1130 if (pa_source_flat_volume_enabled(s
)) {
1131 pa_cvolume old_volume
= o
->volume
;
1133 /* Follow the root source's real volume. */
1134 o
->volume
= *new_volume
;
1135 pa_cvolume_remap(&o
->volume
, channel_map
, &o
->channel_map
);
1136 compute_reference_ratio(o
);
1138 /* The volume changed, let's tell people so */
1139 if (!pa_cvolume_equal(&old_volume
, &o
->volume
)) {
1140 if (o
->volume_changed
)
1141 o
->volume_changed(o
);
1143 pa_subscription_post(o
->core
, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, o
->index
);
1147 update_real_volume(o
->destination_source
, new_volume
, channel_map
);
1152 /* Called from main thread. Only called for the root source in shared volume
1154 static void compute_real_volume(pa_source
*s
) {
1155 pa_source_assert_ref(s
);
1156 pa_assert_ctl_context();
1157 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1158 pa_assert(pa_source_flat_volume_enabled(s
));
1159 pa_assert(!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
));
1161 /* This determines the maximum volume of all streams and sets
1162 * s->real_volume accordingly. */
1164 if (!has_outputs(s
)) {
1165 /* In the special case that we have no source outputs we leave the
1166 * volume unmodified. */
1167 update_real_volume(s
, &s
->reference_volume
, &s
->channel_map
);
1171 pa_cvolume_mute(&s
->real_volume
, s
->channel_map
.channels
);
1173 /* First let's determine the new maximum volume of all outputs
1174 * connected to this source */
1175 get_maximum_output_volume(s
, &s
->real_volume
, &s
->channel_map
);
1176 update_real_volume(s
, &s
->real_volume
, &s
->channel_map
);
1178 /* Then, let's update the real ratios/soft volumes of all outputs
1179 * connected to this source */
1180 compute_real_ratios(s
);
1183 /* Called from main thread. Only called for the root source in shared volume
1184 * cases, except for internal recursive calls. */
1185 static void propagate_reference_volume(pa_source
*s
) {
1186 pa_source_output
*o
;
1189 pa_source_assert_ref(s
);
1190 pa_assert_ctl_context();
1191 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1192 pa_assert(pa_source_flat_volume_enabled(s
));
1194 /* This is called whenever the source volume changes that is not
1195 * caused by a source output volume change. We need to fix up the
1196 * source output volumes accordingly */
1198 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1199 pa_cvolume old_volume
;
1201 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)) {
1202 propagate_reference_volume(o
->destination_source
);
1204 /* Since the origin source uses volume sharing, this output's volume
1205 * needs to be updated to match the root source's real volume, but
1206 * that will be done later in update_shared_real_volume(). */
1210 old_volume
= o
->volume
;
1212 /* This basically calculates:
1214 * o->volume := o->reference_volume * o->reference_ratio */
1216 o
->volume
= s
->reference_volume
;
1217 pa_cvolume_remap(&o
->volume
, &s
->channel_map
, &o
->channel_map
);
1218 pa_sw_cvolume_multiply(&o
->volume
, &o
->volume
, &o
->reference_ratio
);
1220 /* The volume changed, let's tell people so */
1221 if (!pa_cvolume_equal(&old_volume
, &o
->volume
)) {
1223 if (o
->volume_changed
)
1224 o
->volume_changed(o
);
1226 pa_subscription_post(o
->core
, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, o
->index
);
1231 /* Called from main thread. Only called for the root source in volume sharing
1232 * cases, except for internal recursive calls. The return value indicates
1233 * whether any reference volume actually changed. */
1234 static pa_bool_t
update_reference_volume(pa_source
*s
, const pa_cvolume
*v
, const pa_channel_map
*channel_map
, pa_bool_t save
) {
1236 pa_bool_t reference_volume_changed
;
1237 pa_source_output
*o
;
1240 pa_source_assert_ref(s
);
1241 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1243 pa_assert(channel_map
);
1244 pa_assert(pa_cvolume_valid(v
));
1247 pa_cvolume_remap(&volume
, channel_map
, &s
->channel_map
);
1249 reference_volume_changed
= !pa_cvolume_equal(&volume
, &s
->reference_volume
);
1250 s
->reference_volume
= volume
;
1252 s
->save_volume
= (!reference_volume_changed
&& s
->save_volume
) || save
;
1254 if (reference_volume_changed
)
1255 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1256 else if (!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
1257 /* If the root source's volume doesn't change, then there can't be any
1258 * changes in the other source in the source tree either.
1260 * It's probably theoretically possible that even if the root source's
1261 * volume changes slightly, some filter source doesn't change its volume
1262 * due to rounding errors. If that happens, we still want to propagate
1263 * the changed root source volume to the sources connected to the
1264 * intermediate source that didn't change its volume. This theoretical
1265 * possiblity is the reason why we have that !(s->flags &
1266 * PA_SOURCE_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
1267 * notice even if we returned here FALSE always if
1268 * reference_volume_changed is FALSE. */
1271 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1272 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
1273 update_reference_volume(o
->destination_source
, v
, channel_map
, FALSE
);
1279 /* Called from main thread */
1280 void pa_source_set_volume(
1282 const pa_cvolume
*volume
,
1286 pa_cvolume new_reference_volume
;
1287 pa_source
*root_source
= s
;
1289 pa_source_assert_ref(s
);
1290 pa_assert_ctl_context();
1291 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1292 pa_assert(!volume
|| pa_cvolume_valid(volume
));
1293 pa_assert(volume
|| pa_source_flat_volume_enabled(s
));
1294 pa_assert(!volume
|| volume
->channels
== 1 || pa_cvolume_compatible(volume
, &s
->sample_spec
));
1296 /* make sure we don't change the volume when a PASSTHROUGH output is connected */
1297 if (pa_source_is_passthrough(s
)) {
1298 /* FIXME: Need to notify client that volume control is disabled */
1299 pa_log_warn("Cannot change volume, Source is monitor of a PASSTHROUGH sink");
1303 /* In case of volume sharing, the volume is set for the root source first,
1304 * from which it's then propagated to the sharing sources. */
1305 while (root_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)
1306 root_source
= root_source
->output_from_master
->source
;
1308 /* As a special exception we accept mono volumes on all sources --
1309 * even on those with more complex channel maps */
1312 if (pa_cvolume_compatible(volume
, &s
->sample_spec
))
1313 new_reference_volume
= *volume
;
1315 new_reference_volume
= s
->reference_volume
;
1316 pa_cvolume_scale(&new_reference_volume
, pa_cvolume_max(volume
));
1319 pa_cvolume_remap(&new_reference_volume
, &s
->channel_map
, &root_source
->channel_map
);
1322 /* If volume is NULL we synchronize the source's real and reference
1323 * volumes with the stream volumes. If it is not NULL we update
1324 * the reference_volume with it. */
1327 if (update_reference_volume(root_source
, &new_reference_volume
, &root_source
->channel_map
, save
)) {
1328 if (pa_source_flat_volume_enabled(root_source
)) {
1329 /* OK, propagate this volume change back to the outputs */
1330 propagate_reference_volume(root_source
);
1332 /* And now recalculate the real volume */
1333 compute_real_volume(root_source
);
1335 update_real_volume(root_source
, &root_source
->reference_volume
, &root_source
->channel_map
);
1339 pa_assert(pa_source_flat_volume_enabled(root_source
));
1341 /* Ok, let's determine the new real volume */
1342 compute_real_volume(root_source
);
1344 /* Let's 'push' the reference volume if necessary */
1345 pa_cvolume_merge(&new_reference_volume
, &s
->reference_volume
, &root_source
->real_volume
);
1346 update_reference_volume(root_source
, &new_reference_volume
, &root_source
->channel_map
, save
);
1348 /* Now that the reference volume is updated, we can update the streams'
1349 * reference ratios. */
1350 compute_reference_ratios(root_source
);
1353 if (root_source
->set_volume
) {
1354 /* If we have a function set_volume(), then we do not apply a
1355 * soft volume by default. However, set_volume() is free to
1356 * apply one to root_source->soft_volume */
1358 pa_cvolume_reset(&root_source
->soft_volume
, root_source
->sample_spec
.channels
);
1359 if (!(root_source
->flags
& PA_SOURCE_SYNC_VOLUME
))
1360 root_source
->set_volume(root_source
);
1363 /* If we have no function set_volume(), then the soft volume
1364 * becomes the real volume */
1365 root_source
->soft_volume
= root_source
->real_volume
;
1367 /* This tells the source that soft volume and/or real volume changed */
1369 pa_assert_se(pa_asyncmsgq_send(root_source
->asyncmsgq
, PA_MSGOBJECT(root_source
), PA_SOURCE_MESSAGE_SET_SHARED_VOLUME
, NULL
, 0, NULL
) == 0);
1372 /* Called from the io thread if sync volume is used, otherwise from the main thread.
1373 * Only to be called by source implementor */
1374 void pa_source_set_soft_volume(pa_source
*s
, const pa_cvolume
*volume
) {
1376 pa_source_assert_ref(s
);
1377 pa_assert(!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
));
1379 if (s
->flags
& PA_SOURCE_SYNC_VOLUME
)
1380 pa_source_assert_io_context(s
);
1382 pa_assert_ctl_context();
1385 pa_cvolume_reset(&s
->soft_volume
, s
->sample_spec
.channels
);
1387 s
->soft_volume
= *volume
;
1389 if (PA_SOURCE_IS_LINKED(s
->state
) && !(s
->flags
& PA_SOURCE_SYNC_VOLUME
))
1390 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_VOLUME
, NULL
, 0, NULL
) == 0);
1392 s
->thread_info
.soft_volume
= s
->soft_volume
;
1395 /* Called from the main thread. Only called for the root source in volume sharing
1396 * cases, except for internal recursive calls. */
1397 static void propagate_real_volume(pa_source
*s
, const pa_cvolume
*old_real_volume
) {
1398 pa_source_output
*o
;
1401 pa_source_assert_ref(s
);
1402 pa_assert(old_real_volume
);
1403 pa_assert_ctl_context();
1404 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1406 /* This is called when the hardware's real volume changes due to
1407 * some external event. We copy the real volume into our
1408 * reference volume and then rebuild the stream volumes based on
1409 * i->real_ratio which should stay fixed. */
1411 if (!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)) {
1412 if (pa_cvolume_equal(old_real_volume
, &s
->real_volume
))
1415 /* 1. Make the real volume the reference volume */
1416 update_reference_volume(s
, &s
->real_volume
, &s
->channel_map
, TRUE
);
1419 if (pa_source_flat_volume_enabled(s
)) {
1421 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1422 pa_cvolume old_volume
= o
->volume
;
1424 /* 2. Since the source's reference and real volumes are equal
1425 * now our ratios should be too. */
1426 o
->reference_ratio
= o
->real_ratio
;
1428 /* 3. Recalculate the new stream reference volume based on the
1429 * reference ratio and the sink's reference volume.
1431 * This basically calculates:
1433 * o->volume = s->reference_volume * o->reference_ratio
1435 * This is identical to propagate_reference_volume() */
1436 o
->volume
= s
->reference_volume
;
1437 pa_cvolume_remap(&o
->volume
, &s
->channel_map
, &o
->channel_map
);
1438 pa_sw_cvolume_multiply(&o
->volume
, &o
->volume
, &o
->reference_ratio
);
1440 /* Notify if something changed */
1441 if (!pa_cvolume_equal(&old_volume
, &o
->volume
)) {
1443 if (o
->volume_changed
)
1444 o
->volume_changed(o
);
1446 pa_subscription_post(o
->core
, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, o
->index
);
1449 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
1450 propagate_real_volume(o
->destination_source
, old_real_volume
);
1454 /* Something got changed in the hardware. It probably makes sense
1455 * to save changed hw settings given that hw volume changes not
1456 * triggered by PA are almost certainly done by the user. */
1457 if (!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
1458 s
->save_volume
= TRUE
;
1461 /* Called from io thread */
1462 void pa_source_update_volume_and_mute(pa_source
*s
) {
1464 pa_source_assert_io_context(s
);
1466 pa_asyncmsgq_post(pa_thread_mq_get()->outq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE
, NULL
, 0, NULL
, NULL
);
1469 /* Called from main thread */
1470 const pa_cvolume
*pa_source_get_volume(pa_source
*s
, pa_bool_t force_refresh
) {
1471 pa_source_assert_ref(s
);
1472 pa_assert_ctl_context();
1473 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1475 if (s
->refresh_volume
|| force_refresh
) {
1476 struct pa_cvolume old_real_volume
;
1478 pa_assert(!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
));
1480 old_real_volume
= s
->real_volume
;
1482 if (!(s
->flags
& PA_SOURCE_SYNC_VOLUME
) && s
->get_volume
)
1485 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_VOLUME
, NULL
, 0, NULL
) == 0);
1487 update_real_volume(s
, &s
->real_volume
, &s
->channel_map
);
1488 propagate_real_volume(s
, &old_real_volume
);
1491 return &s
->reference_volume
;
1494 /* Called from main thread. In volume sharing cases, only the root source may
1496 void pa_source_volume_changed(pa_source
*s
, const pa_cvolume
*new_real_volume
) {
1497 pa_cvolume old_real_volume
;
1499 pa_source_assert_ref(s
);
1500 pa_assert_ctl_context();
1501 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1502 pa_assert(!(s
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
));
1504 /* The source implementor may call this if the volume changed to make sure everyone is notified */
1506 old_real_volume
= s
->real_volume
;
1507 update_real_volume(s
, new_real_volume
, &s
->channel_map
);
1508 propagate_real_volume(s
, &old_real_volume
);
1511 /* Called from main thread */
1512 void pa_source_set_mute(pa_source
*s
, pa_bool_t mute
, pa_bool_t save
) {
1513 pa_bool_t old_muted
;
1515 pa_source_assert_ref(s
);
1516 pa_assert_ctl_context();
1517 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1519 old_muted
= s
->muted
;
1521 s
->save_muted
= (old_muted
== s
->muted
&& s
->save_muted
) || save
;
1523 if (!(s
->flags
& PA_SOURCE_SYNC_VOLUME
) && s
->set_mute
)
1526 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_MUTE
, NULL
, 0, NULL
) == 0);
1528 if (old_muted
!= s
->muted
)
1529 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1532 /* Called from main thread */
1533 pa_bool_t
pa_source_get_mute(pa_source
*s
, pa_bool_t force_refresh
) {
1535 pa_source_assert_ref(s
);
1536 pa_assert_ctl_context();
1537 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1539 if (s
->refresh_muted
|| force_refresh
) {
1540 pa_bool_t old_muted
= s
->muted
;
1542 if (!(s
->flags
& PA_SOURCE_SYNC_VOLUME
) && s
->get_mute
)
1545 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_MUTE
, NULL
, 0, NULL
) == 0);
1547 if (old_muted
!= s
->muted
) {
1548 s
->save_muted
= TRUE
;
1550 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1552 /* Make sure the soft mute status stays in sync */
1553 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_MUTE
, NULL
, 0, NULL
) == 0);
1560 /* Called from main thread */
1561 void pa_source_mute_changed(pa_source
*s
, pa_bool_t new_muted
) {
1562 pa_source_assert_ref(s
);
1563 pa_assert_ctl_context();
1564 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1566 /* The source implementor may call this if the mute state changed to make sure everyone is notified */
1568 if (s
->muted
== new_muted
)
1571 s
->muted
= new_muted
;
1572 s
->save_muted
= TRUE
;
1574 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1577 /* Called from main thread */
1578 pa_bool_t
pa_source_update_proplist(pa_source
*s
, pa_update_mode_t mode
, pa_proplist
*p
) {
1579 pa_source_assert_ref(s
);
1580 pa_assert_ctl_context();
1583 pa_proplist_update(s
->proplist
, mode
, p
);
1585 if (PA_SOURCE_IS_LINKED(s
->state
)) {
1586 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED
], s
);
1587 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1593 /* Called from main thread */
1594 /* FIXME -- this should be dropped and be merged into pa_source_update_proplist() */
1595 void pa_source_set_description(pa_source
*s
, const char *description
) {
1597 pa_source_assert_ref(s
);
1598 pa_assert_ctl_context();
1600 if (!description
&& !pa_proplist_contains(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
))
1603 old
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1605 if (old
&& description
&& pa_streq(old
, description
))
1609 pa_proplist_sets(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
, description
);
1611 pa_proplist_unset(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1613 if (PA_SOURCE_IS_LINKED(s
->state
)) {
1614 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1615 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED
], s
);
1619 /* Called from main thread */
1620 unsigned pa_source_linked_by(pa_source
*s
) {
1621 pa_source_assert_ref(s
);
1622 pa_assert_ctl_context();
1623 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1625 return pa_idxset_size(s
->outputs
);
1628 /* Called from main thread */
1629 unsigned pa_source_used_by(pa_source
*s
) {
1632 pa_source_assert_ref(s
);
1633 pa_assert_ctl_context();
1634 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1636 ret
= pa_idxset_size(s
->outputs
);
1637 pa_assert(ret
>= s
->n_corked
);
1639 return ret
- s
->n_corked
;
1642 /* Called from main thread */
1643 unsigned pa_source_check_suspend(pa_source
*s
) {
1645 pa_source_output
*o
;
1648 pa_source_assert_ref(s
);
1649 pa_assert_ctl_context();
1651 if (!PA_SOURCE_IS_LINKED(s
->state
))
1656 PA_IDXSET_FOREACH(o
, s
->outputs
, idx
) {
1657 pa_source_output_state_t st
;
1659 st
= pa_source_output_get_state(o
);
1661 /* We do not assert here. It is perfectly valid for a source output to
1662 * be in the INIT state (i.e. created, marked done but not yet put)
1663 * and we should not care if it's unlinked as it won't contribute
1664 * towarards our busy status.
1666 if (!PA_SOURCE_OUTPUT_IS_LINKED(st
))
1669 if (st
== PA_SOURCE_OUTPUT_CORKED
)
1672 if (o
->flags
& PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND
)
1681 /* Called from the IO thread */
1682 static void sync_output_volumes_within_thread(pa_source
*s
) {
1683 pa_source_output
*o
;
1686 pa_source_assert_ref(s
);
1687 pa_source_assert_io_context(s
);
1689 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
) {
1690 if (pa_cvolume_equal(&o
->thread_info
.soft_volume
, &o
->soft_volume
))
1693 o
->thread_info
.soft_volume
= o
->soft_volume
;
1694 //pa_source_output_request_rewind(o, 0, TRUE, FALSE, FALSE);
1698 /* Called from the IO thread. Only called for the root source in volume sharing
1699 * cases, except for internal recursive calls. */
1700 static void set_shared_volume_within_thread(pa_source
*s
) {
1701 pa_source_output
*o
;
1704 pa_source_assert_ref(s
);
1706 PA_MSGOBJECT(s
)->process_msg(PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED
, NULL
, 0, NULL
);
1708 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
) {
1709 if (o
->destination_source
&& (o
->destination_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
))
1710 set_shared_volume_within_thread(o
->destination_source
);
1714 /* Called from IO thread, except when it is not */
1715 int pa_source_process_msg(pa_msgobject
*object
, int code
, void *userdata
, int64_t offset
, pa_memchunk
*chunk
) {
1716 pa_source
*s
= PA_SOURCE(object
);
1717 pa_source_assert_ref(s
);
1719 switch ((pa_source_message_t
) code
) {
1721 case PA_SOURCE_MESSAGE_ADD_OUTPUT
: {
1722 pa_source_output
*o
= PA_SOURCE_OUTPUT(userdata
);
1724 pa_hashmap_put(s
->thread_info
.outputs
, PA_UINT32_TO_PTR(o
->index
), pa_source_output_ref(o
));
1726 if (o
->direct_on_input
) {
1727 o
->thread_info
.direct_on_input
= o
->direct_on_input
;
1728 pa_hashmap_put(o
->thread_info
.direct_on_input
->thread_info
.direct_outputs
, PA_UINT32_TO_PTR(o
->index
), o
);
1731 pa_assert(!o
->thread_info
.attached
);
1732 o
->thread_info
.attached
= TRUE
;
1737 pa_source_output_set_state_within_thread(o
, o
->state
);
1739 if (o
->thread_info
.requested_source_latency
!= (pa_usec_t
) -1)
1740 pa_source_output_set_requested_latency_within_thread(o
, o
->thread_info
.requested_source_latency
);
1742 pa_source_output_update_max_rewind(o
, s
->thread_info
.max_rewind
);
1744 /* We don't just invalidate the requested latency here,
1745 * because if we are in a move we might need to fix up the
1746 * requested latency. */
1747 pa_source_output_set_requested_latency_within_thread(o
, o
->thread_info
.requested_source_latency
);
1749 /* In flat volume mode we need to update the volume as
1751 return object
->process_msg(object
, PA_SOURCE_MESSAGE_SET_SHARED_VOLUME
, NULL
, 0, NULL
);
1754 case PA_SOURCE_MESSAGE_REMOVE_OUTPUT
: {
1755 pa_source_output
*o
= PA_SOURCE_OUTPUT(userdata
);
1757 pa_source_output_set_state_within_thread(o
, o
->state
);
1762 pa_assert(o
->thread_info
.attached
);
1763 o
->thread_info
.attached
= FALSE
;
1765 if (o
->thread_info
.direct_on_input
) {
1766 pa_hashmap_remove(o
->thread_info
.direct_on_input
->thread_info
.direct_outputs
, PA_UINT32_TO_PTR(o
->index
));
1767 o
->thread_info
.direct_on_input
= NULL
;
1770 if (pa_hashmap_remove(s
->thread_info
.outputs
, PA_UINT32_TO_PTR(o
->index
)))
1771 pa_source_output_unref(o
);
1773 pa_source_invalidate_requested_latency(s
, TRUE
);
1775 /* In flat volume mode we need to update the volume as
1777 return object
->process_msg(object
, PA_SOURCE_MESSAGE_SET_SHARED_VOLUME
, NULL
, 0, NULL
);
1780 case PA_SOURCE_MESSAGE_SET_SHARED_VOLUME
: {
1781 pa_source
*root_source
= s
;
1783 while (root_source
->flags
& PA_SOURCE_SHARE_VOLUME_WITH_MASTER
)
1784 root_source
= root_source
->output_from_master
->source
;
1786 set_shared_volume_within_thread(root_source
);
1790 case PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED
:
1792 if (s
->flags
& PA_SOURCE_SYNC_VOLUME
) {
1794 pa_source_volume_change_push(s
);
1796 /* Fall through ... */
1798 case PA_SOURCE_MESSAGE_SET_VOLUME
:
1800 if (!pa_cvolume_equal(&s
->thread_info
.soft_volume
, &s
->soft_volume
)) {
1801 s
->thread_info
.soft_volume
= s
->soft_volume
;
1804 /* Fall through ... */
1806 case PA_SOURCE_MESSAGE_SYNC_VOLUMES
:
1807 sync_output_volumes_within_thread(s
);
1810 case PA_SOURCE_MESSAGE_GET_VOLUME
:
1812 if ((s
->flags
& PA_SOURCE_SYNC_VOLUME
) && s
->get_volume
) {
1814 pa_source_volume_change_flush(s
);
1815 pa_sw_cvolume_divide(&s
->thread_info
.current_hw_volume
, &s
->real_volume
, &s
->soft_volume
);
1818 /* In case source implementor reset SW volume. */
1819 if (!pa_cvolume_equal(&s
->thread_info
.soft_volume
, &s
->soft_volume
)) {
1820 s
->thread_info
.soft_volume
= s
->soft_volume
;
1825 case PA_SOURCE_MESSAGE_SET_MUTE
:
1827 if (s
->thread_info
.soft_muted
!= s
->muted
) {
1828 s
->thread_info
.soft_muted
= s
->muted
;
1831 if (s
->flags
& PA_SOURCE_SYNC_VOLUME
&& s
->set_mute
)
1836 case PA_SOURCE_MESSAGE_GET_MUTE
:
1838 if (s
->flags
& PA_SOURCE_SYNC_VOLUME
&& s
->get_mute
)
1843 case PA_SOURCE_MESSAGE_SET_STATE
: {
1845 pa_bool_t suspend_change
=
1846 (s
->thread_info
.state
== PA_SOURCE_SUSPENDED
&& PA_SOURCE_IS_OPENED(PA_PTR_TO_UINT(userdata
))) ||
1847 (PA_SOURCE_IS_OPENED(s
->thread_info
.state
) && PA_PTR_TO_UINT(userdata
) == PA_SOURCE_SUSPENDED
);
1849 s
->thread_info
.state
= PA_PTR_TO_UINT(userdata
);
1851 if (suspend_change
) {
1852 pa_source_output
*o
;
1855 while ((o
= pa_hashmap_iterate(s
->thread_info
.outputs
, &state
, NULL
)))
1856 if (o
->suspend_within_thread
)
1857 o
->suspend_within_thread(o
, s
->thread_info
.state
== PA_SOURCE_SUSPENDED
);
1863 case PA_SOURCE_MESSAGE_DETACH
:
1865 /* Detach all streams */
1866 pa_source_detach_within_thread(s
);
1869 case PA_SOURCE_MESSAGE_ATTACH
:
1871 /* Reattach all streams */
1872 pa_source_attach_within_thread(s
);
1875 case PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY
: {
1877 pa_usec_t
*usec
= userdata
;
1878 *usec
= pa_source_get_requested_latency_within_thread(s
);
1880 /* Yes, that's right, the IO thread will see -1 when no
1881 * explicit requested latency is configured, the main
1882 * thread will see max_latency */
1883 if (*usec
== (pa_usec_t
) -1)
1884 *usec
= s
->thread_info
.max_latency
;
1889 case PA_SOURCE_MESSAGE_SET_LATENCY_RANGE
: {
1890 pa_usec_t
*r
= userdata
;
1892 pa_source_set_latency_range_within_thread(s
, r
[0], r
[1]);
1897 case PA_SOURCE_MESSAGE_GET_LATENCY_RANGE
: {
1898 pa_usec_t
*r
= userdata
;
1900 r
[0] = s
->thread_info
.min_latency
;
1901 r
[1] = s
->thread_info
.max_latency
;
1906 case PA_SOURCE_MESSAGE_GET_FIXED_LATENCY
:
1908 *((pa_usec_t
*) userdata
) = s
->thread_info
.fixed_latency
;
1911 case PA_SOURCE_MESSAGE_SET_FIXED_LATENCY
:
1913 pa_source_set_fixed_latency_within_thread(s
, (pa_usec_t
) offset
);
1916 case PA_SOURCE_MESSAGE_GET_MAX_REWIND
:
1918 *((size_t*) userdata
) = s
->thread_info
.max_rewind
;
1921 case PA_SOURCE_MESSAGE_SET_MAX_REWIND
:
1923 pa_source_set_max_rewind_within_thread(s
, (size_t) offset
);
1926 case PA_SOURCE_MESSAGE_GET_LATENCY
:
1928 if (s
->monitor_of
) {
1929 *((pa_usec_t
*) userdata
) = 0;
1933 /* Implementors need to overwrite this implementation! */
1936 case PA_SOURCE_MESSAGE_SET_PORT
:
1938 pa_assert(userdata
);
1940 struct source_message_set_port
*msg_data
= userdata
;
1941 msg_data
->ret
= s
->set_port(s
, msg_data
->port
);
1945 case PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE
:
1946 /* This message is sent from IO-thread and handled in main thread. */
1947 pa_assert_ctl_context();
1949 pa_source_get_volume(s
, TRUE
);
1950 pa_source_get_mute(s
, TRUE
);
1953 case PA_SOURCE_MESSAGE_MAX
:
1960 /* Called from main thread */
1961 int pa_source_suspend_all(pa_core
*c
, pa_bool_t suspend
, pa_suspend_cause_t cause
) {
1966 pa_core_assert_ref(c
);
1967 pa_assert_ctl_context();
1968 pa_assert(cause
!= 0);
1970 for (source
= PA_SOURCE(pa_idxset_first(c
->sources
, &idx
)); source
; source
= PA_SOURCE(pa_idxset_next(c
->sources
, &idx
))) {
1973 if (source
->monitor_of
)
1976 if ((r
= pa_source_suspend(source
, suspend
, cause
)) < 0)
1983 /* Called from main thread */
1984 void pa_source_detach(pa_source
*s
) {
1985 pa_source_assert_ref(s
);
1986 pa_assert_ctl_context();
1987 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1989 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_DETACH
, NULL
, 0, NULL
) == 0);
1992 /* Called from main thread */
1993 void pa_source_attach(pa_source
*s
) {
1994 pa_source_assert_ref(s
);
1995 pa_assert_ctl_context();
1996 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
1998 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_ATTACH
, NULL
, 0, NULL
) == 0);
2001 /* Called from IO thread */
2002 void pa_source_detach_within_thread(pa_source
*s
) {
2003 pa_source_output
*o
;
2006 pa_source_assert_ref(s
);
2007 pa_source_assert_io_context(s
);
2008 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
2010 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2015 /* Called from IO thread */
2016 void pa_source_attach_within_thread(pa_source
*s
) {
2017 pa_source_output
*o
;
2020 pa_source_assert_ref(s
);
2021 pa_source_assert_io_context(s
);
2022 pa_assert(PA_SOURCE_IS_LINKED(s
->thread_info
.state
));
2024 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2029 /* Called from IO thread */
2030 pa_usec_t
pa_source_get_requested_latency_within_thread(pa_source
*s
) {
2031 pa_usec_t result
= (pa_usec_t
) -1;
2032 pa_source_output
*o
;
2035 pa_source_assert_ref(s
);
2036 pa_source_assert_io_context(s
);
2038 if (!(s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
))
2039 return PA_CLAMP(s
->thread_info
.fixed_latency
, s
->thread_info
.min_latency
, s
->thread_info
.max_latency
);
2041 if (s
->thread_info
.requested_latency_valid
)
2042 return s
->thread_info
.requested_latency
;
2044 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2045 if (o
->thread_info
.requested_source_latency
!= (pa_usec_t
) -1 &&
2046 (result
== (pa_usec_t
) -1 || result
> o
->thread_info
.requested_source_latency
))
2047 result
= o
->thread_info
.requested_source_latency
;
2049 if (result
!= (pa_usec_t
) -1)
2050 result
= PA_CLAMP(result
, s
->thread_info
.min_latency
, s
->thread_info
.max_latency
);
2052 if (PA_SOURCE_IS_LINKED(s
->thread_info
.state
)) {
2053 /* Only cache this if we are fully set up */
2054 s
->thread_info
.requested_latency
= result
;
2055 s
->thread_info
.requested_latency_valid
= TRUE
;
2061 /* Called from main thread */
2062 pa_usec_t
pa_source_get_requested_latency(pa_source
*s
) {
2065 pa_source_assert_ref(s
);
2066 pa_assert_ctl_context();
2067 pa_assert(PA_SOURCE_IS_LINKED(s
->state
));
2069 if (s
->state
== PA_SOURCE_SUSPENDED
)
2072 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY
, &usec
, 0, NULL
) == 0);
2077 /* Called from IO thread */
2078 void pa_source_set_max_rewind_within_thread(pa_source
*s
, size_t max_rewind
) {
2079 pa_source_output
*o
;
2082 pa_source_assert_ref(s
);
2083 pa_source_assert_io_context(s
);
2085 if (max_rewind
== s
->thread_info
.max_rewind
)
2088 s
->thread_info
.max_rewind
= max_rewind
;
2090 if (PA_SOURCE_IS_LINKED(s
->thread_info
.state
))
2091 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2092 pa_source_output_update_max_rewind(o
, s
->thread_info
.max_rewind
);
2095 /* Called from main thread */
2096 void pa_source_set_max_rewind(pa_source
*s
, size_t max_rewind
) {
2097 pa_source_assert_ref(s
);
2098 pa_assert_ctl_context();
2100 if (PA_SOURCE_IS_LINKED(s
->state
))
2101 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_MAX_REWIND
, NULL
, max_rewind
, NULL
) == 0);
2103 pa_source_set_max_rewind_within_thread(s
, max_rewind
);
2106 /* Called from IO thread */
2107 void pa_source_invalidate_requested_latency(pa_source
*s
, pa_bool_t dynamic
) {
2108 pa_source_output
*o
;
2111 pa_source_assert_ref(s
);
2112 pa_source_assert_io_context(s
);
2114 if ((s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
))
2115 s
->thread_info
.requested_latency_valid
= FALSE
;
2119 if (PA_SOURCE_IS_LINKED(s
->thread_info
.state
)) {
2121 if (s
->update_requested_latency
)
2122 s
->update_requested_latency(s
);
2124 while ((o
= pa_hashmap_iterate(s
->thread_info
.outputs
, &state
, NULL
)))
2125 if (o
->update_source_requested_latency
)
2126 o
->update_source_requested_latency(o
);
2130 pa_sink_invalidate_requested_latency(s
->monitor_of
, dynamic
);
2133 /* Called from main thread */
2134 void pa_source_set_latency_range(pa_source
*s
, pa_usec_t min_latency
, pa_usec_t max_latency
) {
2135 pa_source_assert_ref(s
);
2136 pa_assert_ctl_context();
2138 /* min_latency == 0: no limit
2139 * min_latency anything else: specified limit
2141 * Similar for max_latency */
2143 if (min_latency
< ABSOLUTE_MIN_LATENCY
)
2144 min_latency
= ABSOLUTE_MIN_LATENCY
;
2146 if (max_latency
<= 0 ||
2147 max_latency
> ABSOLUTE_MAX_LATENCY
)
2148 max_latency
= ABSOLUTE_MAX_LATENCY
;
2150 pa_assert(min_latency
<= max_latency
);
2152 /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2153 pa_assert((min_latency
== ABSOLUTE_MIN_LATENCY
&&
2154 max_latency
== ABSOLUTE_MAX_LATENCY
) ||
2155 (s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
));
2157 if (PA_SOURCE_IS_LINKED(s
->state
)) {
2163 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_LATENCY_RANGE
, r
, 0, NULL
) == 0);
2165 pa_source_set_latency_range_within_thread(s
, min_latency
, max_latency
);
2168 /* Called from main thread */
2169 void pa_source_get_latency_range(pa_source
*s
, pa_usec_t
*min_latency
, pa_usec_t
*max_latency
) {
2170 pa_source_assert_ref(s
);
2171 pa_assert_ctl_context();
2172 pa_assert(min_latency
);
2173 pa_assert(max_latency
);
2175 if (PA_SOURCE_IS_LINKED(s
->state
)) {
2176 pa_usec_t r
[2] = { 0, 0 };
2178 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_LATENCY_RANGE
, r
, 0, NULL
) == 0);
2180 *min_latency
= r
[0];
2181 *max_latency
= r
[1];
2183 *min_latency
= s
->thread_info
.min_latency
;
2184 *max_latency
= s
->thread_info
.max_latency
;
2188 /* Called from IO thread, and from main thread before pa_source_put() is called */
2189 void pa_source_set_latency_range_within_thread(pa_source
*s
, pa_usec_t min_latency
, pa_usec_t max_latency
) {
2190 pa_source_assert_ref(s
);
2191 pa_source_assert_io_context(s
);
2193 pa_assert(min_latency
>= ABSOLUTE_MIN_LATENCY
);
2194 pa_assert(max_latency
<= ABSOLUTE_MAX_LATENCY
);
2195 pa_assert(min_latency
<= max_latency
);
2197 /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2198 pa_assert((min_latency
== ABSOLUTE_MIN_LATENCY
&&
2199 max_latency
== ABSOLUTE_MAX_LATENCY
) ||
2200 (s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
) ||
2203 if (s
->thread_info
.min_latency
== min_latency
&&
2204 s
->thread_info
.max_latency
== max_latency
)
2207 s
->thread_info
.min_latency
= min_latency
;
2208 s
->thread_info
.max_latency
= max_latency
;
2210 if (PA_SOURCE_IS_LINKED(s
->thread_info
.state
)) {
2211 pa_source_output
*o
;
2214 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2215 if (o
->update_source_latency_range
)
2216 o
->update_source_latency_range(o
);
2219 pa_source_invalidate_requested_latency(s
, FALSE
);
2222 /* Called from main thread, before the source is put */
2223 void pa_source_set_fixed_latency(pa_source
*s
, pa_usec_t latency
) {
2224 pa_source_assert_ref(s
);
2225 pa_assert_ctl_context();
2227 if (s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
) {
2228 pa_assert(latency
== 0);
2232 if (latency
< ABSOLUTE_MIN_LATENCY
)
2233 latency
= ABSOLUTE_MIN_LATENCY
;
2235 if (latency
> ABSOLUTE_MAX_LATENCY
)
2236 latency
= ABSOLUTE_MAX_LATENCY
;
2238 if (PA_SOURCE_IS_LINKED(s
->state
))
2239 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_FIXED_LATENCY
, NULL
, (int64_t) latency
, NULL
) == 0);
2241 s
->thread_info
.fixed_latency
= latency
;
2244 /* Called from main thread */
2245 pa_usec_t
pa_source_get_fixed_latency(pa_source
*s
) {
2248 pa_source_assert_ref(s
);
2249 pa_assert_ctl_context();
2251 if (s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
)
2254 if (PA_SOURCE_IS_LINKED(s
->state
))
2255 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_FIXED_LATENCY
, &latency
, 0, NULL
) == 0);
2257 latency
= s
->thread_info
.fixed_latency
;
2262 /* Called from IO thread */
2263 void pa_source_set_fixed_latency_within_thread(pa_source
*s
, pa_usec_t latency
) {
2264 pa_source_assert_ref(s
);
2265 pa_source_assert_io_context(s
);
2267 if (s
->flags
& PA_SOURCE_DYNAMIC_LATENCY
) {
2268 pa_assert(latency
== 0);
2272 pa_assert(latency
>= ABSOLUTE_MIN_LATENCY
);
2273 pa_assert(latency
<= ABSOLUTE_MAX_LATENCY
);
2275 if (s
->thread_info
.fixed_latency
== latency
)
2278 s
->thread_info
.fixed_latency
= latency
;
2280 if (PA_SOURCE_IS_LINKED(s
->thread_info
.state
)) {
2281 pa_source_output
*o
;
2284 PA_HASHMAP_FOREACH(o
, s
->thread_info
.outputs
, state
)
2285 if (o
->update_source_fixed_latency
)
2286 o
->update_source_fixed_latency(o
);
2289 pa_source_invalidate_requested_latency(s
, FALSE
);
2292 /* Called from main thread */
2293 size_t pa_source_get_max_rewind(pa_source
*s
) {
2295 pa_assert_ctl_context();
2296 pa_source_assert_ref(s
);
2298 if (!PA_SOURCE_IS_LINKED(s
->state
))
2299 return s
->thread_info
.max_rewind
;
2301 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_GET_MAX_REWIND
, &r
, 0, NULL
) == 0);
2306 /* Called from main context */
2307 int pa_source_set_port(pa_source
*s
, const char *name
, pa_bool_t save
) {
2308 pa_device_port
*port
;
2311 pa_source_assert_ref(s
);
2312 pa_assert_ctl_context();
2315 pa_log_debug("set_port() operation not implemented for source %u \"%s\"", s
->index
, s
->name
);
2316 return -PA_ERR_NOTIMPLEMENTED
;
2320 return -PA_ERR_NOENTITY
;
2322 if (!(port
= pa_hashmap_get(s
->ports
, name
)))
2323 return -PA_ERR_NOENTITY
;
2325 if (s
->active_port
== port
) {
2326 s
->save_port
= s
->save_port
|| save
;
2330 if (s
->flags
& PA_SOURCE_SYNC_VOLUME
) {
2331 struct source_message_set_port msg
= { .port
= port
, .ret
= 0 };
2332 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SOURCE_MESSAGE_SET_PORT
, &msg
, 0, NULL
) == 0);
2336 ret
= s
->set_port(s
, port
);
2339 return -PA_ERR_NOENTITY
;
2341 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SOURCE
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
2343 pa_log_info("Changed port of source %u \"%s\" to %s", s
->index
, s
->name
, port
->name
);
2345 s
->active_port
= port
;
2346 s
->save_port
= save
;
2348 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SOURCE_PORT_CHANGED
], s
);
2353 PA_STATIC_FLIST_DECLARE(pa_source_volume_change
, 0, pa_xfree
);
2355 /* Called from the IO thread. */
2356 static pa_source_volume_change
*pa_source_volume_change_new(pa_source
*s
) {
2357 pa_source_volume_change
*c
;
2358 if (!(c
= pa_flist_pop(PA_STATIC_FLIST_GET(pa_source_volume_change
))))
2359 c
= pa_xnew(pa_source_volume_change
, 1);
2361 PA_LLIST_INIT(pa_source_volume_change
, c
);
2363 pa_cvolume_reset(&c
->hw_volume
, s
->sample_spec
.channels
);
2367 /* Called from the IO thread. */
2368 static void pa_source_volume_change_free(pa_source_volume_change
*c
) {
2370 if (pa_flist_push(PA_STATIC_FLIST_GET(pa_source_volume_change
), c
) < 0)
2374 /* Called from the IO thread. */
2375 void pa_source_volume_change_push(pa_source
*s
) {
2376 pa_source_volume_change
*c
= NULL
;
2377 pa_source_volume_change
*nc
= NULL
;
2378 uint32_t safety_margin
= s
->thread_info
.volume_change_safety_margin
;
2380 const char *direction
= NULL
;
2383 nc
= pa_source_volume_change_new(s
);
2385 /* NOTE: There is already more different volumes in pa_source that I can remember.
2386 * Adding one more volume for HW would get us rid of this, but I am trying
2387 * to survive with the ones we already have. */
2388 pa_sw_cvolume_divide(&nc
->hw_volume
, &s
->real_volume
, &s
->soft_volume
);
2390 if (!s
->thread_info
.volume_changes
&& pa_cvolume_equal(&nc
->hw_volume
, &s
->thread_info
.current_hw_volume
)) {
2391 pa_log_debug("Volume not changing");
2392 pa_source_volume_change_free(nc
);
2396 nc
->at
= pa_source_get_latency_within_thread(s
);
2397 nc
->at
+= pa_rtclock_now() + s
->thread_info
.volume_change_extra_delay
;
2399 if (s
->thread_info
.volume_changes_tail
) {
2400 for (c
= s
->thread_info
.volume_changes_tail
; c
; c
= c
->prev
) {
2401 /* If volume is going up let's do it a bit late. If it is going
2402 * down let's do it a bit early. */
2403 if (pa_cvolume_avg(&nc
->hw_volume
) > pa_cvolume_avg(&c
->hw_volume
)) {
2404 if (nc
->at
+ safety_margin
> c
->at
) {
2405 nc
->at
+= safety_margin
;
2410 else if (nc
->at
- safety_margin
> c
->at
) {
2411 nc
->at
-= safety_margin
;
2419 if (pa_cvolume_avg(&nc
->hw_volume
) > pa_cvolume_avg(&s
->thread_info
.current_hw_volume
)) {
2420 nc
->at
+= safety_margin
;
2423 nc
->at
-= safety_margin
;
2426 PA_LLIST_PREPEND(pa_source_volume_change
, s
->thread_info
.volume_changes
, nc
);
2429 PA_LLIST_INSERT_AFTER(pa_source_volume_change
, s
->thread_info
.volume_changes
, c
, nc
);
2432 pa_log_debug("Volume going %s to %d at %llu", direction
, pa_cvolume_avg(&nc
->hw_volume
), (long long unsigned) nc
->at
);
2434 /* We can ignore volume events that came earlier but should happen later than this. */
2435 PA_LLIST_FOREACH(c
, nc
->next
) {
2436 pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c
->hw_volume
), (long long unsigned) c
->at
);
2437 pa_source_volume_change_free(c
);
2440 s
->thread_info
.volume_changes_tail
= nc
;
2443 /* Called from the IO thread. */
2444 static void pa_source_volume_change_flush(pa_source
*s
) {
2445 pa_source_volume_change
*c
= s
->thread_info
.volume_changes
;
2447 s
->thread_info
.volume_changes
= NULL
;
2448 s
->thread_info
.volume_changes_tail
= NULL
;
2450 pa_source_volume_change
*next
= c
->next
;
2451 pa_source_volume_change_free(c
);
2456 /* Called from the IO thread. */
2457 pa_bool_t
pa_source_volume_change_apply(pa_source
*s
, pa_usec_t
*usec_to_next
) {
2458 pa_usec_t now
= pa_rtclock_now();
2459 pa_bool_t ret
= FALSE
;
2462 pa_assert(s
->write_volume
);
2464 while (s
->thread_info
.volume_changes
&& now
>= s
->thread_info
.volume_changes
->at
) {
2465 pa_source_volume_change
*c
= s
->thread_info
.volume_changes
;
2466 PA_LLIST_REMOVE(pa_source_volume_change
, s
->thread_info
.volume_changes
, c
);
2467 pa_log_debug("Volume change to %d at %llu was written %llu usec late",
2468 pa_cvolume_avg(&c
->hw_volume
), (long long unsigned) c
->at
, (long long unsigned) (now
- c
->at
));
2470 s
->thread_info
.current_hw_volume
= c
->hw_volume
;
2471 pa_source_volume_change_free(c
);
2474 if (s
->write_volume
&& ret
)
2477 if (s
->thread_info
.volume_changes
) {
2479 *usec_to_next
= s
->thread_info
.volume_changes
->at
- now
;
2480 if (pa_log_ratelimit(PA_LOG_DEBUG
))
2481 pa_log_debug("Next volume change in %lld usec", (long long) (s
->thread_info
.volume_changes
->at
- now
));
2486 s
->thread_info
.volume_changes_tail
= NULL
;
2492 /* Called from the main thread */
2493 /* Gets the list of formats supported by the source. The members and idxset must
2494 * be freed by the caller. */
2495 pa_idxset
* pa_source_get_formats(pa_source
*s
) {
2500 if (s
->get_formats
) {
2501 /* Source supports format query, all is good */
2502 ret
= s
->get_formats(s
);
2504 /* Source doesn't support format query, so assume it does PCM */
2505 pa_format_info
*f
= pa_format_info_new();
2506 f
->encoding
= PA_ENCODING_PCM
;
2508 ret
= pa_idxset_new(NULL
, NULL
);
2509 pa_idxset_put(ret
, f
, NULL
);
2515 /* Called from the main thread */
2516 /* Checks if the source can accept this format */
2517 pa_bool_t
pa_source_check_format(pa_source
*s
, pa_format_info
*f
)
2519 pa_idxset
*formats
= NULL
;
2520 pa_bool_t ret
= FALSE
;
2525 formats
= pa_source_get_formats(s
);
2528 pa_format_info
*finfo_device
;
2531 PA_IDXSET_FOREACH(finfo_device
, formats
, i
) {
2532 if (pa_format_info_is_compatible(finfo_device
, f
)) {
2538 pa_idxset_free(formats
, (pa_free2_cb_t
) pa_format_info_free2
, NULL
);
2544 /* Called from the main thread */
2545 /* Calculates the intersection between formats supported by the source and
2546 * in_formats, and returns these, in the order of the source's formats. */
2547 pa_idxset
* pa_source_check_formats(pa_source
*s
, pa_idxset
*in_formats
) {
2548 pa_idxset
*out_formats
= pa_idxset_new(NULL
, NULL
), *source_formats
= NULL
;
2549 pa_format_info
*f_source
, *f_in
;
2554 if (!in_formats
|| pa_idxset_isempty(in_formats
))
2557 source_formats
= pa_source_get_formats(s
);
2559 PA_IDXSET_FOREACH(f_source
, source_formats
, i
) {
2560 PA_IDXSET_FOREACH(f_in
, in_formats
, j
) {
2561 if (pa_format_info_is_compatible(f_source
, f_in
))
2562 pa_idxset_put(out_formats
, pa_format_info_copy(f_in
), NULL
);
2568 pa_idxset_free(source_formats
, (pa_free2_cb_t
) pa_format_info_free2
, NULL
);