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/utf8.h>
32 #include <pulse/xmalloc.h>
33 #include <pulse/util.h>
35 #include <pulsecore/sample-util.h>
36 #include <pulsecore/core-subscribe.h>
37 #include <pulsecore/log.h>
38 #include <pulsecore/play-memblockq.h>
39 #include <pulsecore/namereg.h>
40 #include <pulsecore/core-util.h>
42 #include "sink-input.h"
44 #define MEMBLOCKQ_MAXLENGTH (32*1024*1024)
45 #define CONVERT_BUFFER_LENGTH (PA_PAGE_SIZE)
47 static PA_DEFINE_CHECK_TYPE(pa_sink_input
, pa_msgobject
);
49 static void sink_input_free(pa_object
*o
);
51 pa_sink_input_new_data
* pa_sink_input_new_data_init(pa_sink_input_new_data
*data
) {
54 memset(data
, 0, sizeof(*data
));
55 data
->resample_method
= PA_RESAMPLER_INVALID
;
56 data
->proplist
= pa_proplist_new();
61 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data
*data
, const pa_sample_spec
*spec
) {
64 if ((data
->sample_spec_is_set
= !!spec
))
65 data
->sample_spec
= *spec
;
68 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data
*data
, const pa_channel_map
*map
) {
71 if ((data
->channel_map_is_set
= !!map
))
72 data
->channel_map
= *map
;
75 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data
*data
, const pa_cvolume
*volume
) {
78 if ((data
->volume_is_set
= !!volume
))
79 data
->volume
= *volume
;
82 void pa_sink_input_new_data_apply_volume_factor(pa_sink_input_new_data
*data
, const pa_cvolume
*volume_factor
) {
84 pa_assert(volume_factor
);
86 if (data
->volume_factor_is_set
)
87 pa_sw_cvolume_multiply(&data
->volume_factor
, &data
->volume_factor
, volume_factor
);
89 data
->volume_factor_is_set
= TRUE
;
90 data
->volume_factor
= *volume_factor
;
94 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data
*data
, pa_bool_t mute
) {
97 data
->muted_is_set
= TRUE
;
101 void pa_sink_input_new_data_done(pa_sink_input_new_data
*data
) {
104 pa_proplist_free(data
->proplist
);
107 /* Called from main context */
108 static void reset_callbacks(pa_sink_input
*i
) {
112 i
->process_rewind
= NULL
;
113 i
->update_max_rewind
= NULL
;
114 i
->update_max_request
= NULL
;
115 i
->update_sink_requested_latency
= NULL
;
116 i
->update_sink_latency_range
= NULL
;
120 i
->suspend_within_thread
= NULL
;
123 i
->get_latency
= NULL
;
124 i
->state_change
= NULL
;
125 i
->may_move_to
= NULL
;
126 i
->send_event
= NULL
;
129 /* Called from main context */
130 int pa_sink_input_new(
133 pa_sink_input_new_data
*data
,
134 pa_sink_input_flags_t flags
) {
137 pa_resampler
*resampler
= NULL
;
138 char st
[PA_SAMPLE_SPEC_SNPRINT_MAX
], cm
[PA_CHANNEL_MAP_SNPRINT_MAX
];
139 pa_channel_map original_cm
;
147 pa_proplist_update(data
->proplist
, PA_UPDATE_MERGE
, data
->client
->proplist
);
149 if ((r
= pa_hook_fire(&core
->hooks
[PA_CORE_HOOK_SINK_INPUT_NEW
], data
)) < 0)
152 pa_return_val_if_fail(!data
->driver
|| pa_utf8_valid(data
->driver
), -PA_ERR_INVALID
);
155 data
->sink
= pa_namereg_get(core
, NULL
, PA_NAMEREG_SINK
);
156 data
->save_sink
= FALSE
;
159 pa_return_val_if_fail(data
->sink
, -PA_ERR_NOENTITY
);
160 pa_return_val_if_fail(PA_SINK_IS_LINKED(pa_sink_get_state(data
->sink
)), -PA_ERR_BADSTATE
);
161 pa_return_val_if_fail(!data
->sync_base
|| (data
->sync_base
->sink
== data
->sink
&& pa_sink_input_get_state(data
->sync_base
) == PA_SINK_INPUT_CORKED
), -PA_ERR_INVALID
);
163 if (!data
->sample_spec_is_set
)
164 data
->sample_spec
= data
->sink
->sample_spec
;
166 pa_return_val_if_fail(pa_sample_spec_valid(&data
->sample_spec
), -PA_ERR_INVALID
);
168 if (!data
->channel_map_is_set
) {
169 if (pa_channel_map_compatible(&data
->sink
->channel_map
, &data
->sample_spec
))
170 data
->channel_map
= data
->sink
->channel_map
;
172 pa_channel_map_init_extend(&data
->channel_map
, data
->sample_spec
.channels
, PA_CHANNEL_MAP_DEFAULT
);
175 pa_return_val_if_fail(pa_channel_map_valid(&data
->channel_map
), -PA_ERR_INVALID
);
176 pa_return_val_if_fail(pa_channel_map_compatible(&data
->channel_map
, &data
->sample_spec
), -PA_ERR_INVALID
);
178 if (!data
->volume_is_set
) {
180 if (data
->sink
->flags
& PA_SINK_FLAT_VOLUME
) {
181 data
->volume
= *pa_sink_get_volume(data
->sink
, FALSE
);
182 pa_cvolume_remap(&data
->volume
, &data
->sink
->channel_map
, &data
->channel_map
);
183 data
->volume_is_absolute
= TRUE
;
185 pa_cvolume_reset(&data
->volume
, data
->sample_spec
.channels
);
186 data
->volume_is_absolute
= FALSE
;
189 data
->save_volume
= FALSE
;
192 pa_return_val_if_fail(pa_cvolume_valid(&data
->volume
), -PA_ERR_INVALID
);
193 pa_return_val_if_fail(pa_cvolume_compatible(&data
->volume
, &data
->sample_spec
), -PA_ERR_INVALID
);
195 if (!data
->volume_factor_is_set
)
196 pa_cvolume_reset(&data
->volume_factor
, data
->sample_spec
.channels
);
198 pa_return_val_if_fail(pa_cvolume_valid(&data
->volume_factor
), -PA_ERR_INVALID
);
199 pa_return_val_if_fail(pa_cvolume_compatible(&data
->volume_factor
, &data
->sample_spec
), -PA_ERR_INVALID
);
201 if (!data
->muted_is_set
)
204 if (flags
& PA_SINK_INPUT_FIX_FORMAT
)
205 data
->sample_spec
.format
= data
->sink
->sample_spec
.format
;
207 if (flags
& PA_SINK_INPUT_FIX_RATE
)
208 data
->sample_spec
.rate
= data
->sink
->sample_spec
.rate
;
210 original_cm
= data
->channel_map
;
212 if (flags
& PA_SINK_INPUT_FIX_CHANNELS
) {
213 data
->sample_spec
.channels
= data
->sink
->sample_spec
.channels
;
214 data
->channel_map
= data
->sink
->channel_map
;
217 pa_assert(pa_sample_spec_valid(&data
->sample_spec
));
218 pa_assert(pa_channel_map_valid(&data
->channel_map
));
220 /* Due to the fixing of the sample spec the volume might not match anymore */
221 pa_cvolume_remap(&data
->volume
, &original_cm
, &data
->channel_map
);
223 if (data
->resample_method
== PA_RESAMPLER_INVALID
)
224 data
->resample_method
= core
->resample_method
;
226 pa_return_val_if_fail(data
->resample_method
< PA_RESAMPLER_MAX
, -PA_ERR_INVALID
);
228 if ((r
= pa_hook_fire(&core
->hooks
[PA_CORE_HOOK_SINK_INPUT_FIXATE
], data
)) < 0)
231 if ((flags
& PA_SINK_INPUT_FAIL_ON_SUSPEND
) &&
232 pa_sink_get_state(data
->sink
) == PA_SINK_SUSPENDED
) {
233 pa_log_warn("Failed to create sink input: sink is suspended.");
234 return -PA_ERR_BADSTATE
;
237 if (pa_idxset_size(data
->sink
->inputs
) >= PA_MAX_INPUTS_PER_SINK
) {
238 pa_log_warn("Failed to create sink input: too many inputs per sink.");
239 return -PA_ERR_TOOLARGE
;
242 if ((flags
& PA_SINK_INPUT_VARIABLE_RATE
) ||
243 !pa_sample_spec_equal(&data
->sample_spec
, &data
->sink
->sample_spec
) ||
244 !pa_channel_map_equal(&data
->channel_map
, &data
->sink
->channel_map
)) {
246 if (!(resampler
= pa_resampler_new(
248 &data
->sample_spec
, &data
->channel_map
,
249 &data
->sink
->sample_spec
, &data
->sink
->channel_map
,
250 data
->resample_method
,
251 ((flags
& PA_SINK_INPUT_VARIABLE_RATE
) ? PA_RESAMPLER_VARIABLE_RATE
: 0) |
252 ((flags
& PA_SINK_INPUT_NO_REMAP
) ? PA_RESAMPLER_NO_REMAP
: 0) |
253 (core
->disable_remixing
|| (flags
& PA_SINK_INPUT_NO_REMIX
) ? PA_RESAMPLER_NO_REMIX
: 0) |
254 (core
->disable_lfe_remixing
? PA_RESAMPLER_NO_LFE
: 0)))) {
255 pa_log_warn("Unsupported resampling operation.");
256 return -PA_ERR_NOTSUPPORTED
;
260 i
= pa_msgobject_new(pa_sink_input
);
261 i
->parent
.parent
.free
= sink_input_free
;
262 i
->parent
.process_msg
= pa_sink_input_process_msg
;
265 i
->state
= PA_SINK_INPUT_INIT
;
267 i
->proplist
= pa_proplist_copy(data
->proplist
);
268 i
->driver
= pa_xstrdup(pa_path_get_filename(data
->driver
));
269 i
->module
= data
->module
;
270 i
->sink
= data
->sink
;
271 i
->client
= data
->client
;
273 i
->requested_resample_method
= data
->resample_method
;
274 i
->actual_resample_method
= resampler
? pa_resampler_get_method(resampler
) : PA_RESAMPLER_INVALID
;
275 i
->sample_spec
= data
->sample_spec
;
276 i
->channel_map
= data
->channel_map
;
278 if ((i
->sink
->flags
& PA_SINK_FLAT_VOLUME
) && !data
->volume_is_absolute
) {
279 /* When the 'absolute' bool is not set then we'll treat the volume
280 * as relative to the sink volume even in flat volume mode */
282 pa_cvolume t
= *pa_sink_get_volume(data
->sink
, FALSE
);
283 pa_cvolume_remap(&t
, &data
->sink
->channel_map
, &data
->channel_map
);
285 pa_sw_cvolume_multiply(&i
->virtual_volume
, &data
->volume
, &t
);
287 i
->virtual_volume
= data
->volume
;
289 i
->volume_factor
= data
->volume_factor
;
290 pa_cvolume_init(&i
->soft_volume
);
291 memset(i
->relative_volume
, 0, sizeof(i
->relative_volume
));
292 i
->save_volume
= data
->save_volume
;
293 i
->save_sink
= data
->save_sink
;
294 i
->save_muted
= data
->save_muted
;
296 i
->muted
= data
->muted
;
298 if (data
->sync_base
) {
299 i
->sync_next
= data
->sync_base
->sync_next
;
300 i
->sync_prev
= data
->sync_base
;
302 if (data
->sync_base
->sync_next
)
303 data
->sync_base
->sync_next
->sync_prev
= i
;
304 data
->sync_base
->sync_next
= i
;
306 i
->sync_next
= i
->sync_prev
= NULL
;
308 i
->direct_outputs
= pa_idxset_new(NULL
, NULL
);
313 i
->thread_info
.state
= i
->state
;
314 i
->thread_info
.attached
= FALSE
;
315 pa_atomic_store(&i
->thread_info
.drained
, 1);
316 i
->thread_info
.sample_spec
= i
->sample_spec
;
317 i
->thread_info
.resampler
= resampler
;
318 i
->thread_info
.soft_volume
= i
->soft_volume
;
319 i
->thread_info
.muted
= i
->muted
;
320 i
->thread_info
.requested_sink_latency
= (pa_usec_t
) -1;
321 i
->thread_info
.rewrite_nbytes
= 0;
322 i
->thread_info
.rewrite_flush
= FALSE
;
323 i
->thread_info
.dont_rewind_render
= FALSE
;
324 i
->thread_info
.underrun_for
= (uint64_t) -1;
325 i
->thread_info
.playing_for
= 0;
326 i
->thread_info
.direct_outputs
= pa_hashmap_new(pa_idxset_trivial_hash_func
, pa_idxset_trivial_compare_func
);
328 i
->thread_info
.render_memblockq
= pa_memblockq_new(
332 pa_frame_size(&i
->sink
->sample_spec
),
338 pa_assert_se(pa_idxset_put(core
->sink_inputs
, i
, &i
->index
) == 0);
339 pa_assert_se(pa_idxset_put(i
->sink
->inputs
, pa_sink_input_ref(i
), NULL
) == 0);
342 pa_assert_se(pa_idxset_put(i
->client
->sink_inputs
, i
, NULL
) >= 0);
344 pa_log_info("Created input %u \"%s\" on %s with sample spec %s and channel map %s",
346 pa_strnull(pa_proplist_gets(i
->proplist
, PA_PROP_MEDIA_NAME
)),
348 pa_sample_spec_snprint(st
, sizeof(st
), &i
->sample_spec
),
349 pa_channel_map_snprint(cm
, sizeof(cm
), &i
->channel_map
));
351 /* Don't forget to call pa_sink_input_put! */
357 /* Called from main context */
358 static void update_n_corked(pa_sink_input
*i
, pa_sink_input_state_t state
) {
364 if (i
->state
== PA_SINK_INPUT_CORKED
&& state
!= PA_SINK_INPUT_CORKED
)
365 pa_assert_se(i
->sink
->n_corked
-- >= 1);
366 else if (i
->state
!= PA_SINK_INPUT_CORKED
&& state
== PA_SINK_INPUT_CORKED
)
370 /* Called from main context */
371 static void sink_input_set_state(pa_sink_input
*i
, pa_sink_input_state_t state
) {
372 pa_sink_input
*ssync
;
375 if (state
== PA_SINK_INPUT_DRAINED
)
376 state
= PA_SINK_INPUT_RUNNING
;
378 if (i
->state
== state
)
381 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);
383 update_n_corked(i
, state
);
386 for (ssync
= i
->sync_prev
; ssync
; ssync
= ssync
->sync_prev
) {
387 update_n_corked(ssync
, state
);
388 ssync
->state
= state
;
390 for (ssync
= i
->sync_next
; ssync
; ssync
= ssync
->sync_next
) {
391 update_n_corked(ssync
, state
);
392 ssync
->state
= state
;
395 if (state
!= PA_SINK_INPUT_UNLINKED
) {
396 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED
], i
);
398 for (ssync
= i
->sync_prev
; ssync
; ssync
= ssync
->sync_prev
)
399 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED
], ssync
);
401 for (ssync
= i
->sync_next
; ssync
; ssync
= ssync
->sync_next
)
402 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED
], ssync
);
405 pa_sink_update_status(i
->sink
);
408 /* Called from main context */
409 void pa_sink_input_unlink(pa_sink_input
*i
) {
411 pa_source_output
*o
, *p
= NULL
;
414 /* See pa_sink_unlink() for a couple of comments how this function
417 pa_sink_input_ref(i
);
419 linked
= PA_SINK_INPUT_IS_LINKED(i
->state
);
422 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_UNLINK
], i
);
425 i
->sync_prev
->sync_next
= i
->sync_next
;
427 i
->sync_next
->sync_prev
= i
->sync_prev
;
429 i
->sync_prev
= i
->sync_next
= NULL
;
431 pa_idxset_remove_by_data(i
->core
->sink_inputs
, i
, NULL
);
434 if (pa_idxset_remove_by_data(i
->sink
->inputs
, i
, NULL
))
435 pa_sink_input_unref(i
);
438 pa_idxset_remove_by_data(i
->client
->sink_inputs
, i
, NULL
);
440 while ((o
= pa_idxset_first(i
->direct_outputs
, NULL
))) {
442 pa_source_output_kill(o
);
446 update_n_corked(i
, PA_SINK_INPUT_UNLINKED
);
447 i
->state
= PA_SINK_INPUT_UNLINKED
;
449 if (linked
&& i
->sink
) {
450 /* We might need to update the sink's volume if we are in flat volume mode. */
451 if (i
->sink
->flags
& PA_SINK_FLAT_VOLUME
) {
452 pa_cvolume new_volume
;
453 pa_sink_update_flat_volume(i
->sink
, &new_volume
);
454 pa_sink_set_volume(i
->sink
, &new_volume
, FALSE
, FALSE
);
457 if (i
->sink
->asyncmsgq
)
458 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
->sink
), PA_SINK_MESSAGE_REMOVE_INPUT
, i
, 0, NULL
) == 0);
464 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_REMOVE
, i
->index
);
465 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST
], i
);
469 pa_sink_update_status(i
->sink
);
473 pa_core_maybe_vacuum(i
->core
);
475 pa_sink_input_unref(i
);
478 /* Called from main context */
479 static void sink_input_free(pa_object
*o
) {
480 pa_sink_input
* i
= PA_SINK_INPUT(o
);
483 pa_assert(pa_sink_input_refcnt(i
) == 0);
485 if (PA_SINK_INPUT_IS_LINKED(i
->state
))
486 pa_sink_input_unlink(i
);
488 pa_log_info("Freeing input %u \"%s\"", i
->index
, pa_strnull(pa_proplist_gets(i
->proplist
, PA_PROP_MEDIA_NAME
)));
490 pa_assert(!i
->thread_info
.attached
);
492 if (i
->thread_info
.render_memblockq
)
493 pa_memblockq_free(i
->thread_info
.render_memblockq
);
495 if (i
->thread_info
.resampler
)
496 pa_resampler_free(i
->thread_info
.resampler
);
499 pa_proplist_free(i
->proplist
);
501 if (i
->direct_outputs
)
502 pa_idxset_free(i
->direct_outputs
, NULL
, NULL
);
504 if (i
->thread_info
.direct_outputs
)
505 pa_hashmap_free(i
->thread_info
.direct_outputs
, NULL
, NULL
);
511 /* Called from main context */
512 void pa_sink_input_put(pa_sink_input
*i
) {
513 pa_sink_input_state_t state
;
514 pa_sink_input_assert_ref(i
);
516 pa_assert(i
->state
== PA_SINK_INPUT_INIT
);
518 /* The following fields must be initialized properly */
520 pa_assert(i
->process_rewind
);
523 state
= i
->flags
& PA_SINK_INPUT_START_CORKED
? PA_SINK_INPUT_CORKED
: PA_SINK_INPUT_RUNNING
;
525 update_n_corked(i
, state
);
528 /* We might need to update the sink's volume if we are in flat volume mode. */
529 if (i
->sink
->flags
& PA_SINK_FLAT_VOLUME
) {
530 pa_cvolume new_volume
;
531 pa_sink_update_flat_volume(i
->sink
, &new_volume
);
532 pa_sink_set_volume(i
->sink
, &new_volume
, FALSE
, FALSE
);
534 pa_sink_input_set_relative_volume(i
, &i
->virtual_volume
);
536 i
->thread_info
.soft_volume
= i
->soft_volume
;
537 i
->thread_info
.muted
= i
->muted
;
539 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
->sink
), PA_SINK_MESSAGE_ADD_INPUT
, i
, 0, NULL
) == 0);
541 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_NEW
, i
->index
);
542 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_PUT
], i
);
544 pa_sink_update_status(i
->sink
);
547 /* Called from main context */
548 void pa_sink_input_kill(pa_sink_input
*i
) {
549 pa_sink_input_assert_ref(i
);
550 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
555 /* Called from main context */
556 pa_usec_t
pa_sink_input_get_latency(pa_sink_input
*i
, pa_usec_t
*sink_latency
) {
557 pa_usec_t r
[2] = { 0, 0 };
559 pa_sink_input_assert_ref(i
);
560 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
562 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_GET_LATENCY
, r
, 0, NULL
) == 0);
565 r
[0] += i
->get_latency(i
);
568 *sink_latency
= r
[1];
573 /* Called from thread context */
574 void pa_sink_input_peek(pa_sink_input
*i
, size_t slength
/* in sink frames */, pa_memchunk
*chunk
, pa_cvolume
*volume
) {
575 pa_bool_t do_volume_adj_here
;
576 pa_bool_t volume_is_norm
;
577 size_t block_size_max_sink
, block_size_max_sink_input
;
580 pa_sink_input_assert_ref(i
);
581 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
));
582 pa_assert(pa_frame_aligned(slength
, &i
->sink
->sample_spec
));
586 /* pa_log_debug("peek"); */
588 pa_assert(i
->thread_info
.state
== PA_SINK_INPUT_RUNNING
||
589 i
->thread_info
.state
== PA_SINK_INPUT_CORKED
||
590 i
->thread_info
.state
== PA_SINK_INPUT_DRAINED
);
592 block_size_max_sink_input
= i
->thread_info
.resampler
?
593 pa_resampler_max_block_size(i
->thread_info
.resampler
) :
594 pa_frame_align(pa_mempool_block_size_max(i
->core
->mempool
), &i
->sample_spec
);
596 block_size_max_sink
= pa_frame_align(pa_mempool_block_size_max(i
->core
->mempool
), &i
->sink
->sample_spec
);
598 /* Default buffer size */
600 slength
= pa_frame_align(CONVERT_BUFFER_LENGTH
, &i
->sink
->sample_spec
);
602 if (slength
> block_size_max_sink
)
603 slength
= block_size_max_sink
;
605 if (i
->thread_info
.resampler
) {
606 ilength
= pa_resampler_request(i
->thread_info
.resampler
, slength
);
609 ilength
= pa_frame_align(CONVERT_BUFFER_LENGTH
, &i
->sample_spec
);
613 if (ilength
> block_size_max_sink_input
)
614 ilength
= block_size_max_sink_input
;
616 /* If the channel maps of the sink and this stream differ, we need
617 * to adjust the volume *before* we resample. Otherwise we can do
618 * it after and leave it for the sink code */
620 do_volume_adj_here
= !pa_channel_map_equal(&i
->channel_map
, &i
->sink
->channel_map
);
621 volume_is_norm
= pa_cvolume_is_norm(&i
->thread_info
.soft_volume
) && !i
->thread_info
.muted
;
623 while (!pa_memblockq_is_readable(i
->thread_info
.render_memblockq
)) {
626 /* There's nothing in our render queue. We need to fill it up
627 * with data from the implementor. */
629 if (i
->thread_info
.state
== PA_SINK_INPUT_CORKED
||
630 i
->pop(i
, ilength
, &tchunk
) < 0) {
632 /* OK, we're corked or the implementor didn't give us any
633 * data, so let's just hand out silence */
634 pa_atomic_store(&i
->thread_info
.drained
, 1);
636 pa_memblockq_seek(i
->thread_info
.render_memblockq
, (int64_t) slength
, PA_SEEK_RELATIVE
, TRUE
);
637 i
->thread_info
.playing_for
= 0;
638 if (i
->thread_info
.underrun_for
!= (uint64_t) -1)
639 i
->thread_info
.underrun_for
+= ilength
;
643 pa_atomic_store(&i
->thread_info
.drained
, 0);
645 pa_assert(tchunk
.length
> 0);
646 pa_assert(tchunk
.memblock
);
648 i
->thread_info
.underrun_for
= 0;
649 i
->thread_info
.playing_for
+= tchunk
.length
;
651 while (tchunk
.length
> 0) {
655 pa_memblock_ref(wchunk
.memblock
);
657 if (wchunk
.length
> block_size_max_sink_input
)
658 wchunk
.length
= block_size_max_sink_input
;
660 /* It might be necessary to adjust the volume here */
661 if (do_volume_adj_here
&& !volume_is_norm
) {
662 pa_memchunk_make_writable(&wchunk
, 0);
664 if (i
->thread_info
.muted
)
665 pa_silence_memchunk(&wchunk
, &i
->thread_info
.sample_spec
);
667 pa_volume_memchunk(&wchunk
, &i
->thread_info
.sample_spec
, &i
->thread_info
.soft_volume
);
670 if (!i
->thread_info
.resampler
)
671 pa_memblockq_push_align(i
->thread_info
.render_memblockq
, &wchunk
);
674 pa_resampler_run(i
->thread_info
.resampler
, &wchunk
, &rchunk
);
676 /* pa_log_debug("pushing %lu", (unsigned long) rchunk.length); */
678 if (rchunk
.memblock
) {
679 pa_memblockq_push_align(i
->thread_info
.render_memblockq
, &rchunk
);
680 pa_memblock_unref(rchunk
.memblock
);
684 pa_memblock_unref(wchunk
.memblock
);
686 tchunk
.index
+= wchunk
.length
;
687 tchunk
.length
-= wchunk
.length
;
690 pa_memblock_unref(tchunk
.memblock
);
693 pa_assert_se(pa_memblockq_peek(i
->thread_info
.render_memblockq
, chunk
) >= 0);
695 pa_assert(chunk
->length
> 0);
696 pa_assert(chunk
->memblock
);
698 /* pa_log_debug("peeking %lu", (unsigned long) chunk->length); */
700 if (chunk
->length
> block_size_max_sink
)
701 chunk
->length
= block_size_max_sink
;
703 /* Let's see if we had to apply the volume adjustment ourselves,
704 * or if this can be done by the sink for us */
706 if (do_volume_adj_here
)
707 /* We had different channel maps, so we already did the adjustment */
708 pa_cvolume_reset(volume
, i
->sink
->sample_spec
.channels
);
709 else if (i
->thread_info
.muted
)
710 /* We've both the same channel map, so let's have the sink do the adjustment for us*/
711 pa_cvolume_mute(volume
, i
->sink
->sample_spec
.channels
);
713 *volume
= i
->thread_info
.soft_volume
;
716 /* Called from thread context */
717 void pa_sink_input_drop(pa_sink_input
*i
, size_t nbytes
/* in sink sample spec */) {
718 pa_sink_input_assert_ref(i
);
720 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
));
721 pa_assert(pa_frame_aligned(nbytes
, &i
->sink
->sample_spec
));
722 pa_assert(nbytes
> 0);
724 /* pa_log_debug("dropping %lu", (unsigned long) nbytes); */
726 pa_memblockq_drop(i
->thread_info
.render_memblockq
, nbytes
);
729 /* Called from thread context */
730 void pa_sink_input_process_rewind(pa_sink_input
*i
, size_t nbytes
/* in sink sample spec */) {
732 pa_bool_t called
= FALSE
;
733 pa_sink_input_assert_ref(i
);
735 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
));
736 pa_assert(pa_frame_aligned(nbytes
, &i
->sink
->sample_spec
));
738 /* pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes); */
740 lbq
= pa_memblockq_get_length(i
->thread_info
.render_memblockq
);
742 if (nbytes
> 0 && !i
->thread_info
.dont_rewind_render
) {
743 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes
);
744 pa_memblockq_rewind(i
->thread_info
.render_memblockq
, nbytes
);
747 if (i
->thread_info
.rewrite_nbytes
== (size_t) -1) {
749 /* We were asked to drop all buffered data, and rerequest new
750 * data from implementor the next time push() is called */
752 pa_memblockq_flush_write(i
->thread_info
.render_memblockq
);
754 } else if (i
->thread_info
.rewrite_nbytes
> 0) {
755 size_t max_rewrite
, amount
;
757 /* Calculate how much make sense to rewrite at most */
758 max_rewrite
= nbytes
+ lbq
;
760 /* Transform into local domain */
761 if (i
->thread_info
.resampler
)
762 max_rewrite
= pa_resampler_request(i
->thread_info
.resampler
, max_rewrite
);
764 /* Calculate how much of the rewinded data should actually be rewritten */
765 amount
= PA_MIN(i
->thread_info
.rewrite_nbytes
, max_rewrite
);
768 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount
);
770 /* Tell the implementor */
771 if (i
->process_rewind
)
772 i
->process_rewind(i
, amount
);
775 /* Convert back to to sink domain */
776 if (i
->thread_info
.resampler
)
777 amount
= pa_resampler_result(i
->thread_info
.resampler
, amount
);
780 /* Ok, now update the write pointer */
781 pa_memblockq_seek(i
->thread_info
.render_memblockq
, - ((int64_t) amount
), PA_SEEK_RELATIVE
, TRUE
);
783 if (i
->thread_info
.rewrite_flush
)
784 pa_memblockq_silence(i
->thread_info
.render_memblockq
);
786 /* And reset the resampler */
787 if (i
->thread_info
.resampler
)
788 pa_resampler_reset(i
->thread_info
.resampler
);
793 if (i
->process_rewind
)
794 i
->process_rewind(i
, 0);
796 i
->thread_info
.rewrite_nbytes
= 0;
797 i
->thread_info
.rewrite_flush
= FALSE
;
798 i
->thread_info
.dont_rewind_render
= FALSE
;
801 /* Called from thread context */
802 void pa_sink_input_update_max_rewind(pa_sink_input
*i
, size_t nbytes
/* in the sink's sample spec */) {
803 pa_sink_input_assert_ref(i
);
804 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
));
805 pa_assert(pa_frame_aligned(nbytes
, &i
->sink
->sample_spec
));
807 pa_memblockq_set_maxrewind(i
->thread_info
.render_memblockq
, nbytes
);
809 if (i
->update_max_rewind
)
810 i
->update_max_rewind(i
, i
->thread_info
.resampler
? pa_resampler_request(i
->thread_info
.resampler
, nbytes
) : nbytes
);
813 /* Called from thread context */
814 void pa_sink_input_update_max_request(pa_sink_input
*i
, size_t nbytes
/* in the sink's sample spec */) {
815 pa_sink_input_assert_ref(i
);
816 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
));
817 pa_assert(pa_frame_aligned(nbytes
, &i
->sink
->sample_spec
));
819 if (i
->update_max_request
)
820 i
->update_max_request(i
, i
->thread_info
.resampler
? pa_resampler_request(i
->thread_info
.resampler
, nbytes
) : nbytes
);
823 /* Called from thread context */
824 pa_usec_t
pa_sink_input_set_requested_latency_within_thread(pa_sink_input
*i
, pa_usec_t usec
) {
825 pa_sink_input_assert_ref(i
);
827 if (usec
!= (pa_usec_t
) -1)
828 usec
= PA_CLAMP(usec
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
830 i
->thread_info
.requested_sink_latency
= usec
;
831 pa_sink_invalidate_requested_latency(i
->sink
);
836 /* Called from main context */
837 pa_usec_t
pa_sink_input_set_requested_latency(pa_sink_input
*i
, pa_usec_t usec
) {
838 pa_usec_t min_latency
, max_latency
;
840 pa_sink_input_assert_ref(i
);
842 if (PA_SINK_INPUT_IS_LINKED(i
->state
) && i
->sink
) {
843 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY
, &usec
, 0, NULL
) == 0);
847 /* If this sink input is not realized yet or we are being moved,
848 * we have to touch the thread info data directly */
851 pa_sink_get_latency_range(i
->sink
, &min_latency
, &max_latency
);
853 if (usec
!= (pa_usec_t
) -1)
854 usec
= PA_CLAMP(usec
, min_latency
, max_latency
);
857 i
->thread_info
.requested_sink_latency
= usec
;
862 /* Called from main context */
863 pa_usec_t
pa_sink_input_get_requested_latency(pa_sink_input
*i
) {
864 pa_sink_input_assert_ref(i
);
866 if (PA_SINK_INPUT_IS_LINKED(i
->state
) && i
->sink
) {
868 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY
, &usec
, 0, NULL
) == 0);
872 /* If this sink input is not realized yet or we are being moved,
873 * we have to touch the thread info data directly */
875 return i
->thread_info
.requested_sink_latency
;
878 /* Called from main context */
879 void pa_sink_input_set_volume(pa_sink_input
*i
, const pa_cvolume
*volume
, pa_bool_t save
) {
880 pa_sink_input_assert_ref(i
);
881 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
883 pa_assert(pa_cvolume_valid(volume
));
884 pa_assert(pa_cvolume_compatible(volume
, &i
->sample_spec
));
886 if (pa_cvolume_equal(volume
, &i
->virtual_volume
))
889 i
->virtual_volume
= *volume
;
890 i
->save_volume
= save
;
892 if (i
->sink
->flags
& PA_SINK_FLAT_VOLUME
) {
893 pa_cvolume new_volume
;
895 /* We are in flat volume mode, so let's update all sink input
896 * volumes and update the flat volume of the sink */
898 pa_sink_update_flat_volume(i
->sink
, &new_volume
);
899 pa_sink_set_volume(i
->sink
, &new_volume
, FALSE
, TRUE
);
903 /* OK, we are in normal volume mode. The volume only affects
905 pa_sink_input_set_relative_volume(i
, volume
);
907 /* Hooks have the ability to play games with i->soft_volume */
908 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME
], i
);
910 /* Copy the new soft_volume to the thread_info struct */
911 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME
, NULL
, 0, NULL
) == 0);
914 /* The virtual volume changed, let's tell people so */
915 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
918 /* Called from main context */
919 const pa_cvolume
*pa_sink_input_get_volume(pa_sink_input
*i
) {
920 pa_sink_input_assert_ref(i
);
921 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
923 return &i
->virtual_volume
;
926 /* Called from main context */
927 pa_cvolume
*pa_sink_input_get_relative_volume(pa_sink_input
*i
, pa_cvolume
*v
) {
930 pa_sink_input_assert_ref(i
);
932 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
934 /* This always returns a relative volume, even in flat volume mode */
936 v
->channels
= i
->sample_spec
.channels
;
938 for (c
= 0; c
< v
->channels
; c
++)
939 v
->values
[c
] = pa_sw_volume_from_linear(i
->relative_volume
[c
]);
944 /* Called from main context */
945 void pa_sink_input_set_relative_volume(pa_sink_input
*i
, const pa_cvolume
*v
) {
949 pa_sink_input_assert_ref(i
);
950 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
951 pa_assert(!v
|| pa_cvolume_compatible(v
, &i
->sample_spec
));
954 v
= pa_cvolume_reset(&_v
, i
->sample_spec
.channels
);
956 /* This basically calculates:
958 * i->relative_volume := v
959 * i->soft_volume := i->relative_volume * i->volume_factor */
961 i
->soft_volume
.channels
= i
->sample_spec
.channels
;
963 for (c
= 0; c
< i
->sample_spec
.channels
; c
++) {
964 i
->relative_volume
[c
] = pa_sw_volume_to_linear(v
->values
[c
]);
966 i
->soft_volume
.values
[c
] = pa_sw_volume_from_linear(
967 i
->relative_volume
[c
] *
968 pa_sw_volume_to_linear(i
->volume_factor
.values
[c
]));
971 /* We don't copy the data to the thread_info data. That's left for someone else to do */
974 /* Called from main context */
975 void pa_sink_input_set_mute(pa_sink_input
*i
, pa_bool_t mute
, pa_bool_t save
) {
977 pa_sink_input_assert_ref(i
);
978 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
980 if (!i
->muted
== !mute
)
984 i
->save_muted
= save
;
986 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE
, NULL
, 0, NULL
) == 0);
987 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
990 /* Called from main context */
991 pa_bool_t
pa_sink_input_get_mute(pa_sink_input
*i
) {
992 pa_sink_input_assert_ref(i
);
993 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
998 /* Called from main thread */
999 void pa_sink_input_update_proplist(pa_sink_input
*i
, pa_update_mode_t mode
, pa_proplist
*p
) {
1000 pa_sink_input_assert_ref(i
);
1003 pa_proplist_update(i
->proplist
, mode
, p
);
1005 if (PA_SINK_IS_LINKED(i
->state
)) {
1006 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED
], i
);
1007 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1011 /* Called from main context */
1012 void pa_sink_input_cork(pa_sink_input
*i
, pa_bool_t b
) {
1013 pa_sink_input_assert_ref(i
);
1014 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1016 sink_input_set_state(i
, b
? PA_SINK_INPUT_CORKED
: PA_SINK_INPUT_RUNNING
);
1019 /* Called from main context */
1020 int pa_sink_input_set_rate(pa_sink_input
*i
, uint32_t rate
) {
1021 pa_sink_input_assert_ref(i
);
1022 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1023 pa_return_val_if_fail(i
->thread_info
.resampler
, -PA_ERR_BADSTATE
);
1025 if (i
->sample_spec
.rate
== rate
)
1028 i
->sample_spec
.rate
= rate
;
1030 pa_asyncmsgq_post(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
), PA_SINK_INPUT_MESSAGE_SET_RATE
, PA_UINT_TO_PTR(rate
), 0, NULL
, NULL
);
1032 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1036 /* Called from main context */
1037 void pa_sink_input_set_name(pa_sink_input
*i
, const char *name
) {
1039 pa_sink_input_assert_ref(i
);
1041 if (!name
&& !pa_proplist_contains(i
->proplist
, PA_PROP_MEDIA_NAME
))
1044 old
= pa_proplist_gets(i
->proplist
, PA_PROP_MEDIA_NAME
);
1046 if (old
&& name
&& !strcmp(old
, name
))
1050 pa_proplist_sets(i
->proplist
, PA_PROP_MEDIA_NAME
, name
);
1052 pa_proplist_unset(i
->proplist
, PA_PROP_MEDIA_NAME
);
1054 if (PA_SINK_INPUT_IS_LINKED(i
->state
)) {
1055 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED
], i
);
1056 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1060 /* Called from main context */
1061 pa_resample_method_t
pa_sink_input_get_resample_method(pa_sink_input
*i
) {
1062 pa_sink_input_assert_ref(i
);
1064 return i
->actual_resample_method
;
1067 /* Called from main context */
1068 pa_bool_t
pa_sink_input_may_move(pa_sink_input
*i
) {
1069 pa_sink_input_assert_ref(i
);
1070 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1072 if (i
->flags
& PA_SINK_INPUT_DONT_MOVE
)
1075 if (i
->sync_next
|| i
->sync_prev
) {
1076 pa_log_warn("Moving synchronised streams not supported.");
1083 /* Called from main context */
1084 pa_bool_t
pa_sink_input_may_move_to(pa_sink_input
*i
, pa_sink
*dest
) {
1085 pa_sink_input_assert_ref(i
);
1086 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1087 pa_sink_assert_ref(dest
);
1089 if (dest
== i
->sink
)
1092 if (!pa_sink_input_may_move(i
))
1095 if (pa_idxset_size(dest
->inputs
) >= PA_MAX_INPUTS_PER_SINK
) {
1096 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1101 if (!i
->may_move_to(i
, dest
))
1107 /* Called from main context */
1108 int pa_sink_input_start_move(pa_sink_input
*i
) {
1109 pa_source_output
*o
, *p
= NULL
;
1113 pa_sink_input_assert_ref(i
);
1114 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1117 if (!pa_sink_input_may_move(i
))
1118 return -PA_ERR_NOTSUPPORTED
;
1120 if ((r
= pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_MOVE_START
], i
)) < 0)
1125 /* Kill directly connected outputs */
1126 while ((o
= pa_idxset_first(i
->direct_outputs
, NULL
))) {
1128 pa_source_output_kill(o
);
1131 pa_assert(pa_idxset_isempty(i
->direct_outputs
));
1133 pa_idxset_remove_by_data(i
->sink
->inputs
, i
, NULL
);
1135 if (pa_sink_input_get_state(i
) == PA_SINK_INPUT_CORKED
)
1136 pa_assert_se(i
->sink
->n_corked
-- >= 1);
1138 if (i
->sink
->flags
& PA_SINK_FLAT_VOLUME
) {
1139 pa_cvolume new_volume
;
1141 /* Make the virtual volume relative */
1142 pa_sink_input_get_relative_volume(i
, &i
->virtual_volume
);
1144 /* And reset the the relative volume */
1145 pa_sink_input_set_relative_volume(i
, NULL
);
1147 /* We might need to update the sink's volume if we are in flat
1149 pa_sink_update_flat_volume(i
->sink
, &new_volume
);
1150 pa_sink_set_volume(i
->sink
, &new_volume
, FALSE
, FALSE
);
1153 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
->sink
), PA_SINK_MESSAGE_START_MOVE
, i
, 0, NULL
) == 0);
1155 pa_sink_update_status(i
->sink
);
1158 pa_sink_input_unref(i
);
1163 /* Called from main context */
1164 int pa_sink_input_finish_move(pa_sink_input
*i
, pa_sink
*dest
, pa_bool_t save
) {
1165 pa_resampler
*new_resampler
;
1167 pa_sink_input_assert_ref(i
);
1168 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1169 pa_assert(!i
->sink
);
1170 pa_sink_assert_ref(dest
);
1172 if (!pa_sink_input_may_move_to(i
, dest
))
1173 return -PA_ERR_NOTSUPPORTED
;
1175 if (i
->thread_info
.resampler
&&
1176 pa_sample_spec_equal(pa_resampler_output_sample_spec(i
->thread_info
.resampler
), &dest
->sample_spec
) &&
1177 pa_channel_map_equal(pa_resampler_output_channel_map(i
->thread_info
.resampler
), &dest
->channel_map
))
1179 /* Try to reuse the old resampler if possible */
1180 new_resampler
= i
->thread_info
.resampler
;
1182 else if ((i
->flags
& PA_SINK_INPUT_VARIABLE_RATE
) ||
1183 !pa_sample_spec_equal(&i
->sample_spec
, &dest
->sample_spec
) ||
1184 !pa_channel_map_equal(&i
->channel_map
, &dest
->channel_map
)) {
1186 /* Okey, we need a new resampler for the new sink */
1188 if (!(new_resampler
= pa_resampler_new(
1190 &i
->sample_spec
, &i
->channel_map
,
1191 &dest
->sample_spec
, &dest
->channel_map
,
1192 i
->requested_resample_method
,
1193 ((i
->flags
& PA_SINK_INPUT_VARIABLE_RATE
) ? PA_RESAMPLER_VARIABLE_RATE
: 0) |
1194 ((i
->flags
& PA_SINK_INPUT_NO_REMAP
) ? PA_RESAMPLER_NO_REMAP
: 0) |
1195 (i
->core
->disable_remixing
|| (i
->flags
& PA_SINK_INPUT_NO_REMIX
) ? PA_RESAMPLER_NO_REMIX
: 0)))) {
1196 pa_log_warn("Unsupported resampling operation.");
1197 return -PA_ERR_NOTSUPPORTED
;
1200 new_resampler
= NULL
;
1206 i
->save_sink
= save
;
1207 pa_idxset_put(dest
->inputs
, pa_sink_input_ref(i
), NULL
);
1209 if (pa_sink_input_get_state(i
) == PA_SINK_INPUT_CORKED
)
1210 i
->sink
->n_corked
++;
1212 /* Replace resampler and render queue */
1213 if (new_resampler
!= i
->thread_info
.resampler
) {
1215 if (i
->thread_info
.resampler
)
1216 pa_resampler_free(i
->thread_info
.resampler
);
1217 i
->thread_info
.resampler
= new_resampler
;
1219 pa_memblockq_free(i
->thread_info
.render_memblockq
);
1221 i
->thread_info
.render_memblockq
= pa_memblockq_new(
1223 MEMBLOCKQ_MAXLENGTH
,
1225 pa_frame_size(&i
->sink
->sample_spec
),
1231 pa_sink_update_status(dest
);
1233 if (i
->sink
->flags
& PA_SINK_FLAT_VOLUME
) {
1234 pa_cvolume new_volume
;
1236 /* Make relative volume absolute again */
1237 pa_cvolume t
= dest
->virtual_volume
;
1238 pa_cvolume_remap(&t
, &dest
->channel_map
, &i
->channel_map
);
1239 pa_sw_cvolume_multiply(&i
->virtual_volume
, &i
->virtual_volume
, &t
);
1241 /* We might need to update the sink's volume if we are in flat volume mode. */
1242 pa_sink_update_flat_volume(i
->sink
, &new_volume
);
1243 pa_sink_set_volume(i
->sink
, &new_volume
, FALSE
, FALSE
);
1246 pa_assert_se(pa_asyncmsgq_send(i
->sink
->asyncmsgq
, PA_MSGOBJECT(i
->sink
), PA_SINK_MESSAGE_FINISH_MOVE
, i
, 0, NULL
) == 0);
1248 pa_log_debug("Successfully moved sink input %i to %s.", i
->index
, dest
->name
);
1250 /* Notify everyone */
1251 pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH
], i
);
1252 pa_subscription_post(i
->core
, PA_SUBSCRIPTION_EVENT_SINK_INPUT
|PA_SUBSCRIPTION_EVENT_CHANGE
, i
->index
);
1257 /* Called from main context */
1258 int pa_sink_input_move_to(pa_sink_input
*i
, pa_sink
*dest
, pa_bool_t save
) {
1261 pa_sink_input_assert_ref(i
);
1262 pa_assert(PA_SINK_INPUT_IS_LINKED(i
->state
));
1264 pa_sink_assert_ref(dest
);
1266 if (dest
== i
->sink
)
1269 if (!pa_sink_input_may_move_to(i
, dest
))
1270 return -PA_ERR_NOTSUPPORTED
;
1272 pa_sink_input_ref(i
);
1274 if ((r
= pa_sink_input_start_move(i
)) < 0) {
1275 pa_sink_input_unref(i
);
1279 if ((r
= pa_sink_input_finish_move(i
, dest
, save
)) < 0) {
1280 pa_sink_input_unref(i
);
1284 pa_sink_input_unref(i
);
1289 /* Called from IO thread context */
1290 void pa_sink_input_set_state_within_thread(pa_sink_input
*i
, pa_sink_input_state_t state
) {
1291 pa_bool_t corking
, uncorking
;
1292 pa_sink_input_assert_ref(i
);
1294 if (state
== i
->thread_info
.state
)
1297 if ((state
== PA_SINK_INPUT_DRAINED
|| state
== PA_SINK_INPUT_RUNNING
) &&
1298 !(i
->thread_info
.state
== PA_SINK_INPUT_DRAINED
|| i
->thread_info
.state
!= PA_SINK_INPUT_RUNNING
))
1299 pa_atomic_store(&i
->thread_info
.drained
, 1);
1301 corking
= state
== PA_SINK_INPUT_CORKED
&& i
->thread_info
.state
== PA_SINK_INPUT_RUNNING
;
1302 uncorking
= i
->thread_info
.state
== PA_SINK_INPUT_CORKED
&& state
== PA_SINK_INPUT_RUNNING
;
1304 if (i
->state_change
)
1305 i
->state_change(i
, state
);
1307 i
->thread_info
.state
= state
;
1311 pa_log_debug("Requesting rewind due to corking");
1313 /* This will tell the implementing sink input driver to rewind
1314 * so that the unplayed already mixed data is not lost */
1315 pa_sink_input_request_rewind(i
, 0, TRUE
, TRUE
, FALSE
);
1317 } else if (uncorking
) {
1319 i
->thread_info
.underrun_for
= (uint64_t) -1;
1320 i
->thread_info
.playing_for
= 0;
1322 pa_log_debug("Requesting rewind due to uncorking");
1324 /* OK, we're being uncorked. Make sure we're not rewound when
1325 * the hw buffer is remixed and request a remix. */
1326 pa_sink_input_request_rewind(i
, 0, FALSE
, TRUE
, TRUE
);
1330 /* Called from thread context, except when it is not. */
1331 int pa_sink_input_process_msg(pa_msgobject
*o
, int code
, void *userdata
, int64_t offset
, pa_memchunk
*chunk
) {
1332 pa_sink_input
*i
= PA_SINK_INPUT(o
);
1333 pa_sink_input_assert_ref(i
);
1337 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME
:
1338 if (!pa_cvolume_equal(&i
->thread_info
.soft_volume
, &i
->soft_volume
)) {
1339 i
->thread_info
.soft_volume
= i
->soft_volume
;
1340 pa_sink_input_request_rewind(i
, 0, TRUE
, FALSE
, FALSE
);
1344 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE
:
1345 if (i
->thread_info
.muted
!= i
->muted
) {
1346 i
->thread_info
.muted
= i
->muted
;
1347 pa_sink_input_request_rewind(i
, 0, TRUE
, FALSE
, FALSE
);
1351 case PA_SINK_INPUT_MESSAGE_GET_LATENCY
: {
1352 pa_usec_t
*r
= userdata
;
1353 pa_usec_t sink_usec
= 0;
1355 r
[0] += pa_bytes_to_usec(pa_memblockq_get_length(i
->thread_info
.render_memblockq
), &i
->sink
->sample_spec
);
1357 if (i
->sink
->parent
.process_msg(PA_MSGOBJECT(i
->sink
), PA_SINK_MESSAGE_GET_LATENCY
, &sink_usec
, 0, NULL
) >= 0)
1363 case PA_SINK_INPUT_MESSAGE_SET_RATE
:
1365 i
->thread_info
.sample_spec
.rate
= PA_PTR_TO_UINT(userdata
);
1366 pa_resampler_set_input_rate(i
->thread_info
.resampler
, PA_PTR_TO_UINT(userdata
));
1370 case PA_SINK_INPUT_MESSAGE_SET_STATE
: {
1371 pa_sink_input
*ssync
;
1373 pa_sink_input_set_state_within_thread(i
, PA_PTR_TO_UINT(userdata
));
1375 for (ssync
= i
->thread_info
.sync_prev
; ssync
; ssync
= ssync
->thread_info
.sync_prev
)
1376 pa_sink_input_set_state_within_thread(ssync
, PA_PTR_TO_UINT(userdata
));
1378 for (ssync
= i
->thread_info
.sync_next
; ssync
; ssync
= ssync
->thread_info
.sync_next
)
1379 pa_sink_input_set_state_within_thread(ssync
, PA_PTR_TO_UINT(userdata
));
1384 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY
: {
1385 pa_usec_t
*usec
= userdata
;
1387 *usec
= pa_sink_input_set_requested_latency_within_thread(i
, *usec
);
1391 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY
: {
1392 pa_usec_t
*r
= userdata
;
1394 *r
= i
->thread_info
.requested_sink_latency
;
1399 return -PA_ERR_NOTIMPLEMENTED
;
1402 /* Called from main thread */
1403 pa_sink_input_state_t
pa_sink_input_get_state(pa_sink_input
*i
) {
1404 pa_sink_input_assert_ref(i
);
1406 if (i
->state
== PA_SINK_INPUT_RUNNING
|| i
->state
== PA_SINK_INPUT_DRAINED
)
1407 return pa_atomic_load(&i
->thread_info
.drained
) ? PA_SINK_INPUT_DRAINED
: PA_SINK_INPUT_RUNNING
;
1412 /* Called from IO context */
1413 pa_bool_t
pa_sink_input_safe_to_remove(pa_sink_input
*i
) {
1414 pa_sink_input_assert_ref(i
);
1416 if (PA_SINK_INPUT_IS_LINKED(i
->thread_info
.state
))
1417 return pa_memblockq_is_empty(i
->thread_info
.render_memblockq
);
1422 /* Called from IO context */
1423 void pa_sink_input_request_rewind(pa_sink_input
*i
, size_t nbytes
/* in our sample spec */, pa_bool_t rewrite
, pa_bool_t flush
, pa_bool_t dont_rewind_render
) {
1426 /* If 'rewrite' is TRUE the sink is rewound as far as requested
1427 * and possible and the exact value of this is passed back the
1428 * implementor via process_rewind(). If 'flush' is also TRUE all
1429 * already rendered data is also dropped.
1431 * If 'rewrite' is FALSE the sink is rewound as far as requested
1432 * and possible and the already rendered data is dropped so that
1433 * in the next iteration we read new data from the
1434 * implementor. This implies 'flush' is TRUE. If
1435 * dont_rewind_render is TRUE then the render memblockq is not
1438 pa_sink_input_assert_ref(i
);
1440 nbytes
= PA_MAX(i
->thread_info
.rewrite_nbytes
, nbytes
);
1442 /* pa_log_debug("request rewrite %lu", (unsigned long) nbytes); */
1444 /* We don't take rewind requests while we are corked */
1445 if (i
->thread_info
.state
== PA_SINK_INPUT_CORKED
)
1448 pa_assert(rewrite
|| flush
);
1449 pa_assert(!dont_rewind_render
|| !rewrite
);
1451 /* Calculate how much we can rewind locally without having to
1454 lbq
= pa_memblockq_get_length(i
->thread_info
.render_memblockq
);
1458 /* Check if rewinding for the maximum is requested, and if so, fix up */
1461 /* Calculate maximum number of bytes that could be rewound in theory */
1462 nbytes
= i
->sink
->thread_info
.max_rewind
+ lbq
;
1464 /* Transform from sink domain */
1465 if (i
->thread_info
.resampler
)
1466 nbytes
= pa_resampler_request(i
->thread_info
.resampler
, nbytes
);
1469 if (i
->thread_info
.rewrite_nbytes
!= (size_t) -1) {
1471 /* Make sure to not overwrite over underruns */
1472 if (nbytes
> i
->thread_info
.playing_for
)
1473 nbytes
= (size_t) i
->thread_info
.playing_for
;
1475 i
->thread_info
.rewrite_nbytes
= nbytes
;
1477 i
->thread_info
.rewrite_nbytes
= (size_t) -1;
1480 i
->thread_info
.rewrite_flush
=
1481 i
->thread_info
.rewrite_flush
||
1482 (flush
&& i
->thread_info
.rewrite_nbytes
!= 0);
1484 i
->thread_info
.dont_rewind_render
=
1485 i
->thread_info
.dont_rewind_render
||
1488 if (nbytes
!= (size_t) -1) {
1490 /* Transform to sink domain */
1491 if (i
->thread_info
.resampler
)
1492 nbytes
= pa_resampler_result(i
->thread_info
.resampler
, nbytes
);
1495 pa_sink_request_rewind(i
->sink
, nbytes
- lbq
);
1497 /* This call will make sure process_rewind() is called later */
1498 pa_sink_request_rewind(i
->sink
, 0);
1502 /* Called from main context */
1503 pa_memchunk
* pa_sink_input_get_silence(pa_sink_input
*i
, pa_memchunk
*ret
) {
1504 pa_sink_input_assert_ref(i
);
1507 pa_silence_memchunk_get(
1508 &i
->core
->silence_cache
,
1512 i
->thread_info
.resampler
? pa_resampler_max_block_size(i
->thread_info
.resampler
) : 0);
1517 /* Called from main context */
1518 void pa_sink_input_send_event(pa_sink_input
*i
, const char *event
, pa_proplist
*data
) {
1519 pa_proplist
*pl
= NULL
;
1520 pa_sink_input_send_event_hook_data hook_data
;
1522 pa_sink_input_assert_ref(i
);
1529 data
= pl
= pa_proplist_new();
1531 hook_data
.sink_input
= i
;
1532 hook_data
.data
= data
;
1533 hook_data
.event
= event
;
1535 if (pa_hook_fire(&i
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT
], &hook_data
) < 0)
1538 i
->send_event(i
, event
, data
);
1542 pa_proplist_free(pl
);