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/util.h>
33 #include <pulse/internal.h>
35 #include <pulsecore/core-format.h>
36 #include <pulsecore/mix.h>
37 #include <pulsecore/stream-util.h>
38 #include <pulsecore/core-subscribe.h>
39 #include <pulsecore/log.h>
40 #include <pulsecore/play-memblockq.h>
41 #include <pulsecore/namereg.h>
42 #include <pulsecore/core-util.h>
44 #include "sink-input.h"
46 /* #define SINK_INPUT_DEBUG */
48 #define MEMBLOCKQ_MAXLENGTH (32*1024*1024)
49 #define CONVERT_BUFFER_LENGTH (PA_PAGE_SIZE)
51 PA_DEFINE_PUBLIC_CLASS(pa_sink_input
, pa_msgobject
);
53 struct volume_factor_entry
{
58 static struct volume_factor_entry
*volume_factor_entry_new(const char *key
, const pa_cvolume
*volume
) {
59 struct volume_factor_entry
*entry
;
64 entry
= pa_xnew(struct volume_factor_entry
, 1);
65 entry
->key
= pa_xstrdup(key
);
67 entry
->volume
= *volume
;
72 static void volume_factor_entry_free(struct volume_factor_entry
*volume_entry
) {
73 pa_assert(volume_entry
);
75 pa_xfree(volume_entry
->key
);
76 pa_xfree(volume_entry
);
79 static void volume_factor_from_hashmap(pa_cvolume
*v
, pa_hashmap
*items
, uint8_t channels
) {
80 struct volume_factor_entry
*entry
;
83 pa_cvolume_reset(v
, channels
);
84 PA_HASHMAP_FOREACH(entry
, items
, state
)
85 pa_sw_cvolume_multiply(v
, v
, &entry
->volume
);
88 static void sink_input_free(pa_object
*o
);
89 static void set_real_ratio(pa_sink_input
*i
, const pa_cvolume
*v
);
91 static int check_passthrough_connection(bool passthrough
, pa_sink
*dest
) {
92 if (pa_sink_is_passthrough(dest
)) {
93 pa_log_warn("Sink is already connected to PASSTHROUGH input");
97 /* If current input(s) exist, check new input is not PASSTHROUGH */
98 if (pa_idxset_size(dest
->inputs
) > 0 && passthrough
) {
99 pa_log_warn("Sink is already connected, cannot accept new PASSTHROUGH INPUT");
106 pa_sink_input_new_data
* pa_sink_input_new_data_init(pa_sink_input_new_data
*data
) {
110 data
->resample_method
= PA_RESAMPLER_INVALID
;
111 data
->proplist
= pa_proplist_new();
112 data
->volume_writable
= true;
114 data
->volume_factor_items
= pa_hashmap_new_full(pa_idxset_string_hash_func
, pa_idxset_string_compare_func
, NULL
,
115 (pa_free_cb_t
) volume_factor_entry_free
);
116 data
->volume_factor_sink_items
= pa_hashmap_new_full(pa_idxset_string_hash_func
, pa_idxset_string_compare_func
, NULL
,
117 (pa_free_cb_t
) volume_factor_entry_free
);
122 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data
*data
, const pa_sample_spec
*spec
) {
125 if ((data
->sample_spec_is_set
= !!spec
))
126 data
->sample_spec
= *spec
;
129 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data
*data
, const pa_channel_map
*map
) {
132 if ((data
->channel_map_is_set
= !!map
))
133 data
->channel_map
= *map
;
136 bool pa_sink_input_new_data_is_passthrough(pa_sink_input_new_data
*data
) {
139 if (PA_LIKELY(data
->format
) && PA_UNLIKELY(!pa_format_info_is_pcm(data
->format
)))
142 if (PA_UNLIKELY(data
->flags
& PA_SINK_INPUT_PASSTHROUGH
))
148 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data
*data
, const pa_cvolume
*volume
) {
150 pa_assert(data
->volume_writable
);
152 if ((data
->volume_is_set
= !!volume
))
153 data
->volume
= *volume
;
156 void pa_sink_input_new_data_add_volume_factor(pa_sink_input_new_data
*data
, const char *key
, const pa_cvolume
*volume_factor
) {
157 struct volume_factor_entry
*v
;
161 pa_assert(volume_factor
);
163 v
= volume_factor_entry_new(key
, volume_factor
);
164 pa_assert_se(pa_hashmap_put(data
->volume_factor_items
, v
->key
, v
) >= 0);
167 void pa_sink_input_new_data_add_volume_factor_sink(pa_sink_input_new_data
*data
, const char *key
, const pa_cvolume
*volume_factor
) {
168 struct volume_factor_entry
*v
;
172 pa_assert(volume_factor
);
174 v
= volume_factor_entry_new(key
, volume_factor
);
175 pa_assert_se(pa_hashmap_put(data
->volume_factor_sink_items
, v
->key
, v
) >= 0);
178 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data
*data
, bool mute
) {
181 data
->muted_is_set
= true;
182 data
->muted
= !!mute
;
185 bool pa_sink_input_new_data_set_sink(pa_sink_input_new_data
*data
, pa_sink
*s
, bool save
) {
187 pa_idxset
*formats
= NULL
;
192 if (!data
->req_formats
) {
193 /* We're not working with the extended API */
195 data
->save_sink
= save
;
197 /* Extended API: let's see if this sink supports the formats the client can provide */
198 formats
= pa_sink_check_formats(s
, data
->req_formats
);
200 if (formats
&& !pa_idxset_isempty(formats
)) {
201 /* Sink supports at least one of the requested formats */
203 data
->save_sink
= save
;
204 if (data
->nego_formats
)
205 pa_idxset_free(data
->nego_formats
, (pa_free_cb_t
) pa_format_info_free
);
206 data
->nego_formats
= formats
;
208 /* Sink doesn't support any of the formats requested by the client */
210 pa_idxset_free(formats
, (pa_free_cb_t
) pa_format_info_free
);
218 bool pa_sink_input_new_data_set_formats(pa_sink_input_new_data
*data
, pa_idxset
*formats
) {
222 if (data
->req_formats
)
223 pa_idxset_free(data
->req_formats
, (pa_free_cb_t
) pa_format_info_free
);
225 data
->req_formats
= formats
;
228 /* Trigger format negotiation */
229 return pa_sink_input_new_data_set_sink(data
, data
->sink
, data
->save_sink
);
235 void pa_sink_input_new_data_done(pa_sink_input_new_data
*data
) {
238 if (data
->req_formats
)
239 pa_idxset_free(data
->req_formats
, (pa_free_cb_t
) pa_format_info_free
);
241 if (data
->nego_formats
)
242 pa_idxset_free(data
->nego_formats
, (pa_free_cb_t
) pa_format_info_free
);
245 pa_format_info_free(data
->format
);
247 if (data
->volume_factor_items
)
248 pa_hashmap_free(data
->volume_factor_items
);
250 if (data
->volume_factor_sink_items
)
251 pa_hashmap_free(data
->volume_factor_sink_items
);
253 pa_proplist_free(data
->proplist
);
256 /* Called from main context */
257 static void reset_callbacks(pa_sink_input
*i
) {
261 i
->process_underrun
= NULL
;
262 i
->process_rewind
= NULL
;
263 i
->update_max_rewind
= NULL
;
264 i
->update_max_request
= NULL
;
265 i
->update_sink_requested_latency
= NULL
;
266 i
->update_sink_latency_range
= NULL
;
267 i
->update_sink_fixed_latency
= NULL
;
271 i
->suspend_within_thread
= NULL
;
274 i
->get_latency
= NULL
;
275 i
->state_change
= NULL
;
276 i
->may_move_to
= NULL
;
277 i
->send_event
= NULL
;
278 i
->volume_changed
= NULL
;
279 i
->mute_changed
= NULL
;
282 /* Called from main context */
283 int pa_sink_input_new(
286 pa_sink_input_new_data
*data
) {
289 pa_resampler
*resampler
= NULL
;
290 char st
[PA_SAMPLE_SPEC_SNPRINT_MAX
], cm
[PA_CHANNEL_MAP_SNPRINT_MAX
], fmt
[PA_FORMAT_INFO_SNPRINT_MAX
];
291 pa_channel_map volume_map
;
294 char *memblockq_name
;
299 pa_assert_ctl_context();
302 pa_proplist_update(data
->proplist
, PA_UPDATE_MERGE
, data
->client
->proplist
);
304 if (data
->origin_sink
&& (data
->origin_sink
->flags
& PA_SINK_SHARE_VOLUME_WITH_MASTER
))
305 data
->volume_writable
= false;
307 if (!data
->req_formats
) {
308 /* From this point on, we want to work only with formats, and get back
309 * to using the sample spec and channel map after all decisions w.r.t.
310 * routing are complete. */
314 f
= pa_format_info_from_sample_spec2(&data
->sample_spec
, data
->channel_map_is_set
? &data
->channel_map
: NULL
,
315 !(data
->flags
& PA_SINK_INPUT_FIX_FORMAT
),
316 !(data
->flags
& PA_SINK_INPUT_FIX_RATE
),
317 !(data
->flags
& PA_SINK_INPUT_FIX_CHANNELS
));
319 return -PA_ERR_INVALID
;
321 formats
= pa_idxset_new(NULL
, NULL
);
322 pa_idxset_put(formats
, f
, NULL
);
323 pa_sink_input_new_data_set_formats(data
, formats
);
326 if ((r
= pa_hook_fire(&core
->hooks
[PA_CORE_HOOK_SINK_INPUT_NEW
], data
)) < 0)
329 pa_return_val_if_fail(!data
->driver
|| pa_utf8_valid(data
->driver
), -PA_ERR_INVALID
);
332 pa_sink
*sink
= pa_namereg_get(core
, NULL
, PA_NAMEREG_SINK
);
333 pa_return_val_if_fail(sink
, -PA_ERR_NOENTITY
);
334 pa_sink_input_new_data_set_sink(data
, sink
, false);
337 /* If something didn't pick a format for us, pick the top-most format since
338 * we assume this is sorted in priority order */
339 if (!data
->format
&& data
->nego_formats
&& !pa_idxset_isempty(data
->nego_formats
))
340 data
->format
= pa_format_info_copy(pa_idxset_first(data
->nego_formats
, NULL
));
342 if (PA_LIKELY(data
->format
)) {
343 pa_log_debug("Negotiated format: %s", pa_format_info_snprint(fmt
, sizeof(fmt
), data
->format
));
345 pa_format_info
*format
;
348 pa_log_info("Sink does not support any requested format:");
349 PA_IDXSET_FOREACH(format
, data
->req_formats
, idx
)
350 pa_log_info(" -- %s", pa_format_info_snprint(fmt
, sizeof(fmt
), format
));
352 return -PA_ERR_NOTSUPPORTED
;
355 pa_return_val_if_fail(PA_SINK_IS_LINKED(pa_sink_get_state(data
->sink
)), -PA_ERR_BADSTATE
);
356 pa_return_val_if_fail(!data
->sync_base
|| (data
->sync_base
->sink
== data
->sink
357 && pa_sink_input_get_state(data
->sync_base
) == PA_SINK_INPUT_CORKED
),
360 /* Routing is done. We have a sink and a format. */
362 if (data
->volume_is_set
&& pa_format_info_is_pcm(data
->format
)) {
363 /* If volume is set, we need to save the original data->channel_map,
364 * so that we can remap the volume from the original channel map to the
365 * final channel map of the stream in case data->channel_map gets
366 * modified in pa_format_info_to_sample_spec2(). */
367 r
= pa_stream_get_volume_channel_map(&data
->volume
, data
->channel_map_is_set
? &data
->channel_map
: NULL
, data
->format
, &volume_map
);
372 /* Now populate the sample spec and channel map according to the final
373 * format that we've negotiated */
374 r
= pa_format_info_to_sample_spec2(data
->format
, &data
->sample_spec
, &data
->channel_map
, &data
->sink
->sample_spec
,
375 &data
->sink
->channel_map
);
379 r
= check_passthrough_connection(pa_sink_input_new_data_is_passthrough(data
), data
->sink
);
383 /* Don't restore (or save) stream volume for passthrough streams and
384 * prevent attenuation/gain */
385 if (pa_sink_input_new_data_is_passthrough(data
)) {
386 data
->volume_is_set
= true;
387 pa_cvolume_reset(&data
->volume
, data
->sample_spec
.channels
);
388 data
->volume_is_absolute
= true;
389 data
->save_volume
= false;
392 if (!data
->volume_is_set
) {
393 pa_cvolume_reset(&data
->volume
, data
->sample_spec
.channels
);
394 data
->volume_is_absolute
= false;
395 data
->save_volume
= false;
398 if (!data
->volume_writable
)
399 data
->save_volume
= false;
401 if (data
->volume_is_set
)
402 /* The original volume channel map may be different than the final
403 * stream channel map, so remapping may be needed. */
404 pa_cvolume_remap(&data
->volume
, &volume_map
, &data
->channel_map
);
406 if (!data
->muted_is_set
)
409 if (!(data
->flags
& PA_SINK_INPUT_VARIABLE_RATE
) &&
410 !pa_sample_spec_equal(&data
->sample_spec
, &data
->sink
->sample_spec
)) {
411 /* try to change sink rate. This is done before the FIXATE hook since
412 module-suspend-on-idle can resume a sink */
414 pa_log_info("Trying to change sample rate");
415 if (pa_sink_update_rate(data
->sink
, data
->sample_spec
.rate
, pa_sink_input_new_data_is_passthrough(data
)) >= 0)
416 pa_log_info("Rate changed to %u Hz", data
->sink
->sample_spec
.rate
);
419 if (pa_sink_input_new_data_is_passthrough(data
) &&
420 !pa_sample_spec_equal(&data
->sample_spec
, &data
->sink
->sample_spec
)) {
421 /* rate update failed, or other parts of sample spec didn't match */
423 pa_log_debug("Could not update sink sample spec to match passthrough stream");
424 return -PA_ERR_NOTSUPPORTED
;
427 if (data
->resample_method
== PA_RESAMPLER_INVALID
)
428 data
->resample_method
= core
->resample_method
;
430 pa_return_val_if_fail(data
->resample_method
< PA_RESAMPLER_MAX
, -PA_ERR_INVALID
);
432 if ((r
= pa_hook_fire(&core
->hooks
[PA_CORE_HOOK_SINK_INPUT_FIXATE
], data
)) < 0)
435 if ((data
->flags
& PA_SINK_INPUT_NO_CREATE_ON_SUSPEND
) &&
436 pa_sink_get_state(data
->sink
) == PA_SINK_SUSPENDED
) {
437 pa_log_warn("Failed to create sink input: sink is suspended.");
438 return -PA_ERR_BADSTATE
;
441 if (pa_idxset_size(data
->sink
->inputs
) >= PA_MAX_INPUTS_PER_SINK
) {
442 pa_log_warn("Failed to create sink input: too many inputs per sink.");
443 return -PA_ERR_TOOLARGE
;
446 if ((data
->flags
& PA_SINK_INPUT_VARIABLE_RATE
) ||
447 !pa_sample_spec_equal(&data
->sample_spec
, &data
->sink
->sample_spec
) ||
448 !pa_channel_map_equal(&data
->channel_map
, &data
->sink
->channel_map
)) {
450 /* Note: for passthrough content we need to adjust the output rate to that of the current sink-input */
451 if (!pa_sink_input_new_data_is_passthrough(data
)) /* no resampler for passthrough content */
452 if (!(resampler
= pa_resampler_new(
454 &data
->sample_spec
, &data
->channel_map
,
455 &data
->sink
->sample_spec
, &data
->sink
->channel_map
,
456 data
->resample_method
,
457 ((data
->flags
& PA_SINK_INPUT_VARIABLE_RATE
) ? PA_RESAMPLER_VARIABLE_RATE
: 0) |
458 ((data
->flags
& PA_SINK_INPUT_NO_REMAP
) ? PA_RESAMPLER_NO_REMAP
: 0) |
459 (core
->disable_remixing
|| (data
->flags
& PA_SINK_INPUT_NO_REMIX
) ? PA_RESAMPLER_NO_REMIX
: 0) |
460 (core
->disable_lfe_remixing
? PA_RESAMPLER_NO_LFE
: 0)))) {
461 pa_log_warn("Unsupported resampling operation.");
462 return -PA_ERR_NOTSUPPORTED
;
466 i
= pa_msgobject_new(pa_sink_input
);
467 i
->parent
.parent
.free
= sink_input_free
;
468 i
->parent
.process_msg
= pa_sink_input_process_msg
;
471 i
->state
= PA_SINK_INPUT_INIT
;
472 i
->flags
= data
->flags
;
473 i
->proplist
= pa_proplist_copy(data
->proplist
);
474 i
->driver
= pa_xstrdup(pa_path_get_filename(data
->driver
));
475 i
->module
= data
->module
;
476 i
->sink
= data
->sink
;
477 i
->origin_sink
= data
->origin_sink
;
478 i
->client
= data
->client
;
480 i
->requested_resample_method
= data
->resample_method
;
481 i
->actual_resample_method
= resampler
? pa_resampler_get_method(resampler
) : PA_RESAMPLER_INVALID
;
482 i
->sample_spec
= data
->sample_spec
;
483 i
->channel_map
= data
->channel_map
;
484 i
->format
= pa_format_info_copy(data
->format
);
486 if (!data
->volume_is_absolute
&& pa_sink_flat_volume_enabled(i
->sink
)) {
489 /* When the 'absolute' bool is not set then we'll treat the volume
490 * as relative to the sink volume even in flat volume mode */
491 remapped
= data
->sink
->reference_volume
;
492 pa_cvolume_remap(&remapped
, &data
->sink
->channel_map
, &data
->channel_map
);
493 pa_sw_cvolume_multiply(&i
->volume
, &data
->volume
, &remapped
);
495 i
->volume
= data
->volume
;
497 i
->volume_factor_items
= data
->volume_factor_items
;
498 data
->volume_factor_items
= NULL
;
499 volume_factor_from_hashmap(&i
->volume_factor
, i
->volume_factor_items
, i
->sample_spec
.channels
);
501 i
->volume_factor_sink_items
= data
->volume_factor_sink_items
;
502 data
->volume_factor_sink_items
= NULL
;
503 volume_factor_from_hashmap(&i
->volume_factor_sink
, i
->volume_factor_sink_items
, i
->sink
->sample_spec
.channels
);
505 i
->real_ratio
= i
->reference_ratio
= data
->volume
;
506 pa_cvolume_reset(&i
->soft_volume
, i
->sample_spec
.channels
);
507 pa_cvolume_reset(&i
->real_ratio
, i
->sample_spec
.channels
);
508 i
->volume_writable
= data
->volume_writable
;
509 i
->save_volume
= data
->save_volume
;
510 i
->save_sink
= data
->save_sink
;
511 i
->save_muted
= data
->save_muted
;
513 i
->muted
= data
->muted
;
515 if (data
->sync_base
) {
516 i
->sync_next
= data
->sync_base
->sync_next
;
517 i
->sync_prev
= data
->sync_base
;
519 if (data
->sync_base
->sync_next
)
520 data
->sync_base
->sync_next
->sync_prev
= i
;
521 data
->sync_base
->sync_next
= i
;
523 i
->sync_next
= i
->sync_prev
= NULL
;
525 i
->direct_outputs
= pa_idxset_new(NULL
, NULL
);
530 i
->thread_info
.state
= i
->state
;
531 i
->thread_info
.attached
= false;
532 pa_atomic_store(&i
->thread_info
.drained
, 1);
533 i
->thread_info
.sample_spec
= i
->sample_spec
;
534 i
->thread_info
.resampler
= resampler
;
535 i
->thread_info
.soft_volume
= i
->soft_volume
;
536 i
->thread_info
.muted
= i
->muted
;
537 i
->thread_info
.requested_sink_latency
= (pa_usec_t
) -1;
538 i
->thread_info
.rewrite_nbytes
= 0;
539 i
->thread_info
.rewrite_flush
= false;
540 i
->thread_info
.dont_rewind_render
= false;
541 i
->thread_info
.underrun_for
= (uint64_t) -1;
542 i
->thread_info
.underrun_for_sink
= 0;
543 i
->thread_info
.playing_for
= 0;
544 i
->thread_info
.direct_outputs
= pa_hashmap_new(pa_idxset_trivial_hash_func
, pa_idxset_trivial_compare_func
);
546 pa_assert_se(pa_idxset_put(core
->sink_inputs
, i
, &i
->index
) == 0);
547 pa_assert_se(pa_idxset_put(i
->sink
->inputs
, pa_sink_input_ref(i
), NULL
) == 0);
550 pa_assert_se(pa_idxset_put(i
->client
->sink_inputs
, i
, NULL
) >= 0);
552 memblockq_name
= pa_sprintf_malloc("sink input render_memblockq [%u]", i
->index
);
553 i
->thread_info
.render_memblockq
= pa_memblockq_new(
558 &i
->sink
->sample_spec
,
563 pa_xfree(memblockq_name
);
565 pt
= pa_proplist_to_string_sep(i
->proplist
, "\n ");
566 pa_log_info("Created input %u \"%s\" on %s with sample spec %s and channel map %s\n %s",
568 pa_strnull(pa_proplist_gets(i
->proplist
, PA_PROP_MEDIA_NAME
)),
570 pa_sample_spec_snprint(st
, sizeof(st
), &i
->sample_spec
),
571 pa_channel_map_snprint(cm
, sizeof(cm
), &i
->channel_map
),
575 /* Don't forget to call pa_sink_input_put! */
581 /* Called from main context */
582 static void update_n_corked(pa_sink_input
*i
, pa_sink_input_state_t state
) {
584 pa_assert_ctl_context();
589 if (i
->state
== PA_SINK_INPUT_CORKED
&& state
!= PA_SINK_INPUT_CORKED
)
590 pa_assert_se(i
->sink
->n_corked
-- >= 1);
591 else if (i
->state
!= PA_SINK_INPUT_CORKED
&& state
== PA_SINK_INPUT_CORKED
)
595 /* Called from main context */
596 static void sink_input_set_state(pa_sink_input
*i
, pa_sink_input_state_t state
) {
597 pa_sink_input
*ssync
;
599 pa_assert_ctl_context();
601 if (state
== PA_SINK_INPUT_DRAINED
)
602 state
= PA_SINK_INPUT_RUNNING
;
604 if (i
->state
== state
)
607 if (i
->state
== PA_SINK_INPUT_CORKED
&& state
== PA_SINK_INPUT_RUNNING
&& pa_sink_used_by(i
->sink
) == 0 &&
608 !pa_sample_spec_equal(&i
->sample_spec
, &i
->sink
->sample_spec
)) {
609 /* We were uncorked and the sink was not playing anything -- let's try
610 * to update the sample rate to avoid resampling */
611 pa_sink_update_rate(i
->sink
, i
->sample_spec
.rate
, pa_sink_input_is_passthrough(i
));
614 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_SET_STATE
, PA_UINT_TO_PTR(state
), 0, NULL
) == 0);
616 update_n_corked(i
, state
);
619 for (ssync
= i
->sync_prev
; ssync
; ssync
= ssync
->sync_prev
) {
620 update_n_corked(ssync
, state
);
621 ssync
->state
= state
;
623 for (ssync
= i
->sync_next
; ssync
; ssync
= ssync
->sync_next
) {
624 update_n_corked(ssync
, state
);
625 ssync
->state
= state
;
628 if (state
!= PA_SINK_INPUT_UNLINKED
) {
629 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED
], i
);
631 for (ssync
= i
->sync_prev
; ssync
; ssync
= ssync
->sync_prev
)
632 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED
], ssync
);
634 for (ssync
= i
->sync_next
; ssync
; ssync
= ssync
->sync_next
)
635 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED
], ssync
);
637 if (PA_SINK_INPUT_IS_LINKED(state
))
638 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
641 pa_sink_update_status(i
->sink
);
644 /* Called from main context */
645 void pa_sink_input_unlink(pa_sink_input
*i
) {
647 pa_source_output
*o
, *p
= NULL
;
650 pa_assert_ctl_context();
652 /* See pa_sink_unlink() for a couple of comments how this function
655 pa_sink_input_ref(i
);
657 linked
= PA_SINK_INPUT_IS_LINKED(i
->state
);
660 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_UNLINK
], i
);
663 i
->sync_prev
->sync_next
= i
->sync_next
;
665 i
->sync_next
->sync_prev
= i
->sync_prev
;
667 i
->sync_prev
= i
->sync_next
= NULL
;
669 pa_idxset_remove_by_data(i
->core
->sink_inputs
, i
, NULL
);
672 if (pa_idxset_remove_by_data(i
->sink
->inputs
, i
, NULL
))
673 pa_sink_input_unref(i
);
676 pa_idxset_remove_by_data(i
->client
->sink_inputs
, i
, NULL
);
678 while ((o
= pa_idxset_first(i
->direct_outputs
, NULL
))) {
680 pa_source_output_kill(o
);
684 update_n_corked(i
, PA_SINK_INPUT_UNLINKED
);
685 i
->state
= PA_SINK_INPUT_UNLINKED
;
687 if (linked
&& i
->sink
) {
688 if (pa_sink_input_is_passthrough(i
))
689 pa_sink_leave_passthrough(i
->sink
);
691 /* We might need to update the sink's volume if we are in flat volume mode. */
692 if (pa_sink_flat_volume_enabled(i
->sink
))
693 pa_sink_set_volume(i
->sink
, NULL
, false, false);
695 if (i
->sink
->asyncmsgq
)
696 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
->sink
), PA_SINK_MESSAGE_REMOVE_INPUT
, i
, 0, NULL
) == 0);
702 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_REMOVE
, i
->index
);
703 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST
], i
);
707 if (PA_SINK_IS_LINKED(pa_sink_get_state(i
->sink
)))
708 pa_sink_update_status(i
->sink
);
713 pa_core_maybe_vacuum(i
->core
);
715 pa_sink_input_unref(i
);
718 /* Called from main context */
719 static void sink_input_free(pa_object
*o
) {
720 pa_sink_input
* i
= PA_SINK_INPUT(o
);
723 pa_assert_ctl_context();
724 pa_assert(pa_sink_input_refcnt(i
) == 0);
726 if (PA_SINK_INPUT_IS_LINKED(i
->state
))
727 pa_sink_input_unlink(i
);
729 pa_log_info("Freeing input %u \"%s\"", i
->index
,
730 i
->proplist
? pa_strnull(pa_proplist_gets(i
->proplist
, PA_PROP_MEDIA_NAME
)) : "");
732 /* Side note: this function must be able to destruct properly any
733 * kind of sink input in any state, even those which are
734 * "half-moved" or are connected to sinks that have no asyncmsgq
735 * and are hence half-destructed themselves! */
737 if (i
->thread_info
.render_memblockq
)
738 pa_memblockq_free(i
->thread_info
.render_memblockq
);
740 if (i
->thread_info
.resampler
)
741 pa_resampler_free(i
->thread_info
.resampler
);
744 pa_format_info_free(i
->format
);
747 pa_proplist_free(i
->proplist
);
749 if (i
->direct_outputs
)
750 pa_idxset_free(i
->direct_outputs
, NULL
);
752 if (i
->thread_info
.direct_outputs
)
753 pa_hashmap_free(i
->thread_info
.direct_outputs
);
755 if (i
->volume_factor_items
)
756 pa_hashmap_free(i
->volume_factor_items
);
758 if (i
->volume_factor_sink_items
)
759 pa_hashmap_free(i
->volume_factor_sink_items
);
765 /* Called from main context */
766 void pa_sink_input_put(pa_sink_input
*i
) {
767 pa_sink_input_state_t state
;
769 pa_sink_input_assert_ref(i
);
770 pa_assert_ctl_context();
772 pa_assert(i
->state
== PA_SINK_INPUT_INIT
);
774 /* The following fields must be initialized properly */
776 pa_assert(i
->process_rewind
);
779 state
= i
->flags
& PA_SINK_INPUT_START_CORKED
? PA_SINK_INPUT_CORKED
: PA_SINK_INPUT_RUNNING
;
781 update_n_corked(i
, state
);
784 /* We might need to update the sink's volume if we are in flat volume mode. */
785 if (pa_sink_flat_volume_enabled(i
->sink
))
786 pa_sink_set_volume(i
->sink
, NULL
, false, i
->save_volume
);
788 if (i
->origin_sink
&& (i
->origin_sink
->flags
& PA_SINK_SHARE_VOLUME_WITH_MASTER
)) {
789 pa_assert(pa_cvolume_is_norm(&i
->volume
));
790 pa_assert(pa_cvolume_is_norm(&i
->reference_ratio
));
793 set_real_ratio(i
, &i
->volume
);
796 if (pa_sink_input_is_passthrough(i
))
797 pa_sink_enter_passthrough(i
->sink
);
799 i
->thread_info
.soft_volume
= i
->soft_volume
;
800 i
->thread_info
.muted
= i
->muted
;
802 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
->sink
), PA_SINK_MESSAGE_ADD_INPUT
, i
, 0, NULL
) == 0);
804 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_NEW
, i
->index
);
805 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_PUT
], i
);
807 pa_sink_update_status(i
->sink
);
810 /* Called from main context */
811 void pa_sink_input_kill(pa_sink_input
*i
) {
812 pa_sink_input_assert_ref(i
);
813 pa_assert_ctl_context();
814 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
819 /* Called from main context */
820 pa_usec_t
pa_sink_input_get_latency(pa_sink_input
*i
, pa_usec_t
*sink_latency
) {
821 pa_usec_t r
[2] = { 0, 0 };
823 pa_sink_input_assert_ref(i
);
824 pa_assert_ctl_context();
825 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
827 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_GET_LATENCY
, r
, 0, NULL
) == 0);
830 r
[0] += i
->get_latency(i
);
833 *sink_latency
= r
[1];
838 /* Called from thread context */
839 void pa_sink_input_peek(pa_sink_input
*i
, size_t slength
/* in sink bytes */, pa_memchunk
*chunk
, pa_cvolume
*volume
) {
840 bool do_volume_adj_here
, need_volume_factor_sink
;
842 size_t block_size_max_sink
, block_size_max_sink_input
;
846 pa_sink_input_assert_ref(i
);
847 pa_sink_input_assert_io_context(i
);
848 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
));
849 pa_assert(pa_frame_aligned(slength
, &i
->sink
->sample_spec
));
853 #ifdef SINK_INPUT_DEBUG
854 pa_log_debug("peek");
857 block_size_max_sink_input
= i
->thread_info
.resampler
?
858 pa_resampler_max_block_size(i
->thread_info
.resampler
) :
859 pa_frame_align(pa_mempool_block_size_max(i
->core
->mempool
), &i
->sample_spec
);
861 block_size_max_sink
= pa_frame_align(pa_mempool_block_size_max(i
->core
->mempool
), &i
->sink
->sample_spec
);
863 /* Default buffer size */
865 slength
= pa_frame_align(CONVERT_BUFFER_LENGTH
, &i
->sink
->sample_spec
);
867 if (slength
> block_size_max_sink
)
868 slength
= block_size_max_sink
;
870 if (i
->thread_info
.resampler
) {
871 ilength
= pa_resampler_request(i
->thread_info
.resampler
, slength
);
874 ilength
= pa_frame_align(CONVERT_BUFFER_LENGTH
, &i
->sample_spec
);
878 /* Length corresponding to slength (without limiting to
879 * block_size_max_sink_input). */
880 ilength_full
= ilength
;
882 if (ilength
> block_size_max_sink_input
)
883 ilength
= block_size_max_sink_input
;
885 /* If the channel maps of the sink and this stream differ, we need
886 * to adjust the volume *before* we resample. Otherwise we can do
887 * it after and leave it for the sink code */
889 do_volume_adj_here
= !pa_channel_map_equal(&i
->channel_map
, &i
->sink
->channel_map
);
890 volume_is_norm
= pa_cvolume_is_norm(&i
->thread_info
.soft_volume
) && !i
->thread_info
.muted
;
891 need_volume_factor_sink
= !pa_cvolume_is_norm(&i
->volume_factor_sink
);
893 while (!pa_memblockq_is_readable(i
->thread_info
.render_memblockq
)) {
896 /* There's nothing in our render queue. We need to fill it up
897 * with data from the implementor. */
899 if (i
->thread_info
.state
== PA_SINK_INPUT_CORKED
||
900 i
->pop(i
, ilength
, &tchunk
) < 0) {
902 /* OK, we're corked or the implementor didn't give us any
903 * data, so let's just hand out silence */
904 pa_atomic_store(&i
->thread_info
.drained
, 1);
906 pa_memblockq_seek(i
->thread_info
.render_memblockq
, (int64_t) slength
, PA_SEEK_RELATIVE
, true);
907 i
->thread_info
.playing_for
= 0;
908 if (i
->thread_info
.underrun_for
!= (uint64_t) -1) {
909 i
->thread_info
.underrun_for
+= ilength_full
;
910 i
->thread_info
.underrun_for_sink
+= slength
;
915 pa_atomic_store(&i
->thread_info
.drained
, 0);
917 pa_assert(tchunk
.length
> 0);
918 pa_assert(tchunk
.memblock
);
920 i
->thread_info
.underrun_for
= 0;
921 i
->thread_info
.underrun_for_sink
= 0;
922 i
->thread_info
.playing_for
+= tchunk
.length
;
924 while (tchunk
.length
> 0) {
926 bool nvfs
= need_volume_factor_sink
;
929 pa_memblock_ref(wchunk
.memblock
);
931 if (wchunk
.length
> block_size_max_sink_input
)
932 wchunk
.length
= block_size_max_sink_input
;
934 /* It might be necessary to adjust the volume here */
935 if (do_volume_adj_here
&& !volume_is_norm
) {
936 pa_memchunk_make_writable(&wchunk
, 0);
938 if (i
->thread_info
.muted
) {
939 pa_silence_memchunk(&wchunk
, &i
->thread_info
.sample_spec
);
942 } else if (!i
->thread_info
.resampler
&& nvfs
) {
945 /* If we don't need a resampler we can merge the
946 * post and the pre volume adjustment into one */
948 pa_sw_cvolume_multiply(&v
, &i
->thread_info
.soft_volume
, &i
->volume_factor_sink
);
949 pa_volume_memchunk(&wchunk
, &i
->thread_info
.sample_spec
, &v
);
953 pa_volume_memchunk(&wchunk
, &i
->thread_info
.sample_spec
, &i
->thread_info
.soft_volume
);
956 if (!i
->thread_info
.resampler
) {
959 pa_memchunk_make_writable(&wchunk
, 0);
960 pa_volume_memchunk(&wchunk
, &i
->sink
->sample_spec
, &i
->volume_factor_sink
);
963 pa_memblockq_push_align(i
->thread_info
.render_memblockq
, &wchunk
);
966 pa_resampler_run(i
->thread_info
.resampler
, &wchunk
, &rchunk
);
968 #ifdef SINK_INPUT_DEBUG
969 pa_log_debug("pushing %lu", (unsigned long) rchunk
.length
);
972 if (rchunk
.memblock
) {
975 pa_memchunk_make_writable(&rchunk
, 0);
976 pa_volume_memchunk(&rchunk
, &i
->sink
->sample_spec
, &i
->volume_factor_sink
);
979 pa_memblockq_push_align(i
->thread_info
.render_memblockq
, &rchunk
);
980 pa_memblock_unref(rchunk
.memblock
);
984 pa_memblock_unref(wchunk
.memblock
);
986 tchunk
.index
+= wchunk
.length
;
987 tchunk
.length
-= wchunk
.length
;
990 pa_memblock_unref(tchunk
.memblock
);
993 pa_assert_se(pa_memblockq_peek(i
->thread_info
.render_memblockq
, chunk
) >= 0);
995 pa_assert(chunk
->length
> 0);
996 pa_assert(chunk
->memblock
);
998 #ifdef SINK_INPUT_DEBUG
999 pa_log_debug("peeking %lu", (unsigned long) chunk
->length
);
1002 if (chunk
->length
> block_size_max_sink
)
1003 chunk
->length
= block_size_max_sink
;
1005 /* Let's see if we had to apply the volume adjustment ourselves,
1006 * or if this can be done by the sink for us */
1008 if (do_volume_adj_here
)
1009 /* We had different channel maps, so we already did the adjustment */
1010 pa_cvolume_reset(volume
, i
->sink
->sample_spec
.channels
);
1011 else if (i
->thread_info
.muted
)
1012 /* We've both the same channel map, so let's have the sink do the adjustment for us*/
1013 pa_cvolume_mute(volume
, i
->sink
->sample_spec
.channels
);
1015 *volume
= i
->thread_info
.soft_volume
;
1018 /* Called from thread context */
1019 void pa_sink_input_drop(pa_sink_input
*i
, size_t nbytes
/* in sink sample spec */) {
1021 pa_sink_input_assert_ref(i
);
1022 pa_sink_input_assert_io_context(i
);
1023 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
));
1024 pa_assert(pa_frame_aligned(nbytes
, &i
->sink
->sample_spec
));
1025 pa_assert(nbytes
> 0);
1027 #ifdef SINK_INPUT_DEBUG
1028 pa_log_debug("dropping %lu", (unsigned long) nbytes
);
1031 pa_memblockq_drop(i
->thread_info
.render_memblockq
, nbytes
);
1034 /* Called from thread context */
1035 bool pa_sink_input_process_underrun(pa_sink_input
*i
) {
1036 pa_sink_input_assert_ref(i
);
1037 pa_sink_input_assert_io_context(i
);
1039 if (pa_memblockq_is_readable(i
->thread_info
.render_memblockq
))
1042 if (i
->process_underrun
&& i
->process_underrun(i
)) {
1043 /* All valid data has been played back, so we can empty this queue. */
1044 pa_memblockq_silence(i
->thread_info
.render_memblockq
);
1050 /* Called from thread context */
1051 void pa_sink_input_process_rewind(pa_sink_input
*i
, size_t nbytes
/* in sink sample spec */) {
1053 bool called
= false;
1055 pa_sink_input_assert_ref(i
);
1056 pa_sink_input_assert_io_context(i
);
1057 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
));
1058 pa_assert(pa_frame_aligned(nbytes
, &i
->sink
->sample_spec
));
1060 #ifdef SINK_INPUT_DEBUG
1061 pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes
, (unsigned long) i
->thread_info
.rewrite_nbytes
);
1064 lbq
= pa_memblockq_get_length(i
->thread_info
.render_memblockq
);
1066 if (nbytes
> 0 && !i
->thread_info
.dont_rewind_render
) {
1067 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes
);
1068 pa_memblockq_rewind(i
->thread_info
.render_memblockq
, nbytes
);
1071 if (i
->thread_info
.rewrite_nbytes
== (size_t) -1) {
1073 /* We were asked to drop all buffered data, and rerequest new
1074 * data from implementor the next time peek() is called */
1076 pa_memblockq_flush_write(i
->thread_info
.render_memblockq
, true);
1078 } else if (i
->thread_info
.rewrite_nbytes
> 0) {
1079 size_t max_rewrite
, amount
;
1081 /* Calculate how much make sense to rewrite at most */
1082 max_rewrite
= nbytes
+ lbq
;
1084 /* Transform into local domain */
1085 if (i
->thread_info
.resampler
)
1086 max_rewrite
= pa_resampler_request(i
->thread_info
.resampler
, max_rewrite
);
1088 /* Calculate how much of the rewinded data should actually be rewritten */
1089 amount
= PA_MIN(i
->thread_info
.rewrite_nbytes
, max_rewrite
);
1092 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount
);
1094 /* Tell the implementor */
1095 if (i
->process_rewind
)
1096 i
->process_rewind(i
, amount
);
1099 /* Convert back to to sink domain */
1100 if (i
->thread_info
.resampler
)
1101 amount
= pa_resampler_result(i
->thread_info
.resampler
, amount
);
1104 /* Ok, now update the write pointer */
1105 pa_memblockq_seek(i
->thread_info
.render_memblockq
, - ((int64_t) amount
), PA_SEEK_RELATIVE
, true);
1107 if (i
->thread_info
.rewrite_flush
)
1108 pa_memblockq_silence(i
->thread_info
.render_memblockq
);
1110 /* And reset the resampler */
1111 if (i
->thread_info
.resampler
)
1112 pa_resampler_reset(i
->thread_info
.resampler
);
1117 if (i
->process_rewind
)
1118 i
->process_rewind(i
, 0);
1120 i
->thread_info
.rewrite_nbytes
= 0;
1121 i
->thread_info
.rewrite_flush
= false;
1122 i
->thread_info
.dont_rewind_render
= false;
1125 /* Called from thread context */
1126 size_t pa_sink_input_get_max_rewind(pa_sink_input
*i
) {
1127 pa_sink_input_assert_ref(i
);
1128 pa_sink_input_assert_io_context(i
);
1130 return i
->thread_info
.resampler
? pa_resampler_request(i
->thread_info
.resampler
, i
->sink
->thread_info
.max_rewind
) : i
->sink
->thread_info
.max_rewind
;
1133 /* Called from thread context */
1134 size_t pa_sink_input_get_max_request(pa_sink_input
*i
) {
1135 pa_sink_input_assert_ref(i
);
1136 pa_sink_input_assert_io_context(i
);
1138 /* We're not verifying the status here, to allow this to be called
1139 * in the state change handler between _INIT and _RUNNING */
1141 return i
->thread_info
.resampler
? pa_resampler_request(i
->thread_info
.resampler
, i
->sink
->thread_info
.max_request
) : i
->sink
->thread_info
.max_request
;
1144 /* Called from thread context */
1145 void pa_sink_input_update_max_rewind(pa_sink_input
*i
, size_t nbytes
/* in the sink's sample spec */) {
1146 pa_sink_input_assert_ref(i
);
1147 pa_sink_input_assert_io_context(i
);
1148 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
));
1149 pa_assert(pa_frame_aligned(nbytes
, &i
->sink
->sample_spec
));
1151 pa_memblockq_set_maxrewind(i
->thread_info
.render_memblockq
, nbytes
);
1153 if (i
->update_max_rewind
)
1154 i
->update_max_rewind(i
, i
->thread_info
.resampler
? pa_resampler_request(i
->thread_info
.resampler
, nbytes
) : nbytes
);
1157 /* Called from thread context */
1158 void pa_sink_input_update_max_request(pa_sink_input
*i
, size_t nbytes
/* in the sink's sample spec */) {
1159 pa_sink_input_assert_ref(i
);
1160 pa_sink_input_assert_io_context(i
);
1161 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
));
1162 pa_assert(pa_frame_aligned(nbytes
, &i
->sink
->sample_spec
));
1164 if (i
->update_max_request
)
1165 i
->update_max_request(i
, i
->thread_info
.resampler
? pa_resampler_request(i
->thread_info
.resampler
, nbytes
) : nbytes
);
1168 /* Called from thread context */
1169 pa_usec_t
pa_sink_input_set_requested_latency_within_thread(pa_sink_input
*i
, pa_usec_t usec
) {
1170 pa_sink_input_assert_ref(i
);
1171 pa_sink_input_assert_io_context(i
);
1173 if (!(i
->sink
->flags
& PA_SINK_DYNAMIC_LATENCY
))
1174 usec
= i
->sink
->thread_info
.fixed_latency
;
1176 if (usec
!= (pa_usec_t
) -1)
1177 usec
= PA_CLAMP(usec
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
1179 i
->thread_info
.requested_sink_latency
= usec
;
1180 pa_sink_invalidate_requested_latency(i
->sink
, true);
1185 /* Called from main context */
1186 pa_usec_t
pa_sink_input_set_requested_latency(pa_sink_input
*i
, pa_usec_t usec
) {
1187 pa_sink_input_assert_ref(i
);
1188 pa_assert_ctl_context();
1190 if (PA_SINK_INPUT_IS_LINKED(i
->state
) && i
->sink
) {
1191 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY
, &usec
, 0, NULL
) == 0);
1195 /* If this sink input is not realized yet or we are being moved,
1196 * we have to touch the thread info data directly */
1199 if (!(i
->sink
->flags
& PA_SINK_DYNAMIC_LATENCY
))
1200 usec
= pa_sink_get_fixed_latency(i
->sink
);
1202 if (usec
!= (pa_usec_t
) -1) {
1203 pa_usec_t min_latency
, max_latency
;
1204 pa_sink_get_latency_range(i
->sink
, &min_latency
, &max_latency
);
1205 usec
= PA_CLAMP(usec
, min_latency
, max_latency
);
1209 i
->thread_info
.requested_sink_latency
= usec
;
1214 /* Called from main context */
1215 pa_usec_t
pa_sink_input_get_requested_latency(pa_sink_input
*i
) {
1216 pa_sink_input_assert_ref(i
);
1217 pa_assert_ctl_context();
1219 if (PA_SINK_INPUT_IS_LINKED(i
->state
) && i
->sink
) {
1221 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY
, &usec
, 0, NULL
) == 0);
1225 /* If this sink input is not realized yet or we are being moved,
1226 * we have to touch the thread info data directly */
1228 return i
->thread_info
.requested_sink_latency
;
1231 /* Called from main context */
1232 void pa_sink_input_set_volume(pa_sink_input
*i
, const pa_cvolume
*volume
, bool save
, bool absolute
) {
1235 pa_sink_input_assert_ref(i
);
1236 pa_assert_ctl_context();
1237 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1239 pa_assert(pa_cvolume_valid(volume
));
1240 pa_assert(volume
->channels
== 1 || pa_cvolume_compatible(volume
, &i
->sample_spec
));
1241 pa_assert(i
->volume_writable
);
1243 if (!absolute
&& pa_sink_flat_volume_enabled(i
->sink
)) {
1244 v
= i
->sink
->reference_volume
;
1245 pa_cvolume_remap(&v
, &i
->sink
->channel_map
, &i
->channel_map
);
1247 if (pa_cvolume_compatible(volume
, &i
->sample_spec
))
1248 volume
= pa_sw_cvolume_multiply(&v
, &v
, volume
);
1250 volume
= pa_sw_cvolume_multiply_scalar(&v
, &v
, pa_cvolume_max(volume
));
1252 if (!pa_cvolume_compatible(volume
, &i
->sample_spec
)) {
1254 volume
= pa_cvolume_scale(&v
, pa_cvolume_max(volume
));
1258 if (pa_cvolume_equal(volume
, &i
->volume
)) {
1259 i
->save_volume
= i
->save_volume
|| save
;
1263 i
->volume
= *volume
;
1264 i
->save_volume
= save
;
1266 if (pa_sink_flat_volume_enabled(i
->sink
)) {
1267 /* We are in flat volume mode, so let's update all sink input
1268 * volumes and update the flat volume of the sink */
1270 pa_sink_set_volume(i
->sink
, NULL
, true, save
);
1273 /* OK, we are in normal volume mode. The volume only affects
1275 set_real_ratio(i
, volume
);
1276 i
->reference_ratio
= i
->volume
;
1278 /* Copy the new soft_volume to the thread_info struct */
1279 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME
, NULL
, 0, NULL
) == 0);
1282 /* The volume changed, let's tell people so */
1283 if (i
->volume_changed
)
1284 i
->volume_changed(i
);
1286 /* The virtual volume changed, let's tell people so */
1287 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1290 void pa_sink_input_add_volume_factor(pa_sink_input
*i
, const char *key
, const pa_cvolume
*volume_factor
) {
1291 struct volume_factor_entry
*v
;
1293 pa_sink_input_assert_ref(i
);
1294 pa_assert_ctl_context();
1295 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1296 pa_assert(volume_factor
);
1298 pa_assert(pa_cvolume_valid(volume_factor
));
1299 pa_assert(volume_factor
->channels
== 1 || pa_cvolume_compatible(volume_factor
, &i
->sample_spec
));
1301 v
= volume_factor_entry_new(key
, volume_factor
);
1302 if (!pa_cvolume_compatible(volume_factor
, &i
->sample_spec
))
1303 pa_cvolume_set(&v
->volume
, i
->sample_spec
.channels
, volume_factor
->values
[0]);
1305 pa_assert_se(pa_hashmap_put(i
->volume_factor_items
, v
->key
, v
) >= 0);
1306 if (pa_hashmap_size(i
->volume_factor_items
) == 1)
1307 i
->volume_factor
= v
->volume
;
1309 pa_sw_cvolume_multiply(&i
->volume_factor
, &i
->volume_factor
, &v
->volume
);
1311 pa_sw_cvolume_multiply(&i
->soft_volume
, &i
->real_ratio
, &i
->volume_factor
);
1313 /* Copy the new soft_volume to the thread_info struct */
1314 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME
, NULL
, 0, NULL
) == 0);
1317 /* Returns 0 if an entry was removed and -1 if no entry for the given key was
1319 int pa_sink_input_remove_volume_factor(pa_sink_input
*i
, const char *key
) {
1320 struct volume_factor_entry
*v
;
1322 pa_sink_input_assert_ref(i
);
1324 pa_assert_ctl_context();
1325 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1327 v
= pa_hashmap_remove(i
->volume_factor_items
, key
);
1332 volume_factor_entry_free(v
);
1334 switch (pa_hashmap_size(i
->volume_factor_items
)) {
1336 pa_cvolume_reset(&i
->volume_factor
, i
->sample_spec
.channels
);
1339 v
= pa_hashmap_first(i
->volume_factor_items
);
1340 i
->volume_factor
= v
->volume
;
1343 volume_factor_from_hashmap(&i
->volume_factor
, i
->volume_factor_items
, i
->volume_factor
.channels
);
1346 pa_sw_cvolume_multiply(&i
->soft_volume
, &i
->real_ratio
, &i
->volume_factor
);
1348 /* Copy the new soft_volume to the thread_info struct */
1349 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME
, NULL
, 0, NULL
) == 0);
1354 /* Called from main context */
1355 static void set_real_ratio(pa_sink_input
*i
, const pa_cvolume
*v
) {
1356 pa_sink_input_assert_ref(i
);
1357 pa_assert_ctl_context();
1358 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1359 pa_assert(!v
|| pa_cvolume_compatible(v
, &i
->sample_spec
));
1361 /* This basically calculates:
1363 * i->real_ratio := v
1364 * i->soft_volume := i->real_ratio * i->volume_factor */
1369 pa_cvolume_reset(&i
->real_ratio
, i
->sample_spec
.channels
);
1371 pa_sw_cvolume_multiply(&i
->soft_volume
, &i
->real_ratio
, &i
->volume_factor
);
1372 /* We don't copy the data to the thread_info data. That's left for someone else to do */
1375 /* Called from main or I/O context */
1376 bool pa_sink_input_is_passthrough(pa_sink_input
*i
) {
1377 pa_sink_input_assert_ref(i
);
1379 if (PA_UNLIKELY(!pa_format_info_is_pcm(i
->format
)))
1382 if (PA_UNLIKELY(i
->flags
& PA_SINK_INPUT_PASSTHROUGH
))
1388 /* Called from main context */
1389 bool pa_sink_input_is_volume_readable(pa_sink_input
*i
) {
1390 pa_sink_input_assert_ref(i
);
1391 pa_assert_ctl_context();
1393 return !pa_sink_input_is_passthrough(i
);
1396 /* Called from main context */
1397 pa_cvolume
*pa_sink_input_get_volume(pa_sink_input
*i
, pa_cvolume
*volume
, bool absolute
) {
1398 pa_sink_input_assert_ref(i
);
1399 pa_assert_ctl_context();
1400 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1401 pa_assert(pa_sink_input_is_volume_readable(i
));
1403 if (absolute
|| !pa_sink_flat_volume_enabled(i
->sink
))
1404 *volume
= i
->volume
;
1406 *volume
= i
->reference_ratio
;
1411 /* Called from main context */
1412 void pa_sink_input_set_mute(pa_sink_input
*i
, bool mute
, bool save
) {
1413 pa_sink_input_assert_ref(i
);
1414 pa_assert_ctl_context();
1415 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1417 if (!i
->muted
== !mute
) {
1418 i
->save_muted
= i
->save_muted
|| mute
;
1423 i
->save_muted
= save
;
1425 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE
, NULL
, 0, NULL
) == 0);
1427 /* The mute status changed, let's tell people so */
1428 if (i
->mute_changed
)
1431 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1434 /* Called from main context */
1435 bool pa_sink_input_get_mute(pa_sink_input
*i
) {
1436 pa_sink_input_assert_ref(i
);
1437 pa_assert_ctl_context();
1438 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1443 /* Called from main thread */
1444 void pa_sink_input_update_proplist(pa_sink_input
*i
, pa_update_mode_t mode
, pa_proplist
*p
) {
1445 pa_sink_input_assert_ref(i
);
1446 pa_assert_ctl_context();
1449 pa_proplist_update(i
->proplist
, mode
, p
);
1451 if (PA_SINK_INPUT_IS_LINKED(i
->state
)) {
1452 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED
], i
);
1453 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1457 /* Called from main context */
1458 void pa_sink_input_cork(pa_sink_input
*i
, bool b
) {
1459 pa_sink_input_assert_ref(i
);
1460 pa_assert_ctl_context();
1461 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1463 sink_input_set_state(i
, b
? PA_SINK_INPUT_CORKED
: PA_SINK_INPUT_RUNNING
);
1466 /* Called from main context */
1467 int pa_sink_input_set_rate(pa_sink_input
*i
, uint32_t rate
) {
1468 pa_sink_input_assert_ref(i
);
1469 pa_assert_ctl_context();
1470 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1471 pa_return_val_if_fail(i
->thread_info
.resampler
, -PA_ERR_BADSTATE
);
1473 if (i
->sample_spec
.rate
== rate
)
1476 i
->sample_spec
.rate
= rate
;
1478 pa_asyncmsgq_post(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_SET_RATE
, PA_UINT_TO_PTR(rate
), 0, NULL
, NULL
);
1480 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1484 /* Called from main context */
1485 void pa_sink_input_set_name(pa_sink_input
*i
, const char *name
) {
1487 pa_sink_input_assert_ref(i
);
1488 pa_assert_ctl_context();
1490 if (!name
&& !pa_proplist_contains(i
->proplist
, PA_PROP_MEDIA_NAME
))
1493 old
= pa_proplist_gets(i
->proplist
, PA_PROP_MEDIA_NAME
);
1495 if (old
&& name
&& pa_streq(old
, name
))
1499 pa_proplist_sets(i
->proplist
, PA_PROP_MEDIA_NAME
, name
);
1501 pa_proplist_unset(i
->proplist
, PA_PROP_MEDIA_NAME
);
1503 if (PA_SINK_INPUT_IS_LINKED(i
->state
)) {
1504 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED
], i
);
1505 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1509 /* Called from main context */
1510 pa_resample_method_t
pa_sink_input_get_resample_method(pa_sink_input
*i
) {
1511 pa_sink_input_assert_ref(i
);
1512 pa_assert_ctl_context();
1514 return i
->actual_resample_method
;
1517 /* Called from main context */
1518 bool pa_sink_input_may_move(pa_sink_input
*i
) {
1519 pa_sink_input_assert_ref(i
);
1520 pa_assert_ctl_context();
1521 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1523 if (i
->flags
& PA_SINK_INPUT_DONT_MOVE
)
1526 if (i
->sync_next
|| i
->sync_prev
) {
1527 pa_log_warn("Moving synchronized streams not supported.");
1534 static bool find_filter_sink_input(pa_sink_input
*target
, pa_sink
*s
) {
1536 while (s
&& s
->input_to_master
) {
1537 if (s
->input_to_master
== target
)
1539 s
= s
->input_to_master
->sink
;
1540 pa_assert(i
++ < 100);
1545 /* Called from main context */
1546 bool pa_sink_input_may_move_to(pa_sink_input
*i
, pa_sink
*dest
) {
1547 pa_sink_input_assert_ref(i
);
1548 pa_assert_ctl_context();
1549 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1550 pa_sink_assert_ref(dest
);
1552 if (dest
== i
->sink
)
1555 if (!pa_sink_input_may_move(i
))
1558 /* Make sure we're not creating a filter sink cycle */
1559 if (find_filter_sink_input(i
, dest
)) {
1560 pa_log_debug("Can't connect input to %s, as that would create a cycle.", dest
->name
);
1564 if (pa_idxset_size(dest
->inputs
) >= PA_MAX_INPUTS_PER_SINK
) {
1565 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1569 if (check_passthrough_connection(pa_sink_input_is_passthrough(i
), dest
) < 0)
1573 if (!i
->may_move_to(i
, dest
))
1579 /* Called from main context */
1580 int pa_sink_input_start_move(pa_sink_input
*i
) {
1581 pa_source_output
*o
, *p
= NULL
;
1582 struct volume_factor_entry
*v
;
1586 pa_sink_input_assert_ref(i
);
1587 pa_assert_ctl_context();
1588 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1591 if (!pa_sink_input_may_move(i
))
1592 return -PA_ERR_NOTSUPPORTED
;
1594 if ((r
= pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_MOVE_START
], i
)) < 0)
1597 /* Kill directly connected outputs */
1598 while ((o
= pa_idxset_first(i
->direct_outputs
, NULL
))) {
1600 pa_source_output_kill(o
);
1603 pa_assert(pa_idxset_isempty(i
->direct_outputs
));
1605 pa_idxset_remove_by_data(i
->sink
->inputs
, i
, NULL
);
1607 if (pa_sink_input_get_state(i
) == PA_SINK_INPUT_CORKED
)
1608 pa_assert_se(i
->sink
->n_corked
-- >= 1);
1610 if (pa_sink_input_is_passthrough(i
))
1611 pa_sink_leave_passthrough(i
->sink
);
1613 if (pa_sink_flat_volume_enabled(i
->sink
))
1614 /* We might need to update the sink's volume if we are in flat
1616 pa_sink_set_volume(i
->sink
, NULL
, false, false);
1618 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
->sink
), PA_SINK_MESSAGE_START_MOVE
, i
, 0, NULL
) == 0);
1620 pa_sink_update_status(i
->sink
);
1622 PA_HASHMAP_FOREACH(v
, i
->volume_factor_sink_items
, state
)
1623 pa_cvolume_remap(&v
->volume
, &i
->sink
->channel_map
, &i
->channel_map
);
1625 pa_cvolume_remap(&i
->volume_factor_sink
, &i
->sink
->channel_map
, &i
->channel_map
);
1629 pa_sink_input_unref(i
);
1634 /* Called from main context. If i has an origin sink that uses volume sharing,
1635 * then also the origin sink and all streams connected to it need to update
1636 * their volume - this function does all that by using recursion. */
1637 static void update_volume_due_to_moving(pa_sink_input
*i
, pa_sink
*dest
) {
1638 pa_cvolume old_volume
;
1642 pa_assert(i
->sink
); /* The destination sink should already be set. */
1644 if (i
->origin_sink
&& (i
->origin_sink
->flags
& PA_SINK_SHARE_VOLUME_WITH_MASTER
)) {
1645 pa_sink
*root_sink
= pa_sink_get_master(i
->sink
);
1646 pa_sink_input
*origin_sink_input
;
1649 if (PA_UNLIKELY(!root_sink
))
1652 if (pa_sink_flat_volume_enabled(i
->sink
)) {
1653 /* Ok, so the origin sink uses volume sharing, and flat volume is
1654 * enabled. The volume will have to be updated as follows:
1656 * i->volume := i->sink->real_volume
1657 * (handled later by pa_sink_set_volume)
1658 * i->reference_ratio := i->volume / i->sink->reference_volume
1659 * (handled later by pa_sink_set_volume)
1660 * i->real_ratio stays unchanged
1661 * (streams whose origin sink uses volume sharing should
1662 * always have real_ratio of 0 dB)
1663 * i->soft_volume stays unchanged
1664 * (streams whose origin sink uses volume sharing should
1665 * always have volume_factor as soft_volume, so no change
1666 * should be needed) */
1668 pa_assert(pa_cvolume_is_norm(&i
->real_ratio
));
1669 pa_assert(pa_cvolume_equal(&i
->soft_volume
, &i
->volume_factor
));
1671 /* Notifications will be sent by pa_sink_set_volume(). */
1674 /* Ok, so the origin sink uses volume sharing, and flat volume is
1675 * disabled. The volume will have to be updated as follows:
1678 * i->reference_ratio := 0 dB
1679 * i->real_ratio stays unchanged
1680 * (streams whose origin sink uses volume sharing should
1681 * always have real_ratio of 0 dB)
1682 * i->soft_volume stays unchanged
1683 * (streams whose origin sink uses volume sharing should
1684 * always have volume_factor as soft_volume, so no change
1685 * should be needed) */
1687 old_volume
= i
->volume
;
1688 pa_cvolume_reset(&i
->volume
, i
->volume
.channels
);
1689 pa_cvolume_reset(&i
->reference_ratio
, i
->reference_ratio
.channels
);
1690 pa_assert(pa_cvolume_is_norm(&i
->real_ratio
));
1691 pa_assert(pa_cvolume_equal(&i
->soft_volume
, &i
->volume_factor
));
1693 /* Notify others about the changed sink input volume. */
1694 if (!pa_cvolume_equal(&i
->volume
, &old_volume
)) {
1695 if (i
->volume_changed
)
1696 i
->volume_changed(i
);
1698 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1702 /* Additionally, the origin sink volume needs updating:
1704 * i->origin_sink->reference_volume := root_sink->reference_volume
1705 * i->origin_sink->real_volume := root_sink->real_volume
1706 * i->origin_sink->soft_volume stays unchanged
1707 * (sinks that use volume sharing should always have
1708 * soft_volume of 0 dB) */
1710 old_volume
= i
->origin_sink
->reference_volume
;
1712 i
->origin_sink
->reference_volume
= root_sink
->reference_volume
;
1713 pa_cvolume_remap(&i
->origin_sink
->reference_volume
, &root_sink
->channel_map
, &i
->origin_sink
->channel_map
);
1715 i
->origin_sink
->real_volume
= root_sink
->real_volume
;
1716 pa_cvolume_remap(&i
->origin_sink
->real_volume
, &root_sink
->channel_map
, &i
->origin_sink
->channel_map
);
1718 pa_assert(pa_cvolume_is_norm(&i
->origin_sink
->soft_volume
));
1720 /* Notify others about the changed sink volume. If you wonder whether
1721 * i->origin_sink->set_volume() should be called somewhere, that's not
1722 * the case, because sinks that use volume sharing shouldn't have any
1723 * internal volume that set_volume() would update. If you wonder
1724 * whether the thread_info variables should be synced, yes, they
1725 * should, and it's done by the PA_SINK_MESSAGE_FINISH_MOVE message
1727 if (!pa_cvolume_equal(&i
->origin_sink
->reference_volume
, &old_volume
))
1728 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->origin_sink
->index
);
1730 /* Recursively update origin sink inputs. */
1731 PA_IDXSET_FOREACH(origin_sink_input
, i
->origin_sink
->inputs
, idx
)
1732 update_volume_due_to_moving(origin_sink_input
, dest
);
1735 old_volume
= i
->volume
;
1737 if (pa_sink_flat_volume_enabled(i
->sink
)) {
1738 /* Ok, so this is a regular stream, and flat volume is enabled. The
1739 * volume will have to be updated as follows:
1741 * i->volume := i->reference_ratio * i->sink->reference_volume
1742 * i->reference_ratio stays unchanged
1743 * i->real_ratio := i->volume / i->sink->real_volume
1744 * (handled later by pa_sink_set_volume)
1745 * i->soft_volume := i->real_ratio * i->volume_factor
1746 * (handled later by pa_sink_set_volume) */
1748 i
->volume
= i
->sink
->reference_volume
;
1749 pa_cvolume_remap(&i
->volume
, &i
->sink
->channel_map
, &i
->channel_map
);
1750 pa_sw_cvolume_multiply(&i
->volume
, &i
->volume
, &i
->reference_ratio
);
1753 /* Ok, so this is a regular stream, and flat volume is disabled.
1754 * The volume will have to be updated as follows:
1756 * i->volume := i->reference_ratio
1757 * i->reference_ratio stays unchanged
1758 * i->real_ratio := i->reference_ratio
1759 * i->soft_volume := i->real_ratio * i->volume_factor */
1761 i
->volume
= i
->reference_ratio
;
1762 i
->real_ratio
= i
->reference_ratio
;
1763 pa_sw_cvolume_multiply(&i
->soft_volume
, &i
->real_ratio
, &i
->volume_factor
);
1766 /* Notify others about the changed sink input volume. */
1767 if (!pa_cvolume_equal(&i
->volume
, &old_volume
)) {
1768 /* XXX: In case i->sink has flat volume enabled, then real_ratio
1769 * and soft_volume are not updated yet. Let's hope that the
1770 * callback implementation doesn't care about those variables... */
1771 if (i
->volume_changed
)
1772 i
->volume_changed(i
);
1774 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1778 /* If i->sink == dest, then recursion has finished, and we can finally call
1779 * pa_sink_set_volume(), which will do the rest of the updates. */
1780 if ((i
->sink
== dest
) && pa_sink_flat_volume_enabled(i
->sink
))
1781 pa_sink_set_volume(i
->sink
, NULL
, false, i
->save_volume
);
1784 /* Called from main context */
1785 int pa_sink_input_finish_move(pa_sink_input
*i
, pa_sink
*dest
, bool save
) {
1786 struct volume_factor_entry
*v
;
1789 pa_sink_input_assert_ref(i
);
1790 pa_assert_ctl_context();
1791 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1792 pa_assert(!i
->sink
);
1793 pa_sink_assert_ref(dest
);
1795 if (!pa_sink_input_may_move_to(i
, dest
))
1796 return -PA_ERR_NOTSUPPORTED
;
1798 if (pa_sink_input_is_passthrough(i
) && !pa_sink_check_format(dest
, i
->format
)) {
1799 pa_proplist
*p
= pa_proplist_new();
1800 pa_log_debug("New sink doesn't support stream format, sending format-changed and killing");
1801 /* Tell the client what device we want to be on if it is going to
1803 pa_proplist_sets(p
, "device", dest
->name
);
1804 pa_sink_input_send_event(i
, PA_STREAM_EVENT_FORMAT_LOST
, p
);
1805 pa_proplist_free(p
);
1806 return -PA_ERR_NOTSUPPORTED
;
1809 if (!(i
->flags
& PA_SINK_INPUT_VARIABLE_RATE
) &&
1810 !pa_sample_spec_equal(&i
->sample_spec
, &dest
->sample_spec
)) {
1811 /* try to change dest sink rate if possible without glitches.
1812 module-suspend-on-idle resumes destination sink with
1813 SINK_INPUT_MOVE_FINISH hook */
1815 pa_log_info("Trying to change sample rate");
1816 if (pa_sink_update_rate(dest
, i
->sample_spec
.rate
, pa_sink_input_is_passthrough(i
)) >= 0)
1817 pa_log_info("Rate changed to %u Hz", dest
->sample_spec
.rate
);
1824 i
->save_sink
= save
;
1825 pa_idxset_put(dest
->inputs
, pa_sink_input_ref(i
), NULL
);
1827 PA_HASHMAP_FOREACH(v
, i
->volume_factor_sink_items
, state
)
1828 pa_cvolume_remap(&v
->volume
, &i
->channel_map
, &i
->sink
->channel_map
);
1830 pa_cvolume_remap(&i
->volume_factor_sink
, &i
->channel_map
, &i
->sink
->channel_map
);
1832 if (pa_sink_input_get_state(i
) == PA_SINK_INPUT_CORKED
)
1833 i
->sink
->n_corked
++;
1835 pa_sink_input_update_rate(i
);
1837 pa_sink_update_status(dest
);
1839 update_volume_due_to_moving(i
, dest
);
1841 if (pa_sink_input_is_passthrough(i
))
1842 pa_sink_enter_passthrough(i
->sink
);
1844 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
->sink
), PA_SINK_MESSAGE_FINISH_MOVE
, i
, 0, NULL
) == 0);
1846 pa_log_debug("Successfully moved sink input %i to %s.", i
->index
, dest
->name
);
1848 /* Notify everyone */
1849 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH
], i
);
1850 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1855 /* Called from main context */
1856 void pa_sink_input_fail_move(pa_sink_input
*i
) {
1858 pa_sink_input_assert_ref(i
);
1859 pa_assert_ctl_context();
1860 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1861 pa_assert(!i
->sink
);
1863 /* Check if someone wants this sink input? */
1864 if (pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL
], i
) == PA_HOOK_STOP
)
1870 pa_sink_input_kill(i
);
1873 /* Called from main context */
1874 int pa_sink_input_move_to(pa_sink_input
*i
, pa_sink
*dest
, bool save
) {
1877 pa_sink_input_assert_ref(i
);
1878 pa_assert_ctl_context();
1879 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1881 pa_sink_assert_ref(dest
);
1883 if (dest
== i
->sink
)
1886 if (!pa_sink_input_may_move_to(i
, dest
))
1887 return -PA_ERR_NOTSUPPORTED
;
1889 pa_sink_input_ref(i
);
1891 if ((r
= pa_sink_input_start_move(i
)) < 0) {
1892 pa_sink_input_unref(i
);
1896 if ((r
= pa_sink_input_finish_move(i
, dest
, save
)) < 0) {
1897 pa_sink_input_fail_move(i
);
1898 pa_sink_input_unref(i
);
1902 pa_sink_input_unref(i
);
1907 /* Called from IO thread context */
1908 void pa_sink_input_set_state_within_thread(pa_sink_input
*i
, pa_sink_input_state_t state
) {
1909 bool corking
, uncorking
;
1911 pa_sink_input_assert_ref(i
);
1912 pa_sink_input_assert_io_context(i
);
1914 if (state
== i
->thread_info
.state
)
1917 if ((state
== PA_SINK_INPUT_DRAINED
|| state
== PA_SINK_INPUT_RUNNING
) &&
1918 !(i
->thread_info
.state
== PA_SINK_INPUT_DRAINED
|| i
->thread_info
.state
!= PA_SINK_INPUT_RUNNING
))
1919 pa_atomic_store(&i
->thread_info
.drained
, 1);
1921 corking
= state
== PA_SINK_INPUT_CORKED
&& i
->thread_info
.state
== PA_SINK_INPUT_RUNNING
;
1922 uncorking
= i
->thread_info
.state
== PA_SINK_INPUT_CORKED
&& state
== PA_SINK_INPUT_RUNNING
;
1924 if (i
->state_change
)
1925 i
->state_change(i
, state
);
1929 pa_log_debug("Requesting rewind due to corking");
1931 /* This will tell the implementing sink input driver to rewind
1932 * so that the unplayed already mixed data is not lost */
1933 pa_sink_input_request_rewind(i
, 0, true, true, false);
1935 /* Set the corked state *after* requesting rewind */
1936 i
->thread_info
.state
= state
;
1938 } else if (uncorking
) {
1940 pa_log_debug("Requesting rewind due to uncorking");
1942 i
->thread_info
.underrun_for
= (uint64_t) -1;
1943 i
->thread_info
.underrun_for_sink
= 0;
1944 i
->thread_info
.playing_for
= 0;
1946 /* Set the uncorked state *before* requesting rewind */
1947 i
->thread_info
.state
= state
;
1949 /* OK, we're being uncorked. Make sure we're not rewound when
1950 * the hw buffer is remixed and request a remix. */
1951 pa_sink_input_request_rewind(i
, 0, false, true, true);
1953 /* We may not be corking or uncorking, but we still need to set the state. */
1954 i
->thread_info
.state
= state
;
1957 /* Called from thread context, except when it is not. */
1958 int pa_sink_input_process_msg(pa_msgobject
*o
, int code
, void *userdata
, int64_t offset
, pa_memchunk
*chunk
) {
1959 pa_sink_input
*i
= PA_SINK_INPUT(o
);
1960 pa_sink_input_assert_ref(i
);
1964 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME
:
1965 if (!pa_cvolume_equal(&i
->thread_info
.soft_volume
, &i
->soft_volume
)) {
1966 i
->thread_info
.soft_volume
= i
->soft_volume
;
1967 pa_sink_input_request_rewind(i
, 0, true, false, false);
1971 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE
:
1972 if (i
->thread_info
.muted
!= i
->muted
) {
1973 i
->thread_info
.muted
= i
->muted
;
1974 pa_sink_input_request_rewind(i
, 0, true, false, false);
1978 case PA_SINK_INPUT_MESSAGE_GET_LATENCY
: {
1979 pa_usec_t
*r
= userdata
;
1981 r
[0] += pa_bytes_to_usec(pa_memblockq_get_length(i
->thread_info
.render_memblockq
), &i
->sink
->sample_spec
);
1982 r
[1] += pa_sink_get_latency_within_thread(i
->sink
);
1987 case PA_SINK_INPUT_MESSAGE_SET_RATE
:
1989 i
->thread_info
.sample_spec
.rate
= PA_PTR_TO_UINT(userdata
);
1990 pa_resampler_set_input_rate(i
->thread_info
.resampler
, PA_PTR_TO_UINT(userdata
));
1994 case PA_SINK_INPUT_MESSAGE_SET_STATE
: {
1995 pa_sink_input
*ssync
;
1997 pa_sink_input_set_state_within_thread(i
, PA_PTR_TO_UINT(userdata
));
1999 for (ssync
= i
->thread_info
.sync_prev
; ssync
; ssync
= ssync
->thread_info
.sync_prev
)
2000 pa_sink_input_set_state_within_thread(ssync
, PA_PTR_TO_UINT(userdata
));
2002 for (ssync
= i
->thread_info
.sync_next
; ssync
; ssync
= ssync
->thread_info
.sync_next
)
2003 pa_sink_input_set_state_within_thread(ssync
, PA_PTR_TO_UINT(userdata
));
2008 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY
: {
2009 pa_usec_t
*usec
= userdata
;
2011 *usec
= pa_sink_input_set_requested_latency_within_thread(i
, *usec
);
2015 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY
: {
2016 pa_usec_t
*r
= userdata
;
2018 *r
= i
->thread_info
.requested_sink_latency
;
2023 return -PA_ERR_NOTIMPLEMENTED
;
2026 /* Called from main thread */
2027 pa_sink_input_state_t
pa_sink_input_get_state(pa_sink_input
*i
) {
2028 pa_sink_input_assert_ref(i
);
2029 pa_assert_ctl_context();
2031 if (i
->state
== PA_SINK_INPUT_RUNNING
|| i
->state
== PA_SINK_INPUT_DRAINED
)
2032 return pa_atomic_load(&i
->thread_info
.drained
) ? PA_SINK_INPUT_DRAINED
: PA_SINK_INPUT_RUNNING
;
2037 /* Called from IO context */
2038 bool pa_sink_input_safe_to_remove(pa_sink_input
*i
) {
2039 pa_sink_input_assert_ref(i
);
2040 pa_sink_input_assert_io_context(i
);
2042 if (PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
))
2043 return pa_memblockq_is_empty(i
->thread_info
.render_memblockq
);
2048 /* Called from IO context */
2049 void pa_sink_input_request_rewind(
2051 size_t nbytes
/* in our sample spec */,
2054 bool dont_rewind_render
) {
2058 /* If 'rewrite' is true the sink is rewound as far as requested
2059 * and possible and the exact value of this is passed back the
2060 * implementor via process_rewind(). If 'flush' is also true all
2061 * already rendered data is also dropped.
2063 * If 'rewrite' is false the sink is rewound as far as requested
2064 * and possible and the already rendered data is dropped so that
2065 * in the next iteration we read new data from the
2066 * implementor. This implies 'flush' is true. If
2067 * dont_rewind_render is true then the render memblockq is not
2070 /* nbytes = 0 means maximum rewind request */
2072 pa_sink_input_assert_ref(i
);
2073 pa_sink_input_assert_io_context(i
);
2074 pa_assert(rewrite
|| flush
);
2075 pa_assert(!dont_rewind_render
|| !rewrite
);
2077 /* We don't take rewind requests while we are corked */
2078 if (i
->thread_info
.state
== PA_SINK_INPUT_CORKED
)
2081 nbytes
= PA_MAX(i
->thread_info
.rewrite_nbytes
, nbytes
);
2083 #ifdef SINK_INPUT_DEBUG
2084 pa_log_debug("request rewrite %zu", nbytes
);
2087 /* Calculate how much we can rewind locally without having to
2090 lbq
= pa_memblockq_get_length(i
->thread_info
.render_memblockq
);
2094 /* Check if rewinding for the maximum is requested, and if so, fix up */
2097 /* Calculate maximum number of bytes that could be rewound in theory */
2098 nbytes
= i
->sink
->thread_info
.max_rewind
+ lbq
;
2100 /* Transform from sink domain */
2101 if (i
->thread_info
.resampler
)
2102 nbytes
= pa_resampler_request(i
->thread_info
.resampler
, nbytes
);
2105 /* Remember how much we actually want to rewrite */
2106 if (i
->thread_info
.rewrite_nbytes
!= (size_t) -1) {
2108 /* Make sure to not overwrite over underruns */
2109 if (nbytes
> i
->thread_info
.playing_for
)
2110 nbytes
= (size_t) i
->thread_info
.playing_for
;
2112 i
->thread_info
.rewrite_nbytes
= nbytes
;
2114 i
->thread_info
.rewrite_nbytes
= (size_t) -1;
2117 i
->thread_info
.rewrite_flush
=
2118 i
->thread_info
.rewrite_flush
|| flush
;
2120 i
->thread_info
.dont_rewind_render
=
2121 i
->thread_info
.dont_rewind_render
||
2124 /* nbytes is -1 if some earlier rewind request had rewrite == false. */
2125 if (nbytes
!= (size_t) -1) {
2127 /* Transform to sink domain */
2128 if (i
->thread_info
.resampler
)
2129 nbytes
= pa_resampler_result(i
->thread_info
.resampler
, nbytes
);
2132 pa_sink_request_rewind(i
->sink
, nbytes
- lbq
);
2134 /* This call will make sure process_rewind() is called later */
2135 pa_sink_request_rewind(i
->sink
, 0);
2139 /* Called from main context */
2140 pa_memchunk
* pa_sink_input_get_silence(pa_sink_input
*i
, pa_memchunk
*ret
) {
2141 pa_sink_input_assert_ref(i
);
2142 pa_assert_ctl_context();
2145 /* FIXME: Shouldn't access resampler object from main context! */
2147 pa_silence_memchunk_get(
2148 &i
->core
->silence_cache
,
2152 i
->thread_info
.resampler
? pa_resampler_max_block_size(i
->thread_info
.resampler
) : 0);
2157 /* Called from main context */
2158 void pa_sink_input_send_event(pa_sink_input
*i
, const char *event
, pa_proplist
*data
) {
2159 pa_proplist
*pl
= NULL
;
2160 pa_sink_input_send_event_hook_data hook_data
;
2162 pa_sink_input_assert_ref(i
);
2163 pa_assert_ctl_context();
2170 data
= pl
= pa_proplist_new();
2172 hook_data
.sink_input
= i
;
2173 hook_data
.data
= data
;
2174 hook_data
.event
= event
;
2176 if (pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT
], &hook_data
) < 0)
2179 i
->send_event(i
, event
, data
);
2183 pa_proplist_free(pl
);
2186 /* Called from main context */
2187 /* Updates the sink input's resampler with whatever the current sink requires
2188 * -- useful when the underlying sink's rate might have changed */
2189 int pa_sink_input_update_rate(pa_sink_input
*i
) {
2190 pa_resampler
*new_resampler
;
2191 char *memblockq_name
;
2193 pa_sink_input_assert_ref(i
);
2194 pa_assert_ctl_context();
2196 if (i
->thread_info
.resampler
&&
2197 pa_sample_spec_equal(pa_resampler_output_sample_spec(i
->thread_info
.resampler
), &i
->sink
->sample_spec
) &&
2198 pa_channel_map_equal(pa_resampler_output_channel_map(i
->thread_info
.resampler
), &i
->sink
->channel_map
))
2200 new_resampler
= i
->thread_info
.resampler
;
2202 else if (!pa_sink_input_is_passthrough(i
) &&
2203 ((i
->flags
& PA_SINK_INPUT_VARIABLE_RATE
) ||
2204 !pa_sample_spec_equal(&i
->sample_spec
, &i
->sink
->sample_spec
) ||
2205 !pa_channel_map_equal(&i
->channel_map
, &i
->sink
->channel_map
))) {
2207 new_resampler
= pa_resampler_new(i
->core
->mempool
,
2208 &i
->sample_spec
, &i
->channel_map
,
2209 &i
->sink
->sample_spec
, &i
->sink
->channel_map
,
2210 i
->requested_resample_method
,
2211 ((i
->flags
& PA_SINK_INPUT_VARIABLE_RATE
) ? PA_RESAMPLER_VARIABLE_RATE
: 0) |
2212 ((i
->flags
& PA_SINK_INPUT_NO_REMAP
) ? PA_RESAMPLER_NO_REMAP
: 0) |
2213 (i
->core
->disable_remixing
|| (i
->flags
& PA_SINK_INPUT_NO_REMIX
) ? PA_RESAMPLER_NO_REMIX
: 0) |
2214 (i
->core
->disable_lfe_remixing
? PA_RESAMPLER_NO_LFE
: 0));
2216 if (!new_resampler
) {
2217 pa_log_warn("Unsupported resampling operation.");
2218 return -PA_ERR_NOTSUPPORTED
;
2221 new_resampler
= NULL
;
2223 if (new_resampler
== i
->thread_info
.resampler
)
2226 if (i
->thread_info
.resampler
)
2227 pa_resampler_free(i
->thread_info
.resampler
);
2229 i
->thread_info
.resampler
= new_resampler
;
2231 pa_memblockq_free(i
->thread_info
.render_memblockq
);
2233 memblockq_name
= pa_sprintf_malloc("sink input render_memblockq [%u]", i
->index
);
2234 i
->thread_info
.render_memblockq
= pa_memblockq_new(
2237 MEMBLOCKQ_MAXLENGTH
,
2239 &i
->sink
->sample_spec
,
2244 pa_xfree(memblockq_name
);
2246 i
->actual_resample_method
= new_resampler
? pa_resampler_get_method(new_resampler
) : PA_RESAMPLER_INVALID
;
2248 pa_log_debug("Updated resampler for sink input %d", i
->index
);