2 This file is part of PulseAudio.
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
31 #include <pulse/introspect.h>
32 #include <pulse/utf8.h>
33 #include <pulse/xmalloc.h>
34 #include <pulse/timeval.h>
35 #include <pulse/util.h>
36 #include <pulse/i18n.h>
38 #include <pulsecore/sink-input.h>
39 #include <pulsecore/namereg.h>
40 #include <pulsecore/core-util.h>
41 #include <pulsecore/sample-util.h>
42 #include <pulsecore/core-subscribe.h>
43 #include <pulsecore/log.h>
44 #include <pulsecore/macro.h>
45 #include <pulsecore/play-memblockq.h>
49 #define MAX_MIX_CHANNELS 32
50 #define MIX_BUFFER_LENGTH (PA_PAGE_SIZE)
51 #define ABSOLUTE_MIN_LATENCY (500)
52 #define ABSOLUTE_MAX_LATENCY (10*PA_USEC_PER_SEC)
53 #define DEFAULT_FIXED_LATENCY (250*PA_USEC_PER_MSEC)
55 static PA_DEFINE_CHECK_TYPE(pa_sink
, pa_msgobject
);
57 static void sink_free(pa_object
*s
);
59 pa_sink_new_data
* pa_sink_new_data_init(pa_sink_new_data
*data
) {
62 memset(data
, 0, sizeof(*data
));
63 data
->proplist
= pa_proplist_new();
68 void pa_sink_new_data_set_name(pa_sink_new_data
*data
, const char *name
) {
72 data
->name
= pa_xstrdup(name
);
75 void pa_sink_new_data_set_sample_spec(pa_sink_new_data
*data
, const pa_sample_spec
*spec
) {
78 if ((data
->sample_spec_is_set
= !!spec
))
79 data
->sample_spec
= *spec
;
82 void pa_sink_new_data_set_channel_map(pa_sink_new_data
*data
, const pa_channel_map
*map
) {
85 if ((data
->channel_map_is_set
= !!map
))
86 data
->channel_map
= *map
;
89 void pa_sink_new_data_set_volume(pa_sink_new_data
*data
, const pa_cvolume
*volume
) {
92 if ((data
->volume_is_set
= !!volume
))
93 data
->volume
= *volume
;
96 void pa_sink_new_data_set_muted(pa_sink_new_data
*data
, pa_bool_t mute
) {
99 data
->muted_is_set
= TRUE
;
100 data
->muted
= !!mute
;
103 void pa_sink_new_data_set_port(pa_sink_new_data
*data
, const char *port
) {
106 pa_xfree(data
->active_port
);
107 data
->active_port
= pa_xstrdup(port
);
110 void pa_sink_new_data_done(pa_sink_new_data
*data
) {
113 pa_proplist_free(data
->proplist
);
118 while ((p
= pa_hashmap_steal_first(data
->ports
)))
119 pa_device_port_free(p
);
121 pa_hashmap_free(data
->ports
, NULL
, NULL
);
124 pa_xfree(data
->name
);
125 pa_xfree(data
->active_port
);
128 pa_device_port
*pa_device_port_new(const char *name
, const char *description
, size_t extra
) {
133 p
= pa_xmalloc(PA_ALIGN(sizeof(pa_device_port
)) + extra
);
134 p
->name
= pa_xstrdup(name
);
135 p
->description
= pa_xstrdup(description
);
142 void pa_device_port_free(pa_device_port
*p
) {
146 pa_xfree(p
->description
);
150 /* Called from main context */
151 static void reset_callbacks(pa_sink
*s
) {
155 s
->get_volume
= NULL
;
156 s
->set_volume
= NULL
;
159 s
->request_rewind
= NULL
;
160 s
->update_requested_latency
= NULL
;
164 /* Called from main context */
165 pa_sink
* pa_sink_new(
167 pa_sink_new_data
*data
,
168 pa_sink_flags_t flags
) {
172 char st
[PA_SAMPLE_SPEC_SNPRINT_MAX
], cm
[PA_CHANNEL_MAP_SNPRINT_MAX
];
173 pa_source_new_data source_data
;
179 pa_assert(data
->name
);
181 s
= pa_msgobject_new(pa_sink
);
183 if (!(name
= pa_namereg_register(core
, data
->name
, PA_NAMEREG_SINK
, s
, data
->namereg_fail
))) {
184 pa_log_debug("Failed to register name %s.", data
->name
);
189 pa_sink_new_data_set_name(data
, name
);
191 if (pa_hook_fire(&core
->hooks
[PA_CORE_HOOK_SINK_NEW
], data
) < 0) {
193 pa_namereg_unregister(core
, name
);
197 /* FIXME, need to free s here on failure */
199 pa_return_null_if_fail(!data
->driver
|| pa_utf8_valid(data
->driver
));
200 pa_return_null_if_fail(data
->name
&& pa_utf8_valid(data
->name
) && data
->name
[0]);
202 pa_return_null_if_fail(data
->sample_spec_is_set
&& pa_sample_spec_valid(&data
->sample_spec
));
204 if (!data
->channel_map_is_set
)
205 pa_return_null_if_fail(pa_channel_map_init_auto(&data
->channel_map
, data
->sample_spec
.channels
, PA_CHANNEL_MAP_DEFAULT
));
207 pa_return_null_if_fail(pa_channel_map_valid(&data
->channel_map
));
208 pa_return_null_if_fail(data
->channel_map
.channels
== data
->sample_spec
.channels
);
210 if (!data
->volume_is_set
)
211 pa_cvolume_reset(&data
->volume
, data
->sample_spec
.channels
);
213 pa_return_null_if_fail(pa_cvolume_valid(&data
->volume
));
214 pa_return_null_if_fail(data
->volume
.channels
== data
->sample_spec
.channels
);
216 if (!data
->muted_is_set
)
220 pa_proplist_update(data
->proplist
, PA_UPDATE_MERGE
, data
->card
->proplist
);
222 pa_device_init_description(data
->proplist
);
223 pa_device_init_icon(data
->proplist
, TRUE
);
224 pa_device_init_intended_roles(data
->proplist
);
226 if (pa_hook_fire(&core
->hooks
[PA_CORE_HOOK_SINK_FIXATE
], data
) < 0) {
228 pa_namereg_unregister(core
, name
);
232 s
->parent
.parent
.free
= sink_free
;
233 s
->parent
.process_msg
= pa_sink_process_msg
;
236 s
->state
= PA_SINK_INIT
;
238 s
->suspend_cause
= 0;
239 s
->name
= pa_xstrdup(name
);
240 s
->proplist
= pa_proplist_copy(data
->proplist
);
241 s
->driver
= pa_xstrdup(pa_path_get_filename(data
->driver
));
242 s
->module
= data
->module
;
243 s
->card
= data
->card
;
245 s
->sample_spec
= data
->sample_spec
;
246 s
->channel_map
= data
->channel_map
;
248 s
->inputs
= pa_idxset_new(NULL
, NULL
);
251 s
->reference_volume
= s
->virtual_volume
= data
->volume
;
252 pa_cvolume_reset(&s
->soft_volume
, s
->sample_spec
.channels
);
253 s
->base_volume
= PA_VOLUME_NORM
;
254 s
->n_volume_steps
= PA_VOLUME_NORM
+1;
255 s
->muted
= data
->muted
;
256 s
->refresh_volume
= s
->refresh_muted
= FALSE
;
258 s
->fixed_latency
= flags
& PA_SINK_DYNAMIC_LATENCY
? 0 : DEFAULT_FIXED_LATENCY
;
266 /* As a minor optimization we just steal the list instead of
268 s
->ports
= data
->ports
;
271 s
->active_port
= NULL
;
272 s
->save_port
= FALSE
;
274 if (data
->active_port
&& s
->ports
)
275 if ((s
->active_port
= pa_hashmap_get(s
->ports
, data
->active_port
)))
276 s
->save_port
= data
->save_port
;
278 if (!s
->active_port
&& s
->ports
) {
282 PA_HASHMAP_FOREACH(p
, s
->ports
, state
)
283 if (!s
->active_port
|| p
->priority
> s
->active_port
->priority
)
287 s
->save_volume
= data
->save_volume
;
288 s
->save_muted
= data
->save_muted
;
290 pa_silence_memchunk_get(
291 &core
->silence_cache
,
297 s
->thread_info
.inputs
= pa_hashmap_new(pa_idxset_trivial_hash_func
, pa_idxset_trivial_compare_func
);
298 s
->thread_info
.soft_volume
= s
->soft_volume
;
299 s
->thread_info
.soft_muted
= s
->muted
;
300 s
->thread_info
.state
= s
->state
;
301 s
->thread_info
.rewind_nbytes
= 0;
302 s
->thread_info
.rewind_requested
= FALSE
;
303 s
->thread_info
.max_rewind
= 0;
304 s
->thread_info
.max_request
= 0;
305 s
->thread_info
.requested_latency_valid
= FALSE
;
306 s
->thread_info
.requested_latency
= 0;
307 s
->thread_info
.min_latency
= ABSOLUTE_MIN_LATENCY
;
308 s
->thread_info
.max_latency
= ABSOLUTE_MAX_LATENCY
;
310 pa_assert_se(pa_idxset_put(core
->sinks
, s
, &s
->index
) >= 0);
313 pa_assert_se(pa_idxset_put(s
->card
->sinks
, s
, NULL
) >= 0);
315 pt
= pa_proplist_to_string_sep(s
->proplist
, "\n ");
316 pa_log_info("Created sink %u \"%s\" with sample spec %s and channel map %s\n %s",
319 pa_sample_spec_snprint(st
, sizeof(st
), &s
->sample_spec
),
320 pa_channel_map_snprint(cm
, sizeof(cm
), &s
->channel_map
),
324 pa_source_new_data_init(&source_data
);
325 pa_source_new_data_set_sample_spec(&source_data
, &s
->sample_spec
);
326 pa_source_new_data_set_channel_map(&source_data
, &s
->channel_map
);
327 source_data
.name
= pa_sprintf_malloc("%s.monitor", name
);
328 source_data
.driver
= data
->driver
;
329 source_data
.module
= data
->module
;
330 source_data
.card
= data
->card
;
332 dn
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
333 pa_proplist_setf(source_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "Monitor of %s", dn
? dn
: s
->name
);
334 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_CLASS
, "monitor");
336 s
->monitor_source
= pa_source_new(core
, &source_data
,
337 ((flags
& PA_SINK_LATENCY
) ? PA_SOURCE_LATENCY
: 0) |
338 ((flags
& PA_SINK_DYNAMIC_LATENCY
) ? PA_SOURCE_DYNAMIC_LATENCY
: 0));
340 pa_source_new_data_done(&source_data
);
342 if (!s
->monitor_source
) {
348 s
->monitor_source
->monitor_of
= s
;
350 pa_source_set_latency_range(s
->monitor_source
, s
->thread_info
.min_latency
, s
->thread_info
.max_latency
);
351 pa_source_set_max_rewind(s
->monitor_source
, s
->thread_info
.max_rewind
);
356 /* Called from main context */
357 static int sink_set_state(pa_sink
*s
, pa_sink_state_t state
) {
359 pa_bool_t suspend_change
;
360 pa_sink_state_t original_state
;
364 if (s
->state
== state
)
367 original_state
= s
->state
;
370 (original_state
== PA_SINK_SUSPENDED
&& PA_SINK_IS_OPENED(state
)) ||
371 (PA_SINK_IS_OPENED(original_state
) && state
== PA_SINK_SUSPENDED
);
374 if ((ret
= s
->set_state(s
, state
)) < 0)
378 if ((ret
= pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_SET_STATE
, PA_UINT_TO_PTR(state
), 0, NULL
)) < 0) {
381 s
->set_state(s
, original_state
);
388 if (state
!= PA_SINK_UNLINKED
) { /* if we enter UNLINKED state pa_sink_unlink() will fire the apropriate events */
389 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SINK_STATE_CHANGED
], s
);
390 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
| PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
393 if (suspend_change
) {
397 /* We're suspending or resuming, tell everyone about it */
399 for (i
= PA_SINK_INPUT(pa_idxset_first(s
->inputs
, &idx
)); i
; i
= PA_SINK_INPUT(pa_idxset_next(s
->inputs
, &idx
)))
400 if (s
->state
== PA_SINK_SUSPENDED
&&
401 (i
->flags
& PA_SINK_INPUT_FAIL_ON_SUSPEND
))
402 pa_sink_input_kill(i
);
404 i
->suspend(i
, state
== PA_SINK_SUSPENDED
);
406 if (s
->monitor_source
)
407 pa_source_sync_suspend(s
->monitor_source
);
413 /* Called from main context */
414 void pa_sink_put(pa_sink
* s
) {
415 pa_sink_assert_ref(s
);
417 pa_assert(s
->state
== PA_SINK_INIT
);
419 /* The following fields must be initialized properly when calling _put() */
420 pa_assert(s
->asyncmsgq
);
421 pa_assert(s
->rtpoll
);
422 pa_assert(s
->thread_info
.min_latency
<= s
->thread_info
.max_latency
);
424 /* Generally, flags should be initialized via pa_sink_new(). As a
425 * special exception we allow volume related flags to be set
426 * between _new() and _put(). */
428 if (!(s
->flags
& PA_SINK_HW_VOLUME_CTRL
))
429 s
->flags
|= PA_SINK_DECIBEL_VOLUME
;
431 if ((s
->flags
& PA_SINK_DECIBEL_VOLUME
) && s
->core
->flat_volumes
)
432 s
->flags
|= PA_SINK_FLAT_VOLUME
;
434 s
->thread_info
.soft_volume
= s
->soft_volume
;
435 s
->thread_info
.soft_muted
= s
->muted
;
437 pa_assert((s
->flags
& PA_SINK_HW_VOLUME_CTRL
) || (s
->base_volume
== PA_VOLUME_NORM
&& s
->flags
& PA_SINK_DECIBEL_VOLUME
));
438 pa_assert(!(s
->flags
& PA_SINK_DECIBEL_VOLUME
) || s
->n_volume_steps
== PA_VOLUME_NORM
+1);
439 pa_assert(!(s
->flags
& PA_SINK_DYNAMIC_LATENCY
) == (s
->fixed_latency
!= 0));
440 pa_assert(!(s
->flags
& PA_SINK_LATENCY
) == !(s
->monitor_source
->flags
& PA_SOURCE_LATENCY
));
441 pa_assert(!(s
->flags
& PA_SINK_DYNAMIC_LATENCY
) == !(s
->monitor_source
->flags
& PA_SOURCE_DYNAMIC_LATENCY
));
443 pa_assert(s
->monitor_source
->fixed_latency
== s
->fixed_latency
);
444 pa_assert(s
->monitor_source
->thread_info
.min_latency
== s
->thread_info
.min_latency
);
445 pa_assert(s
->monitor_source
->thread_info
.max_latency
== s
->thread_info
.max_latency
);
447 pa_assert_se(sink_set_state(s
, PA_SINK_IDLE
) == 0);
449 pa_source_put(s
->monitor_source
);
451 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
| PA_SUBSCRIPTION_EVENT_NEW
, s
->index
);
452 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SINK_PUT
], s
);
455 /* Called from main context */
456 void pa_sink_unlink(pa_sink
* s
) {
458 pa_sink_input
*i
, *j
= NULL
;
462 /* Please note that pa_sink_unlink() does more than simply
463 * reversing pa_sink_put(). It also undoes the registrations
464 * already done in pa_sink_new()! */
466 /* All operations here shall be idempotent, i.e. pa_sink_unlink()
467 * may be called multiple times on the same sink without bad
470 linked
= PA_SINK_IS_LINKED(s
->state
);
473 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SINK_UNLINK
], s
);
475 if (s
->state
!= PA_SINK_UNLINKED
)
476 pa_namereg_unregister(s
->core
, s
->name
);
477 pa_idxset_remove_by_data(s
->core
->sinks
, s
, NULL
);
480 pa_idxset_remove_by_data(s
->card
->sinks
, s
, NULL
);
482 while ((i
= pa_idxset_first(s
->inputs
, NULL
))) {
484 pa_sink_input_kill(i
);
489 sink_set_state(s
, PA_SINK_UNLINKED
);
491 s
->state
= PA_SINK_UNLINKED
;
495 if (s
->monitor_source
)
496 pa_source_unlink(s
->monitor_source
);
499 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
| PA_SUBSCRIPTION_EVENT_REMOVE
, s
->index
);
500 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SINK_UNLINK_POST
], s
);
504 /* Called from main context */
505 static void sink_free(pa_object
*o
) {
506 pa_sink
*s
= PA_SINK(o
);
510 pa_assert(pa_sink_refcnt(s
) == 0);
512 if (PA_SINK_IS_LINKED(s
->state
))
515 pa_log_info("Freeing sink %u \"%s\"", s
->index
, s
->name
);
517 if (s
->monitor_source
) {
518 pa_source_unref(s
->monitor_source
);
519 s
->monitor_source
= NULL
;
522 pa_idxset_free(s
->inputs
, NULL
, NULL
);
524 while ((i
= pa_hashmap_steal_first(s
->thread_info
.inputs
)))
525 pa_sink_input_unref(i
);
527 pa_hashmap_free(s
->thread_info
.inputs
, NULL
, NULL
);
529 if (s
->silence
.memblock
)
530 pa_memblock_unref(s
->silence
.memblock
);
536 pa_proplist_free(s
->proplist
);
541 while ((p
= pa_hashmap_steal_first(s
->ports
)))
542 pa_device_port_free(p
);
544 pa_hashmap_free(s
->ports
, NULL
, NULL
);
550 /* Called from main context */
551 void pa_sink_set_asyncmsgq(pa_sink
*s
, pa_asyncmsgq
*q
) {
552 pa_sink_assert_ref(s
);
556 if (s
->monitor_source
)
557 pa_source_set_asyncmsgq(s
->monitor_source
, q
);
560 /* Called from main context */
561 void pa_sink_set_rtpoll(pa_sink
*s
, pa_rtpoll
*p
) {
562 pa_sink_assert_ref(s
);
566 if (s
->monitor_source
)
567 pa_source_set_rtpoll(s
->monitor_source
, p
);
570 /* Called from main context */
571 int pa_sink_update_status(pa_sink
*s
) {
572 pa_sink_assert_ref(s
);
573 pa_assert(PA_SINK_IS_LINKED(s
->state
));
575 if (s
->state
== PA_SINK_SUSPENDED
)
578 return sink_set_state(s
, pa_sink_used_by(s
) ? PA_SINK_RUNNING
: PA_SINK_IDLE
);
581 /* Called from main context */
582 int pa_sink_suspend(pa_sink
*s
, pa_bool_t suspend
, pa_suspend_cause_t cause
) {
583 pa_sink_assert_ref(s
);
584 pa_assert(PA_SINK_IS_LINKED(s
->state
));
585 pa_assert(cause
!= 0);
588 s
->suspend_cause
|= cause
;
589 s
->monitor_source
->suspend_cause
|= cause
;
591 s
->suspend_cause
&= ~cause
;
592 s
->monitor_source
->suspend_cause
&= ~cause
;
595 if ((pa_sink_get_state(s
) == PA_SINK_SUSPENDED
) == !!s
->suspend_cause
)
598 pa_log_debug("Suspend cause of sink %s is 0x%04x, %s", s
->name
, s
->suspend_cause
, s
->suspend_cause
? "suspending" : "resuming");
600 if (s
->suspend_cause
)
601 return sink_set_state(s
, PA_SINK_SUSPENDED
);
603 return sink_set_state(s
, pa_sink_used_by(s
) ? PA_SINK_RUNNING
: PA_SINK_IDLE
);
606 /* Called from main context */
607 pa_queue
*pa_sink_move_all_start(pa_sink
*s
, pa_queue
*q
) {
608 pa_sink_input
*i
, *n
;
611 pa_sink_assert_ref(s
);
612 pa_assert(PA_SINK_IS_LINKED(s
->state
));
617 for (i
= PA_SINK_INPUT(pa_idxset_first(s
->inputs
, &idx
)); i
; i
= n
) {
618 n
= PA_SINK_INPUT(pa_idxset_next(s
->inputs
, &idx
));
620 pa_sink_input_ref(i
);
622 if (pa_sink_input_start_move(i
) >= 0)
625 pa_sink_input_unref(i
);
631 /* Called from main context */
632 void pa_sink_move_all_finish(pa_sink
*s
, pa_queue
*q
, pa_bool_t save
) {
635 pa_sink_assert_ref(s
);
636 pa_assert(PA_SINK_IS_LINKED(s
->state
));
639 while ((i
= PA_SINK_INPUT(pa_queue_pop(q
)))) {
640 if (pa_sink_input_finish_move(i
, s
, save
) < 0)
641 pa_sink_input_kill(i
);
643 pa_sink_input_unref(i
);
646 pa_queue_free(q
, NULL
, NULL
);
649 /* Called from main context */
650 void pa_sink_move_all_fail(pa_queue
*q
) {
654 while ((i
= PA_SINK_INPUT(pa_queue_pop(q
)))) {
655 if (pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL
], i
) == PA_HOOK_OK
) {
656 pa_sink_input_kill(i
);
657 pa_sink_input_unref(i
);
661 pa_queue_free(q
, NULL
, NULL
);
664 /* Called from IO thread context */
665 void pa_sink_process_rewind(pa_sink
*s
, size_t nbytes
) {
668 pa_sink_assert_ref(s
);
669 pa_assert(PA_SINK_IS_LINKED(s
->thread_info
.state
));
671 /* If nobody requested this and this is actually no real rewind
672 * then we can short cut this */
673 if (!s
->thread_info
.rewind_requested
&& nbytes
<= 0)
676 s
->thread_info
.rewind_nbytes
= 0;
677 s
->thread_info
.rewind_requested
= FALSE
;
679 if (s
->thread_info
.state
== PA_SINK_SUSPENDED
)
683 pa_log_debug("Processing rewind...");
685 while ((i
= pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
))) {
686 pa_sink_input_assert_ref(i
);
687 pa_sink_input_process_rewind(i
, nbytes
);
691 if (s
->monitor_source
&& PA_SOURCE_IS_LINKED(s
->monitor_source
->thread_info
.state
))
692 pa_source_process_rewind(s
->monitor_source
, nbytes
);
695 /* Called from IO thread context */
696 static unsigned fill_mix_info(pa_sink
*s
, size_t *length
, pa_mix_info
*info
, unsigned maxinfo
) {
700 size_t mixlength
= *length
;
702 pa_sink_assert_ref(s
);
705 while ((i
= pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
)) && maxinfo
> 0) {
706 pa_sink_input_assert_ref(i
);
708 pa_sink_input_peek(i
, *length
, &info
->chunk
, &info
->volume
);
710 if (mixlength
== 0 || info
->chunk
.length
< mixlength
)
711 mixlength
= info
->chunk
.length
;
713 if (pa_memblock_is_silence(info
->chunk
.memblock
)) {
714 pa_memblock_unref(info
->chunk
.memblock
);
718 info
->userdata
= pa_sink_input_ref(i
);
720 pa_assert(info
->chunk
.memblock
);
721 pa_assert(info
->chunk
.length
> 0);
734 /* Called from IO thread context */
735 static void inputs_drop(pa_sink
*s
, pa_mix_info
*info
, unsigned n
, pa_memchunk
*result
) {
739 unsigned n_unreffed
= 0;
741 pa_sink_assert_ref(s
);
743 pa_assert(result
->memblock
);
744 pa_assert(result
->length
> 0);
746 /* We optimize for the case where the order of the inputs has not changed */
748 while ((i
= pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
))) {
750 pa_mix_info
* m
= NULL
;
752 pa_sink_input_assert_ref(i
);
754 /* Let's try to find the matching entry info the pa_mix_info array */
755 for (j
= 0; j
< n
; j
++) {
757 if (info
[p
].userdata
== i
) {
768 pa_sink_input_drop(i
, result
->length
);
770 if (s
->monitor_source
&& PA_SOURCE_IS_LINKED(s
->monitor_source
->thread_info
.state
)) {
772 if (pa_hashmap_size(i
->thread_info
.direct_outputs
) > 0) {
777 if (m
&& m
->chunk
.memblock
) {
779 pa_memblock_ref(c
.memblock
);
780 pa_assert(result
->length
<= c
.length
);
781 c
.length
= result
->length
;
783 pa_memchunk_make_writable(&c
, 0);
784 pa_volume_memchunk(&c
, &s
->sample_spec
, &m
->volume
);
787 pa_memblock_ref(c
.memblock
);
788 pa_assert(result
->length
<= c
.length
);
789 c
.length
= result
->length
;
792 while ((o
= pa_hashmap_iterate(i
->thread_info
.direct_outputs
, &ostate
, NULL
))) {
793 pa_source_output_assert_ref(o
);
794 pa_assert(o
->direct_on_input
== i
);
795 pa_source_post_direct(s
->monitor_source
, o
, &c
);
798 pa_memblock_unref(c
.memblock
);
803 if (m
->chunk
.memblock
)
804 pa_memblock_unref(m
->chunk
.memblock
);
805 pa_memchunk_reset(&m
->chunk
);
807 pa_sink_input_unref(m
->userdata
);
814 /* Now drop references to entries that are included in the
815 * pa_mix_info array but don't exist anymore */
817 if (n_unreffed
< n
) {
818 for (; n
> 0; info
++, n
--) {
820 pa_sink_input_unref(info
->userdata
);
821 if (info
->chunk
.memblock
)
822 pa_memblock_unref(info
->chunk
.memblock
);
826 if (s
->monitor_source
&& PA_SOURCE_IS_LINKED(s
->monitor_source
->thread_info
.state
))
827 pa_source_post(s
->monitor_source
, result
);
830 /* Called from IO thread context */
831 void pa_sink_render(pa_sink
*s
, size_t length
, pa_memchunk
*result
) {
832 pa_mix_info info
[MAX_MIX_CHANNELS
];
834 size_t block_size_max
;
836 pa_sink_assert_ref(s
);
837 pa_assert(PA_SINK_IS_LINKED(s
->thread_info
.state
));
838 pa_assert(pa_frame_aligned(length
, &s
->sample_spec
));
843 pa_assert(!s
->thread_info
.rewind_requested
);
844 pa_assert(s
->thread_info
.rewind_nbytes
== 0);
846 if (s
->thread_info
.state
== PA_SINK_SUSPENDED
) {
847 result
->memblock
= pa_memblock_ref(s
->silence
.memblock
);
848 result
->index
= s
->silence
.index
;
849 result
->length
= PA_MIN(s
->silence
.length
, length
);
854 length
= pa_frame_align(MIX_BUFFER_LENGTH
, &s
->sample_spec
);
856 block_size_max
= pa_mempool_block_size_max(s
->core
->mempool
);
857 if (length
> block_size_max
)
858 length
= pa_frame_align(block_size_max
, &s
->sample_spec
);
860 pa_assert(length
> 0);
862 n
= fill_mix_info(s
, &length
, info
, MAX_MIX_CHANNELS
);
866 *result
= s
->silence
;
867 pa_memblock_ref(result
->memblock
);
869 if (result
->length
> length
)
870 result
->length
= length
;
875 *result
= info
[0].chunk
;
876 pa_memblock_ref(result
->memblock
);
878 if (result
->length
> length
)
879 result
->length
= length
;
881 pa_sw_cvolume_multiply(&volume
, &s
->thread_info
.soft_volume
, &info
[0].volume
);
883 if (s
->thread_info
.soft_muted
|| !pa_cvolume_is_norm(&volume
)) {
884 if (s
->thread_info
.soft_muted
|| pa_cvolume_is_muted(&volume
)) {
885 pa_memblock_unref(result
->memblock
);
886 pa_silence_memchunk_get(&s
->core
->silence_cache
,
892 pa_memchunk_make_writable(result
, 0);
893 pa_volume_memchunk(result
, &s
->sample_spec
, &volume
);
898 result
->memblock
= pa_memblock_new(s
->core
->mempool
, length
);
900 ptr
= pa_memblock_acquire(result
->memblock
);
901 result
->length
= pa_mix(info
, n
,
904 &s
->thread_info
.soft_volume
,
905 s
->thread_info
.soft_muted
);
906 pa_memblock_release(result
->memblock
);
911 inputs_drop(s
, info
, n
, result
);
916 /* Called from IO thread context */
917 void pa_sink_render_into(pa_sink
*s
, pa_memchunk
*target
) {
918 pa_mix_info info
[MAX_MIX_CHANNELS
];
920 size_t length
, block_size_max
;
922 pa_sink_assert_ref(s
);
923 pa_assert(PA_SINK_IS_LINKED(s
->thread_info
.state
));
925 pa_assert(target
->memblock
);
926 pa_assert(target
->length
> 0);
927 pa_assert(pa_frame_aligned(target
->length
, &s
->sample_spec
));
931 pa_assert(!s
->thread_info
.rewind_requested
);
932 pa_assert(s
->thread_info
.rewind_nbytes
== 0);
934 if (s
->thread_info
.state
== PA_SINK_SUSPENDED
) {
935 pa_silence_memchunk(target
, &s
->sample_spec
);
939 length
= target
->length
;
940 block_size_max
= pa_mempool_block_size_max(s
->core
->mempool
);
941 if (length
> block_size_max
)
942 length
= pa_frame_align(block_size_max
, &s
->sample_spec
);
944 pa_assert(length
> 0);
946 n
= fill_mix_info(s
, &length
, info
, MAX_MIX_CHANNELS
);
949 if (target
->length
> length
)
950 target
->length
= length
;
952 pa_silence_memchunk(target
, &s
->sample_spec
);
956 if (target
->length
> length
)
957 target
->length
= length
;
959 pa_sw_cvolume_multiply(&volume
, &s
->thread_info
.soft_volume
, &info
[0].volume
);
961 if (s
->thread_info
.soft_muted
|| pa_cvolume_is_muted(&volume
))
962 pa_silence_memchunk(target
, &s
->sample_spec
);
966 vchunk
= info
[0].chunk
;
967 pa_memblock_ref(vchunk
.memblock
);
969 if (vchunk
.length
> length
)
970 vchunk
.length
= length
;
972 if (!pa_cvolume_is_norm(&volume
)) {
973 pa_memchunk_make_writable(&vchunk
, 0);
974 pa_volume_memchunk(&vchunk
, &s
->sample_spec
, &volume
);
977 pa_memchunk_memcpy(target
, &vchunk
);
978 pa_memblock_unref(vchunk
.memblock
);
984 ptr
= pa_memblock_acquire(target
->memblock
);
986 target
->length
= pa_mix(info
, n
,
987 (uint8_t*) ptr
+ target
->index
, length
,
989 &s
->thread_info
.soft_volume
,
990 s
->thread_info
.soft_muted
);
992 pa_memblock_release(target
->memblock
);
995 inputs_drop(s
, info
, n
, target
);
1000 /* Called from IO thread context */
1001 void pa_sink_render_into_full(pa_sink
*s
, pa_memchunk
*target
) {
1005 pa_sink_assert_ref(s
);
1006 pa_assert(PA_SINK_IS_LINKED(s
->thread_info
.state
));
1008 pa_assert(target
->memblock
);
1009 pa_assert(target
->length
> 0);
1010 pa_assert(pa_frame_aligned(target
->length
, &s
->sample_spec
));
1014 pa_assert(!s
->thread_info
.rewind_requested
);
1015 pa_assert(s
->thread_info
.rewind_nbytes
== 0);
1024 pa_sink_render_into(s
, &chunk
);
1033 /* Called from IO thread context */
1034 void pa_sink_render_full(pa_sink
*s
, size_t length
, pa_memchunk
*result
) {
1035 pa_mix_info info
[MAX_MIX_CHANNELS
];
1036 size_t length1st
= length
;
1039 pa_sink_assert_ref(s
);
1040 pa_assert(PA_SINK_IS_LINKED(s
->thread_info
.state
));
1041 pa_assert(length
> 0);
1042 pa_assert(pa_frame_aligned(length
, &s
->sample_spec
));
1047 pa_assert(!s
->thread_info
.rewind_requested
);
1048 pa_assert(s
->thread_info
.rewind_nbytes
== 0);
1050 pa_assert(length
> 0);
1052 n
= fill_mix_info(s
, &length1st
, info
, MAX_MIX_CHANNELS
);
1055 pa_silence_memchunk_get(&s
->core
->silence_cache
,
1060 } else if (n
== 1) {
1063 *result
= info
[0].chunk
;
1064 pa_memblock_ref(result
->memblock
);
1066 if (result
->length
> length
)
1067 result
->length
= length
;
1069 pa_sw_cvolume_multiply(&volume
, &s
->thread_info
.soft_volume
, &info
[0].volume
);
1071 if (s
->thread_info
.soft_muted
|| !pa_cvolume_is_norm(&volume
)) {
1072 if (s
->thread_info
.soft_muted
|| pa_cvolume_is_muted(&volume
)) {
1073 pa_memblock_unref(result
->memblock
);
1074 pa_silence_memchunk_get(&s
->core
->silence_cache
,
1080 pa_memchunk_make_writable(result
, length
);
1081 pa_volume_memchunk(result
, &s
->sample_spec
, &volume
);
1088 result
->memblock
= pa_memblock_new(s
->core
->mempool
, length
);
1090 ptr
= pa_memblock_acquire(result
->memblock
);
1092 result
->length
= pa_mix(info
, n
,
1093 (uint8_t*) ptr
+ result
->index
, length1st
,
1095 &s
->thread_info
.soft_volume
,
1096 s
->thread_info
.soft_muted
);
1098 pa_memblock_release(result
->memblock
);
1101 inputs_drop(s
, info
, n
, result
);
1103 if (result
->length
< length
) {
1106 pa_memchunk_make_writable(result
, length
);
1108 l
= length
- result
->length
;
1109 d
= result
->index
+ result
->length
;
1115 pa_sink_render_into(s
, &chunk
);
1120 result
->length
= length
;
1126 /* Called from main thread */
1127 pa_usec_t
pa_sink_get_latency(pa_sink
*s
) {
1130 pa_sink_assert_ref(s
);
1131 pa_assert(PA_SINK_IS_LINKED(s
->state
));
1133 /* The returned value is supposed to be in the time domain of the sound card! */
1135 if (s
->state
== PA_SINK_SUSPENDED
)
1138 if (!(s
->flags
& PA_SINK_LATENCY
))
1141 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_GET_LATENCY
, &usec
, 0, NULL
) == 0);
1146 /* Called from IO thread */
1147 pa_usec_t
pa_sink_get_latency_within_thread(pa_sink
*s
) {
1151 pa_sink_assert_ref(s
);
1152 pa_assert(PA_SINK_IS_LINKED(s
->thread_info
.state
));
1154 /* The returned value is supposed to be in the time domain of the sound card! */
1156 if (s
->thread_info
.state
== PA_SINK_SUSPENDED
)
1159 if (!(s
->flags
& PA_SINK_LATENCY
))
1162 o
= PA_MSGOBJECT(s
);
1164 /* We probably should make this a proper vtable callback instead of going through process_msg() */
1166 if (o
->process_msg(o
, PA_SINK_MESSAGE_GET_LATENCY
, &usec
, 0, NULL
) < 0)
1172 static void compute_new_soft_volume(pa_sink_input
*i
, const pa_cvolume
*new_volume
) {
1175 pa_sink_input_assert_ref(i
);
1176 pa_assert(new_volume
->channels
== i
->sample_spec
.channels
);
1179 * This basically calculates:
1181 * i->relative_volume := i->virtual_volume / new_volume
1182 * i->soft_volume := i->relative_volume * i->volume_factor
1185 /* The new sink volume passed in here must already be remapped to
1186 * the sink input's channel map! */
1188 i
->soft_volume
.channels
= i
->sample_spec
.channels
;
1190 for (c
= 0; c
< i
->sample_spec
.channels
; c
++)
1192 if (new_volume
->values
[c
] <= PA_VOLUME_MUTED
)
1193 /* We leave i->relative_volume untouched */
1194 i
->soft_volume
.values
[c
] = PA_VOLUME_MUTED
;
1196 i
->relative_volume
[c
] =
1197 pa_sw_volume_to_linear(i
->virtual_volume
.values
[c
]) /
1198 pa_sw_volume_to_linear(new_volume
->values
[c
]);
1200 i
->soft_volume
.values
[c
] = pa_sw_volume_from_linear(
1201 i
->relative_volume
[c
] *
1202 pa_sw_volume_to_linear(i
->volume_factor
.values
[c
]));
1205 /* Hooks have the ability to play games with i->soft_volume */
1206 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME
], i
);
1208 /* We don't copy the soft_volume to the thread_info data
1209 * here. That must be done by the caller */
1212 /* Called from main thread */
1213 void pa_sink_update_flat_volume(pa_sink
*s
, pa_cvolume
*new_volume
) {
1217 pa_sink_assert_ref(s
);
1218 pa_assert(new_volume
);
1219 pa_assert(PA_SINK_IS_LINKED(s
->state
));
1220 pa_assert(s
->flags
& PA_SINK_FLAT_VOLUME
);
1222 /* This is called whenever a sink input volume changes or a sink
1223 * input is added/removed and we might need to fix up the sink
1224 * volume accordingly. Please note that we don't actually update
1225 * the sinks volume here, we only return how it needs to be
1226 * updated. The caller should then call pa_sink_set_volume().*/
1228 if (pa_idxset_isempty(s
->inputs
)) {
1229 /* In the special case that we have no sink input we leave the
1230 * volume unmodified. */
1231 *new_volume
= s
->reference_volume
;
1235 pa_cvolume_mute(new_volume
, s
->channel_map
.channels
);
1237 /* First let's determine the new maximum volume of all inputs
1238 * connected to this sink */
1239 for (i
= PA_SINK_INPUT(pa_idxset_first(s
->inputs
, &idx
)); i
; i
= PA_SINK_INPUT(pa_idxset_next(s
->inputs
, &idx
))) {
1241 pa_cvolume remapped_volume
;
1243 remapped_volume
= i
->virtual_volume
;
1244 pa_cvolume_remap(&remapped_volume
, &i
->channel_map
, &s
->channel_map
);
1246 for (c
= 0; c
< new_volume
->channels
; c
++)
1247 if (remapped_volume
.values
[c
] > new_volume
->values
[c
])
1248 new_volume
->values
[c
] = remapped_volume
.values
[c
];
1251 /* Then, let's update the soft volumes of all inputs connected
1253 for (i
= PA_SINK_INPUT(pa_idxset_first(s
->inputs
, &idx
)); i
; i
= PA_SINK_INPUT(pa_idxset_next(s
->inputs
, &idx
))) {
1254 pa_cvolume remapped_new_volume
;
1256 remapped_new_volume
= *new_volume
;
1257 pa_cvolume_remap(&remapped_new_volume
, &s
->channel_map
, &i
->channel_map
);
1258 compute_new_soft_volume(i
, &remapped_new_volume
);
1260 /* We don't copy soft_volume to the thread_info data here
1261 * (i.e. issue PA_SINK_INPUT_MESSAGE_SET_VOLUME) because we
1262 * want the update to be atomically with the sink volume
1263 * update, hence we do it within the pa_sink_set_volume() call
1268 /* Called from main thread */
1269 void pa_sink_propagate_flat_volume(pa_sink
*s
) {
1273 pa_sink_assert_ref(s
);
1274 pa_assert(PA_SINK_IS_LINKED(s
->state
));
1275 pa_assert(s
->flags
& PA_SINK_FLAT_VOLUME
);
1277 /* This is called whenever the sink volume changes that is not
1278 * caused by a sink input volume change. We need to fix up the
1279 * sink input volumes accordingly */
1281 for (i
= PA_SINK_INPUT(pa_idxset_first(s
->inputs
, &idx
)); i
; i
= PA_SINK_INPUT(pa_idxset_next(s
->inputs
, &idx
))) {
1282 pa_cvolume sink_volume
, new_virtual_volume
;
1285 /* This basically calculates i->virtual_volume := i->relative_volume * s->virtual_volume */
1287 sink_volume
= s
->virtual_volume
;
1288 pa_cvolume_remap(&sink_volume
, &s
->channel_map
, &i
->channel_map
);
1290 for (c
= 0; c
< i
->sample_spec
.channels
; c
++)
1291 new_virtual_volume
.values
[c
] = pa_sw_volume_from_linear(
1292 i
->relative_volume
[c
] *
1293 pa_sw_volume_to_linear(sink_volume
.values
[c
]));
1295 new_virtual_volume
.channels
= i
->sample_spec
.channels
;
1297 if (!pa_cvolume_equal(&new_virtual_volume
, &i
->virtual_volume
)) {
1298 i
->virtual_volume
= new_virtual_volume
;
1300 /* Hmm, the soft volume might no longer actually match
1301 * what has been chosen as new virtual volume here,
1302 * especially when the old volume was
1303 * PA_VOLUME_MUTED. Hence let's recalculate the soft
1305 compute_new_soft_volume(i
, &sink_volume
);
1307 /* The virtual volume changed, let's tell people so */
1308 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1312 /* If the soft_volume of any of the sink inputs got changed, let's
1313 * make sure the thread copies are synced up. */
1314 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_SYNC_VOLUMES
, NULL
, 0, NULL
) == 0);
1317 /* Called from main thread */
1318 void pa_sink_set_volume(pa_sink
*s
, const pa_cvolume
*volume
, pa_bool_t propagate
, pa_bool_t sendmsg
, pa_bool_t become_reference
, pa_bool_t save
) {
1319 pa_bool_t virtual_volume_changed
;
1321 pa_sink_assert_ref(s
);
1322 pa_assert(PA_SINK_IS_LINKED(s
->state
));
1324 pa_assert(pa_cvolume_valid(volume
));
1325 pa_assert(pa_cvolume_compatible(volume
, &s
->sample_spec
));
1327 virtual_volume_changed
= !pa_cvolume_equal(volume
, &s
->virtual_volume
);
1328 s
->virtual_volume
= *volume
;
1329 s
->save_volume
= (!virtual_volume_changed
&& s
->save_volume
) || save
;
1331 if (become_reference
)
1332 s
->reference_volume
= s
->virtual_volume
;
1334 /* Propagate this volume change back to the inputs */
1335 if (virtual_volume_changed
)
1336 if (propagate
&& (s
->flags
& PA_SINK_FLAT_VOLUME
))
1337 pa_sink_propagate_flat_volume(s
);
1339 if (s
->set_volume
) {
1340 /* If we have a function set_volume(), then we do not apply a
1341 * soft volume by default. However, set_volume() is free to
1342 * apply one to s->soft_volume */
1344 pa_cvolume_reset(&s
->soft_volume
, s
->sample_spec
.channels
);
1348 /* If we have no function set_volume(), then the soft volume
1349 * becomes the virtual volume */
1350 s
->soft_volume
= s
->virtual_volume
;
1352 /* This tells the sink that soft and/or virtual volume changed */
1354 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_SET_VOLUME
, NULL
, 0, NULL
) == 0);
1356 if (virtual_volume_changed
)
1357 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1360 /* Called from main thread. Only to be called by sink implementor */
1361 void pa_sink_set_soft_volume(pa_sink
*s
, const pa_cvolume
*volume
) {
1362 pa_sink_assert_ref(s
);
1365 s
->soft_volume
= *volume
;
1367 if (PA_SINK_IS_LINKED(s
->state
))
1368 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_SET_VOLUME
, NULL
, 0, NULL
) == 0);
1370 s
->thread_info
.soft_volume
= *volume
;
1373 /* Called from main thread */
1374 const pa_cvolume
*pa_sink_get_volume(pa_sink
*s
, pa_bool_t force_refresh
, pa_bool_t reference
) {
1375 pa_sink_assert_ref(s
);
1377 if (s
->refresh_volume
|| force_refresh
) {
1378 struct pa_cvolume old_virtual_volume
= s
->virtual_volume
;
1383 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_GET_VOLUME
, NULL
, 0, NULL
) == 0);
1385 if (!pa_cvolume_equal(&old_virtual_volume
, &s
->virtual_volume
)) {
1387 s
->reference_volume
= s
->virtual_volume
;
1389 if (s
->flags
& PA_SINK_FLAT_VOLUME
)
1390 pa_sink_propagate_flat_volume(s
);
1392 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1396 return reference
? &s
->reference_volume
: &s
->virtual_volume
;
1399 /* Called from main thread */
1400 void pa_sink_volume_changed(pa_sink
*s
, const pa_cvolume
*new_volume
, pa_bool_t save
) {
1401 pa_sink_assert_ref(s
);
1403 /* The sink implementor may call this if the volume changed to make sure everyone is notified */
1404 if (pa_cvolume_equal(&s
->virtual_volume
, new_volume
)) {
1405 s
->save_volume
= s
->save_volume
|| save
;
1409 s
->reference_volume
= s
->virtual_volume
= *new_volume
;
1410 s
->save_volume
= save
;
1412 if (s
->flags
& PA_SINK_FLAT_VOLUME
)
1413 pa_sink_propagate_flat_volume(s
);
1415 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1418 /* Called from main thread */
1419 void pa_sink_set_mute(pa_sink
*s
, pa_bool_t mute
, pa_bool_t save
) {
1420 pa_bool_t old_muted
;
1422 pa_sink_assert_ref(s
);
1423 pa_assert(PA_SINK_IS_LINKED(s
->state
));
1425 old_muted
= s
->muted
;
1427 s
->save_muted
= (old_muted
== s
->muted
&& s
->save_muted
) || save
;
1432 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_SET_MUTE
, NULL
, 0, NULL
) == 0);
1434 if (old_muted
!= s
->muted
)
1435 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1438 /* Called from main thread */
1439 pa_bool_t
pa_sink_get_mute(pa_sink
*s
, pa_bool_t force_refresh
) {
1441 pa_sink_assert_ref(s
);
1443 if (s
->refresh_muted
|| force_refresh
) {
1444 pa_bool_t old_muted
= s
->muted
;
1449 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_GET_MUTE
, NULL
, 0, NULL
) == 0);
1451 if (old_muted
!= s
->muted
) {
1452 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1454 /* Make sure the soft mute status stays in sync */
1455 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_SET_MUTE
, NULL
, 0, NULL
) == 0);
1462 /* Called from main thread */
1463 void pa_sink_mute_changed(pa_sink
*s
, pa_bool_t new_muted
, pa_bool_t save
) {
1464 pa_sink_assert_ref(s
);
1466 /* The sink implementor may call this if the volume changed to make sure everyone is notified */
1468 if (s
->muted
== new_muted
) {
1469 s
->save_muted
= s
->save_muted
|| save
;
1473 s
->muted
= new_muted
;
1474 s
->save_muted
= save
;
1476 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1479 /* Called from main thread */
1480 pa_bool_t
pa_sink_update_proplist(pa_sink
*s
, pa_update_mode_t mode
, pa_proplist
*p
) {
1481 pa_sink_assert_ref(s
);
1484 pa_proplist_update(s
->proplist
, mode
, p
);
1486 if (PA_SINK_IS_LINKED(s
->state
)) {
1487 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SINK_PROPLIST_CHANGED
], s
);
1488 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1494 /* Called from main thread */
1495 void pa_sink_set_description(pa_sink
*s
, const char *description
) {
1497 pa_sink_assert_ref(s
);
1499 if (!description
&& !pa_proplist_contains(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
))
1502 old
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1504 if (old
&& description
&& !strcmp(old
, description
))
1508 pa_proplist_sets(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
, description
);
1510 pa_proplist_unset(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1512 if (s
->monitor_source
) {
1515 n
= pa_sprintf_malloc("Monitor Source of %s", description
? description
: s
->name
);
1516 pa_source_set_description(s
->monitor_source
, n
);
1520 if (PA_SINK_IS_LINKED(s
->state
)) {
1521 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
1522 pa_hook_fire(&s
->core
->hooks
[PA_CORE_HOOK_SINK_PROPLIST_CHANGED
], s
);
1526 /* Called from main thread */
1527 unsigned pa_sink_linked_by(pa_sink
*s
) {
1530 pa_sink_assert_ref(s
);
1531 pa_assert(PA_SINK_IS_LINKED(s
->state
));
1533 ret
= pa_idxset_size(s
->inputs
);
1535 /* We add in the number of streams connected to us here. Please
1536 * note the asymmmetry to pa_sink_used_by()! */
1538 if (s
->monitor_source
)
1539 ret
+= pa_source_linked_by(s
->monitor_source
);
1544 /* Called from main thread */
1545 unsigned pa_sink_used_by(pa_sink
*s
) {
1548 pa_sink_assert_ref(s
);
1549 pa_assert(PA_SINK_IS_LINKED(s
->state
));
1551 ret
= pa_idxset_size(s
->inputs
);
1552 pa_assert(ret
>= s
->n_corked
);
1554 /* Streams connected to our monitor source do not matter for
1555 * pa_sink_used_by()!.*/
1557 return ret
- s
->n_corked
;
1560 /* Called from main thread */
1561 unsigned pa_sink_check_suspend(pa_sink
*s
) {
1566 pa_sink_assert_ref(s
);
1568 if (!PA_SINK_IS_LINKED(s
->state
))
1573 PA_IDXSET_FOREACH(i
, s
->inputs
, idx
) {
1574 pa_sink_input_state_t st
;
1576 st
= pa_sink_input_get_state(i
);
1577 pa_assert(PA_SINK_INPUT_IS_LINKED(st
));
1579 if (st
== PA_SINK_INPUT_CORKED
)
1582 if (i
->flags
& PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND
)
1588 if (s
->monitor_source
)
1589 ret
+= pa_source_check_suspend(s
->monitor_source
);
1594 /* Called from the IO thread */
1595 static void sync_input_volumes_within_thread(pa_sink
*s
) {
1599 pa_sink_assert_ref(s
);
1601 while ((i
= PA_SINK_INPUT(pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
)))) {
1602 if (pa_cvolume_equal(&i
->thread_info
.soft_volume
, &i
->soft_volume
))
1605 i
->thread_info
.soft_volume
= i
->soft_volume
;
1606 pa_sink_input_request_rewind(i
, 0, TRUE
, FALSE
, FALSE
);
1610 /* Called from IO thread, except when it is not */
1611 int pa_sink_process_msg(pa_msgobject
*o
, int code
, void *userdata
, int64_t offset
, pa_memchunk
*chunk
) {
1612 pa_sink
*s
= PA_SINK(o
);
1613 pa_sink_assert_ref(s
);
1615 switch ((pa_sink_message_t
) code
) {
1617 case PA_SINK_MESSAGE_ADD_INPUT
: {
1618 pa_sink_input
*i
= PA_SINK_INPUT(userdata
);
1620 /* If you change anything here, make sure to change the
1621 * sink input handling a few lines down at
1622 * PA_SINK_MESSAGE_FINISH_MOVE, too. */
1624 pa_hashmap_put(s
->thread_info
.inputs
, PA_UINT32_TO_PTR(i
->index
), pa_sink_input_ref(i
));
1626 /* Since the caller sleeps in pa_sink_input_put(), we can
1627 * safely access data outside of thread_info even though
1630 if ((i
->thread_info
.sync_prev
= i
->sync_prev
)) {
1631 pa_assert(i
->sink
== i
->thread_info
.sync_prev
->sink
);
1632 pa_assert(i
->sync_prev
->sync_next
== i
);
1633 i
->thread_info
.sync_prev
->thread_info
.sync_next
= i
;
1636 if ((i
->thread_info
.sync_next
= i
->sync_next
)) {
1637 pa_assert(i
->sink
== i
->thread_info
.sync_next
->sink
);
1638 pa_assert(i
->sync_next
->sync_prev
== i
);
1639 i
->thread_info
.sync_next
->thread_info
.sync_prev
= i
;
1642 pa_assert(!i
->thread_info
.attached
);
1643 i
->thread_info
.attached
= TRUE
;
1648 pa_sink_input_set_state_within_thread(i
, i
->state
);
1650 /* The requested latency of the sink input needs to be
1651 * fixed up and then configured on the sink */
1653 if (i
->thread_info
.requested_sink_latency
!= (pa_usec_t
) -1)
1654 pa_sink_input_set_requested_latency_within_thread(i
, i
->thread_info
.requested_sink_latency
);
1656 pa_sink_input_update_max_rewind(i
, s
->thread_info
.max_rewind
);
1657 pa_sink_input_update_max_request(i
, s
->thread_info
.max_request
);
1659 /* We don't rewind here automatically. This is left to the
1660 * sink input implementor because some sink inputs need a
1661 * slow start, i.e. need some time to buffer client
1662 * samples before beginning streaming. */
1664 /* In flat volume mode we need to update the volume as
1666 return o
->process_msg(o
, PA_SINK_MESSAGE_SET_VOLUME
, NULL
, 0, NULL
);
1669 case PA_SINK_MESSAGE_REMOVE_INPUT
: {
1670 pa_sink_input
*i
= PA_SINK_INPUT(userdata
);
1672 /* If you change anything here, make sure to change the
1673 * sink input handling a few lines down at
1674 * PA_SINK_MESSAGE_PREPAPRE_MOVE, too. */
1679 pa_sink_input_set_state_within_thread(i
, i
->state
);
1681 pa_assert(i
->thread_info
.attached
);
1682 i
->thread_info
.attached
= FALSE
;
1684 /* Since the caller sleeps in pa_sink_input_unlink(),
1685 * we can safely access data outside of thread_info even
1686 * though it is mutable */
1688 pa_assert(!i
->sync_prev
);
1689 pa_assert(!i
->sync_next
);
1691 if (i
->thread_info
.sync_prev
) {
1692 i
->thread_info
.sync_prev
->thread_info
.sync_next
= i
->thread_info
.sync_prev
->sync_next
;
1693 i
->thread_info
.sync_prev
= NULL
;
1696 if (i
->thread_info
.sync_next
) {
1697 i
->thread_info
.sync_next
->thread_info
.sync_prev
= i
->thread_info
.sync_next
->sync_prev
;
1698 i
->thread_info
.sync_next
= NULL
;
1701 if (pa_hashmap_remove(s
->thread_info
.inputs
, PA_UINT32_TO_PTR(i
->index
)))
1702 pa_sink_input_unref(i
);
1704 pa_sink_invalidate_requested_latency(s
);
1705 pa_sink_request_rewind(s
, (size_t) -1);
1707 /* In flat volume mode we need to update the volume as
1709 return o
->process_msg(o
, PA_SINK_MESSAGE_SET_VOLUME
, NULL
, 0, NULL
);
1712 case PA_SINK_MESSAGE_START_MOVE
: {
1713 pa_sink_input
*i
= PA_SINK_INPUT(userdata
);
1715 /* We don't support moving synchronized streams. */
1716 pa_assert(!i
->sync_prev
);
1717 pa_assert(!i
->sync_next
);
1718 pa_assert(!i
->thread_info
.sync_next
);
1719 pa_assert(!i
->thread_info
.sync_prev
);
1721 if (i
->thread_info
.state
!= PA_SINK_INPUT_CORKED
) {
1723 size_t sink_nbytes
, total_nbytes
;
1725 /* Get the latency of the sink */
1726 if (!(s
->flags
& PA_SINK_LATENCY
) ||
1727 PA_MSGOBJECT(s
)->process_msg(PA_MSGOBJECT(s
), PA_SINK_MESSAGE_GET_LATENCY
, &usec
, 0, NULL
) < 0)
1730 sink_nbytes
= pa_usec_to_bytes(usec
, &s
->sample_spec
);
1731 total_nbytes
= sink_nbytes
+ pa_memblockq_get_length(i
->thread_info
.render_memblockq
);
1733 if (total_nbytes
> 0) {
1734 i
->thread_info
.rewrite_nbytes
= i
->thread_info
.resampler
? pa_resampler_request(i
->thread_info
.resampler
, total_nbytes
) : total_nbytes
;
1735 i
->thread_info
.rewrite_flush
= TRUE
;
1736 pa_sink_input_process_rewind(i
, sink_nbytes
);
1743 pa_assert(i
->thread_info
.attached
);
1744 i
->thread_info
.attached
= FALSE
;
1746 /* Let's remove the sink input ...*/
1747 if (pa_hashmap_remove(s
->thread_info
.inputs
, PA_UINT32_TO_PTR(i
->index
)))
1748 pa_sink_input_unref(i
);
1750 pa_sink_invalidate_requested_latency(s
);
1752 pa_log_debug("Requesting rewind due to started move");
1753 pa_sink_request_rewind(s
, (size_t) -1);
1755 /* In flat volume mode we need to update the volume as
1757 return o
->process_msg(o
, PA_SINK_MESSAGE_SET_VOLUME
, NULL
, 0, NULL
);
1760 case PA_SINK_MESSAGE_FINISH_MOVE
: {
1761 pa_sink_input
*i
= PA_SINK_INPUT(userdata
);
1763 /* We don't support moving synchronized streams. */
1764 pa_assert(!i
->sync_prev
);
1765 pa_assert(!i
->sync_next
);
1766 pa_assert(!i
->thread_info
.sync_next
);
1767 pa_assert(!i
->thread_info
.sync_prev
);
1769 pa_hashmap_put(s
->thread_info
.inputs
, PA_UINT32_TO_PTR(i
->index
), pa_sink_input_ref(i
));
1771 pa_assert(!i
->thread_info
.attached
);
1772 i
->thread_info
.attached
= TRUE
;
1777 if (i
->thread_info
.requested_sink_latency
!= (pa_usec_t
) -1)
1778 pa_sink_input_set_requested_latency_within_thread(i
, i
->thread_info
.requested_sink_latency
);
1780 pa_sink_input_update_max_rewind(i
, s
->thread_info
.max_rewind
);
1781 pa_sink_input_update_max_request(i
, s
->thread_info
.max_request
);
1783 if (i
->thread_info
.state
!= PA_SINK_INPUT_CORKED
) {
1787 /* Get the latency of the sink */
1788 if (!(s
->flags
& PA_SINK_LATENCY
) ||
1789 PA_MSGOBJECT(s
)->process_msg(PA_MSGOBJECT(s
), PA_SINK_MESSAGE_GET_LATENCY
, &usec
, 0, NULL
) < 0)
1792 nbytes
= pa_usec_to_bytes(usec
, &s
->sample_spec
);
1795 pa_sink_input_drop(i
, nbytes
);
1797 pa_log_debug("Requesting rewind due to finished move");
1798 pa_sink_request_rewind(s
, nbytes
);
1801 /* In flat volume mode we need to update the volume as
1803 return o
->process_msg(o
, PA_SINK_MESSAGE_SET_VOLUME
, NULL
, 0, NULL
);
1806 case PA_SINK_MESSAGE_SET_VOLUME
:
1808 if (!pa_cvolume_equal(&s
->thread_info
.soft_volume
, &s
->soft_volume
)) {
1809 s
->thread_info
.soft_volume
= s
->soft_volume
;
1810 pa_sink_request_rewind(s
, (size_t) -1);
1813 if (!(s
->flags
& PA_SINK_FLAT_VOLUME
))
1816 /* Fall through ... */
1818 case PA_SINK_MESSAGE_SYNC_VOLUMES
:
1819 sync_input_volumes_within_thread(s
);
1822 case PA_SINK_MESSAGE_GET_VOLUME
:
1825 case PA_SINK_MESSAGE_SET_MUTE
:
1827 if (s
->thread_info
.soft_muted
!= s
->muted
) {
1828 s
->thread_info
.soft_muted
= s
->muted
;
1829 pa_sink_request_rewind(s
, (size_t) -1);
1834 case PA_SINK_MESSAGE_GET_MUTE
:
1837 case PA_SINK_MESSAGE_SET_STATE
: {
1839 pa_bool_t suspend_change
=
1840 (s
->thread_info
.state
== PA_SINK_SUSPENDED
&& PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata
))) ||
1841 (PA_SINK_IS_OPENED(s
->thread_info
.state
) && PA_PTR_TO_UINT(userdata
) == PA_SINK_SUSPENDED
);
1843 s
->thread_info
.state
= PA_PTR_TO_UINT(userdata
);
1845 if (s
->thread_info
.state
== PA_SINK_SUSPENDED
) {
1846 s
->thread_info
.rewind_nbytes
= 0;
1847 s
->thread_info
.rewind_requested
= FALSE
;
1850 if (suspend_change
) {
1854 while ((i
= pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
)))
1855 if (i
->suspend_within_thread
)
1856 i
->suspend_within_thread(i
, s
->thread_info
.state
== PA_SINK_SUSPENDED
);
1862 case PA_SINK_MESSAGE_DETACH
:
1864 /* Detach all streams */
1865 pa_sink_detach_within_thread(s
);
1868 case PA_SINK_MESSAGE_ATTACH
:
1870 /* Reattach all streams */
1871 pa_sink_attach_within_thread(s
);
1874 case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY
: {
1876 pa_usec_t
*usec
= userdata
;
1877 *usec
= pa_sink_get_requested_latency_within_thread(s
);
1879 if (*usec
== (pa_usec_t
) -1)
1880 *usec
= s
->thread_info
.max_latency
;
1885 case PA_SINK_MESSAGE_SET_LATENCY_RANGE
: {
1886 pa_usec_t
*r
= userdata
;
1888 pa_sink_set_latency_range_within_thread(s
, r
[0], r
[1]);
1893 case PA_SINK_MESSAGE_GET_LATENCY_RANGE
: {
1894 pa_usec_t
*r
= userdata
;
1896 r
[0] = s
->thread_info
.min_latency
;
1897 r
[1] = s
->thread_info
.max_latency
;
1902 case PA_SINK_MESSAGE_GET_MAX_REWIND
:
1904 *((size_t*) userdata
) = s
->thread_info
.max_rewind
;
1907 case PA_SINK_MESSAGE_GET_MAX_REQUEST
:
1909 *((size_t*) userdata
) = s
->thread_info
.max_request
;
1912 case PA_SINK_MESSAGE_SET_MAX_REWIND
:
1914 pa_sink_set_max_rewind_within_thread(s
, (size_t) offset
);
1917 case PA_SINK_MESSAGE_SET_MAX_REQUEST
:
1919 pa_sink_set_max_request_within_thread(s
, (size_t) offset
);
1922 case PA_SINK_MESSAGE_GET_LATENCY
:
1923 case PA_SINK_MESSAGE_MAX
:
1930 /* Called from main thread */
1931 int pa_sink_suspend_all(pa_core
*c
, pa_bool_t suspend
, pa_suspend_cause_t cause
) {
1936 pa_core_assert_ref(c
);
1937 pa_assert(cause
!= 0);
1939 for (sink
= PA_SINK(pa_idxset_first(c
->sinks
, &idx
)); sink
; sink
= PA_SINK(pa_idxset_next(c
->sinks
, &idx
))) {
1942 if ((r
= pa_sink_suspend(sink
, suspend
, cause
)) < 0)
1949 /* Called from main thread */
1950 void pa_sink_detach(pa_sink
*s
) {
1951 pa_sink_assert_ref(s
);
1952 pa_assert(PA_SINK_IS_LINKED(s
->state
));
1954 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_DETACH
, NULL
, 0, NULL
) == 0);
1957 /* Called from main thread */
1958 void pa_sink_attach(pa_sink
*s
) {
1959 pa_sink_assert_ref(s
);
1960 pa_assert(PA_SINK_IS_LINKED(s
->state
));
1962 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_ATTACH
, NULL
, 0, NULL
) == 0);
1965 /* Called from IO thread */
1966 void pa_sink_detach_within_thread(pa_sink
*s
) {
1970 pa_sink_assert_ref(s
);
1971 pa_assert(PA_SINK_IS_LINKED(s
->thread_info
.state
));
1973 while ((i
= pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
)))
1977 if (s
->monitor_source
)
1978 pa_source_detach_within_thread(s
->monitor_source
);
1981 /* Called from IO thread */
1982 void pa_sink_attach_within_thread(pa_sink
*s
) {
1986 pa_sink_assert_ref(s
);
1987 pa_assert(PA_SINK_IS_LINKED(s
->thread_info
.state
));
1989 while ((i
= pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
)))
1993 if (s
->monitor_source
)
1994 pa_source_attach_within_thread(s
->monitor_source
);
1997 /* Called from IO thread */
1998 void pa_sink_request_rewind(pa_sink
*s
, size_t nbytes
) {
1999 pa_sink_assert_ref(s
);
2000 pa_assert(PA_SINK_IS_LINKED(s
->thread_info
.state
));
2002 if (s
->thread_info
.state
== PA_SINK_SUSPENDED
)
2005 if (nbytes
== (size_t) -1)
2006 nbytes
= s
->thread_info
.max_rewind
;
2008 nbytes
= PA_MIN(nbytes
, s
->thread_info
.max_rewind
);
2010 if (s
->thread_info
.rewind_requested
&&
2011 nbytes
<= s
->thread_info
.rewind_nbytes
)
2014 s
->thread_info
.rewind_nbytes
= nbytes
;
2015 s
->thread_info
.rewind_requested
= TRUE
;
2017 if (s
->request_rewind
)
2018 s
->request_rewind(s
);
2021 /* Called from IO thread */
2022 pa_usec_t
pa_sink_get_requested_latency_within_thread(pa_sink
*s
) {
2023 pa_usec_t result
= (pa_usec_t
) -1;
2026 pa_usec_t monitor_latency
;
2028 pa_sink_assert_ref(s
);
2030 if (!(s
->flags
& PA_SINK_DYNAMIC_LATENCY
))
2031 return PA_CLAMP(s
->fixed_latency
, s
->thread_info
.min_latency
, s
->thread_info
.max_latency
);
2033 if (s
->thread_info
.requested_latency_valid
)
2034 return s
->thread_info
.requested_latency
;
2036 while ((i
= pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
)))
2038 if (i
->thread_info
.requested_sink_latency
!= (pa_usec_t
) -1 &&
2039 (result
== (pa_usec_t
) -1 || result
> i
->thread_info
.requested_sink_latency
))
2040 result
= i
->thread_info
.requested_sink_latency
;
2042 monitor_latency
= pa_source_get_requested_latency_within_thread(s
->monitor_source
);
2044 if (monitor_latency
!= (pa_usec_t
) -1 &&
2045 (result
== (pa_usec_t
) -1 || result
> monitor_latency
))
2046 result
= monitor_latency
;
2048 if (result
!= (pa_usec_t
) -1)
2049 result
= PA_CLAMP(result
, s
->thread_info
.min_latency
, s
->thread_info
.max_latency
);
2051 if (PA_SINK_IS_LINKED(s
->thread_info
.state
)) {
2052 /* Only cache if properly initialized */
2053 s
->thread_info
.requested_latency
= result
;
2054 s
->thread_info
.requested_latency_valid
= TRUE
;
2060 /* Called from main thread */
2061 pa_usec_t
pa_sink_get_requested_latency(pa_sink
*s
) {
2064 pa_sink_assert_ref(s
);
2065 pa_assert(PA_SINK_IS_LINKED(s
->state
));
2067 if (s
->state
== PA_SINK_SUSPENDED
)
2070 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY
, &usec
, 0, NULL
) == 0);
2074 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2075 void pa_sink_set_max_rewind_within_thread(pa_sink
*s
, size_t max_rewind
) {
2079 pa_sink_assert_ref(s
);
2081 if (max_rewind
== s
->thread_info
.max_rewind
)
2084 s
->thread_info
.max_rewind
= max_rewind
;
2086 if (PA_SINK_IS_LINKED(s
->thread_info
.state
)) {
2087 while ((i
= pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
)))
2088 pa_sink_input_update_max_rewind(i
, s
->thread_info
.max_rewind
);
2091 if (s
->monitor_source
)
2092 pa_source_set_max_rewind_within_thread(s
->monitor_source
, s
->thread_info
.max_rewind
);
2095 /* Called from main thread */
2096 void pa_sink_set_max_rewind(pa_sink
*s
, size_t max_rewind
) {
2097 pa_sink_assert_ref(s
);
2099 if (PA_SINK_IS_LINKED(s
->state
))
2100 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_SET_MAX_REWIND
, NULL
, max_rewind
, NULL
) == 0);
2102 pa_sink_set_max_rewind_within_thread(s
, max_rewind
);
2105 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2106 void pa_sink_set_max_request_within_thread(pa_sink
*s
, size_t max_request
) {
2109 pa_sink_assert_ref(s
);
2111 if (max_request
== s
->thread_info
.max_request
)
2114 s
->thread_info
.max_request
= max_request
;
2116 if (PA_SINK_IS_LINKED(s
->thread_info
.state
)) {
2119 while ((i
= pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
)))
2120 pa_sink_input_update_max_request(i
, s
->thread_info
.max_request
);
2124 /* Called from main thread */
2125 void pa_sink_set_max_request(pa_sink
*s
, size_t max_request
) {
2126 pa_sink_assert_ref(s
);
2128 if (PA_SINK_IS_LINKED(s
->state
))
2129 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_SET_MAX_REQUEST
, NULL
, max_request
, NULL
) == 0);
2131 pa_sink_set_max_request_within_thread(s
, max_request
);
2134 /* Called from IO thread */
2135 void pa_sink_invalidate_requested_latency(pa_sink
*s
) {
2139 pa_sink_assert_ref(s
);
2141 if (!(s
->flags
& PA_SINK_DYNAMIC_LATENCY
))
2144 s
->thread_info
.requested_latency_valid
= FALSE
;
2146 if (PA_SINK_IS_LINKED(s
->thread_info
.state
)) {
2148 if (s
->update_requested_latency
)
2149 s
->update_requested_latency(s
);
2151 while ((i
= pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
)))
2152 if (i
->update_sink_requested_latency
)
2153 i
->update_sink_requested_latency(i
);
2157 /* Called from main thread */
2158 void pa_sink_set_latency_range(pa_sink
*s
, pa_usec_t min_latency
, pa_usec_t max_latency
) {
2159 pa_sink_assert_ref(s
);
2161 /* min_latency == 0: no limit
2162 * min_latency anything else: specified limit
2164 * Similar for max_latency */
2166 if (min_latency
< ABSOLUTE_MIN_LATENCY
)
2167 min_latency
= ABSOLUTE_MIN_LATENCY
;
2169 if (max_latency
<= 0 ||
2170 max_latency
> ABSOLUTE_MAX_LATENCY
)
2171 max_latency
= ABSOLUTE_MAX_LATENCY
;
2173 pa_assert(min_latency
<= max_latency
);
2175 /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2176 pa_assert((min_latency
== ABSOLUTE_MIN_LATENCY
&&
2177 max_latency
== ABSOLUTE_MAX_LATENCY
) ||
2178 (s
->flags
& PA_SINK_DYNAMIC_LATENCY
));
2180 if (PA_SINK_IS_LINKED(s
->state
)) {
2186 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_SET_LATENCY_RANGE
, r
, 0, NULL
) == 0);
2188 pa_sink_set_latency_range_within_thread(s
, min_latency
, max_latency
);
2191 /* Called from main thread */
2192 void pa_sink_get_latency_range(pa_sink
*s
, pa_usec_t
*min_latency
, pa_usec_t
*max_latency
) {
2193 pa_sink_assert_ref(s
);
2194 pa_assert(min_latency
);
2195 pa_assert(max_latency
);
2197 if (PA_SINK_IS_LINKED(s
->state
)) {
2198 pa_usec_t r
[2] = { 0, 0 };
2200 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_GET_LATENCY_RANGE
, r
, 0, NULL
) == 0);
2202 *min_latency
= r
[0];
2203 *max_latency
= r
[1];
2205 *min_latency
= s
->thread_info
.min_latency
;
2206 *max_latency
= s
->thread_info
.max_latency
;
2210 /* Called from IO thread */
2211 void pa_sink_set_latency_range_within_thread(pa_sink
*s
, pa_usec_t min_latency
, pa_usec_t max_latency
) {
2214 pa_sink_assert_ref(s
);
2216 pa_assert(min_latency
>= ABSOLUTE_MIN_LATENCY
);
2217 pa_assert(max_latency
<= ABSOLUTE_MAX_LATENCY
);
2218 pa_assert(min_latency
<= max_latency
);
2220 /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2221 pa_assert((min_latency
== ABSOLUTE_MIN_LATENCY
&&
2222 max_latency
== ABSOLUTE_MAX_LATENCY
) ||
2223 (s
->flags
& PA_SINK_DYNAMIC_LATENCY
));
2225 s
->thread_info
.min_latency
= min_latency
;
2226 s
->thread_info
.max_latency
= max_latency
;
2228 if (PA_SINK_IS_LINKED(s
->thread_info
.state
)) {
2231 while ((i
= pa_hashmap_iterate(s
->thread_info
.inputs
, &state
, NULL
)))
2232 if (i
->update_sink_latency_range
)
2233 i
->update_sink_latency_range(i
);
2236 pa_sink_invalidate_requested_latency(s
);
2238 pa_source_set_latency_range_within_thread(s
->monitor_source
, min_latency
, max_latency
);
2241 /* Called from main thread, before the sink is put */
2242 void pa_sink_set_fixed_latency(pa_sink
*s
, pa_usec_t latency
) {
2243 pa_sink_assert_ref(s
);
2245 pa_assert(pa_sink_get_state(s
) == PA_SINK_INIT
);
2247 if (latency
< ABSOLUTE_MIN_LATENCY
)
2248 latency
= ABSOLUTE_MIN_LATENCY
;
2250 if (latency
> ABSOLUTE_MAX_LATENCY
)
2251 latency
= ABSOLUTE_MAX_LATENCY
;
2253 s
->fixed_latency
= latency
;
2254 pa_source_set_fixed_latency(s
->monitor_source
, latency
);
2257 /* Called from main context */
2258 size_t pa_sink_get_max_rewind(pa_sink
*s
) {
2260 pa_sink_assert_ref(s
);
2262 if (!PA_SINK_IS_LINKED(s
->state
))
2263 return s
->thread_info
.max_rewind
;
2265 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_GET_MAX_REWIND
, &r
, 0, NULL
) == 0);
2270 /* Called from main context */
2271 size_t pa_sink_get_max_request(pa_sink
*s
) {
2273 pa_sink_assert_ref(s
);
2275 if (!PA_SINK_IS_LINKED(s
->state
))
2276 return s
->thread_info
.max_request
;
2278 pa_assert_se(pa_asyncmsgq_send(s
->asyncmsgq
, PA_MSGOBJECT(s
), PA_SINK_MESSAGE_GET_MAX_REQUEST
, &r
, 0, NULL
) == 0);
2283 /* Called from main context */
2284 int pa_sink_set_port(pa_sink
*s
, const char *name
, pa_bool_t save
) {
2285 pa_device_port
*port
;
2290 pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s
->index
, s
->name
);
2291 return -PA_ERR_NOTIMPLEMENTED
;
2295 return -PA_ERR_NOENTITY
;
2297 if (!(port
= pa_hashmap_get(s
->ports
, name
)))
2298 return -PA_ERR_NOENTITY
;
2300 if (s
->active_port
== port
) {
2301 s
->save_port
= s
->save_port
|| save
;
2305 if ((s
->set_port(s
, port
)) < 0)
2306 return -PA_ERR_NOENTITY
;
2308 pa_subscription_post(s
->core
, PA_SUBSCRIPTION_EVENT_SINK
|PA_SUBSCRIPTION_EVENT_CHANGE
, s
->index
);
2310 pa_log_info("Changed port of sink %u \"%s\" to %s", s
->index
, s
->name
, port
->name
);
2312 s
->active_port
= port
;
2313 s
->save_port
= save
;
2318 /* Called from main context */
2319 pa_bool_t
pa_device_init_icon(pa_proplist
*p
, pa_bool_t is_sink
) {
2320 const char *ff
, *c
, *t
= NULL
, *s
= "", *profile
, *bus
;
2324 if (pa_proplist_contains(p
, PA_PROP_DEVICE_ICON_NAME
))
2327 if ((ff
= pa_proplist_gets(p
, PA_PROP_DEVICE_FORM_FACTOR
))) {
2329 if (pa_streq(ff
, "microphone"))
2330 t
= "audio-input-microphone";
2331 else if (pa_streq(ff
, "webcam"))
2333 else if (pa_streq(ff
, "computer"))
2335 else if (pa_streq(ff
, "handset"))
2337 else if (pa_streq(ff
, "portable"))
2338 t
= "multimedia-player";
2339 else if (pa_streq(ff
, "tv"))
2340 t
= "video-display";
2343 * The following icons are not part of the icon naming spec,
2344 * because Rodney Dawes sucks as the maintainer of that spec.
2346 * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
2348 else if (pa_streq(ff
, "headset"))
2349 t
= "audio-headset";
2350 else if (pa_streq(ff
, "headphone"))
2351 t
= "audio-headphones";
2352 else if (pa_streq(ff
, "speaker"))
2353 t
= "audio-speakers";
2354 else if (pa_streq(ff
, "hands-free"))
2355 t
= "audio-handsfree";
2359 if ((c
= pa_proplist_gets(p
, PA_PROP_DEVICE_CLASS
)))
2360 if (pa_streq(c
, "modem"))
2367 t
= "audio-input-microphone";
2370 if ((profile
= pa_proplist_gets(p
, PA_PROP_DEVICE_PROFILE_NAME
))) {
2371 if (strstr(profile
, "analog"))
2373 else if (strstr(profile
, "iec958"))
2375 else if (strstr(profile
, "hdmi"))
2379 bus
= pa_proplist_gets(p
, PA_PROP_DEVICE_BUS
);
2381 pa_proplist_setf(p
, PA_PROP_DEVICE_ICON_NAME
, "%s%s%s%s", t
, pa_strempty(s
), bus
? "-" : "", pa_strempty(bus
));
2386 pa_bool_t
pa_device_init_description(pa_proplist
*p
) {
2387 const char *s
, *d
= NULL
, *k
;
2390 if (pa_proplist_contains(p
, PA_PROP_DEVICE_DESCRIPTION
))
2393 if ((s
= pa_proplist_gets(p
, PA_PROP_DEVICE_FORM_FACTOR
)))
2394 if (pa_streq(s
, "internal"))
2395 d
= _("Internal Audio");
2398 if ((s
= pa_proplist_gets(p
, PA_PROP_DEVICE_CLASS
)))
2399 if (pa_streq(s
, "modem"))
2403 d
= pa_proplist_gets(p
, PA_PROP_DEVICE_PRODUCT_NAME
);
2408 k
= pa_proplist_gets(p
, PA_PROP_DEVICE_PROFILE_DESCRIPTION
);
2411 pa_proplist_setf(p
, PA_PROP_DEVICE_DESCRIPTION
, _("%s %s"), d
, k
);
2413 pa_proplist_sets(p
, PA_PROP_DEVICE_DESCRIPTION
, d
);
2418 pa_bool_t
pa_device_init_intended_roles(pa_proplist
*p
) {
2422 if (pa_proplist_contains(p
, PA_PROP_DEVICE_INTENDED_ROLES
))
2425 if ((s
= pa_proplist_gets(p
, PA_PROP_DEVICE_FORM_FACTOR
)))
2426 if (pa_streq(s
, "handset") || pa_streq(s
, "hands-free")) {
2427 pa_proplist_sets(p
, PA_PROP_DEVICE_INTENDED_ROLES
, "phone");