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) {
179 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
180 data->volume_is_absolute = FALSE;
181 data->save_volume = FALSE;
184 pa_return_val_if_fail(pa_cvolume_valid(&data->volume), -PA_ERR_INVALID);
185 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec), -PA_ERR_INVALID);
187 if (!data->volume_factor_is_set)
188 pa_cvolume_reset(&data->volume_factor, data->sample_spec.channels);
190 pa_return_val_if_fail(pa_cvolume_valid(&data->volume_factor), -PA_ERR_INVALID);
191 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume_factor, &data->sample_spec), -PA_ERR_INVALID);
193 if (!data->muted_is_set)
196 if (flags & PA_SINK_INPUT_FIX_FORMAT)
197 data->sample_spec.format = data->sink->sample_spec.format;
199 if (flags & PA_SINK_INPUT_FIX_RATE)
200 data->sample_spec.rate = data->sink->sample_spec.rate;
202 original_cm = data->channel_map;
204 if (flags & PA_SINK_INPUT_FIX_CHANNELS) {
205 data->sample_spec.channels = data->sink->sample_spec.channels;
206 data->channel_map = data->sink->channel_map;
209 pa_assert(pa_sample_spec_valid(&data->sample_spec));
210 pa_assert(pa_channel_map_valid(&data->channel_map));
212 /* Due to the fixing of the sample spec the volume might not match anymore */
213 pa_cvolume_remap(&data->volume, &original_cm, &data->channel_map);
215 if (data->resample_method == PA_RESAMPLER_INVALID)
216 data->resample_method = core->resample_method;
218 pa_return_val_if_fail(data->resample_method < PA_RESAMPLER_MAX, -PA_ERR_INVALID);
220 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], data)) < 0)
223 if ((flags & PA_SINK_INPUT_FAIL_ON_SUSPEND) &&
224 pa_sink_get_state(data->sink) == PA_SINK_SUSPENDED) {
225 pa_log_warn("Failed to create sink input: sink is suspended.");
226 return -PA_ERR_BADSTATE;
229 if (pa_idxset_size(data->sink->inputs) >= PA_MAX_INPUTS_PER_SINK) {
230 pa_log_warn("Failed to create sink input: too many inputs per sink.");
231 return -PA_ERR_TOOLARGE;
234 if ((flags & PA_SINK_INPUT_VARIABLE_RATE) ||
235 !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec) ||
236 !pa_channel_map_equal(&data->channel_map, &data->sink->channel_map)) {
238 if (!(resampler = pa_resampler_new(
240 &data->sample_spec, &data->channel_map,
241 &data->sink->sample_spec, &data->sink->channel_map,
242 data->resample_method,
243 ((flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
244 ((flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
245 (core->disable_remixing || (flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0) |
246 (core->disable_lfe_remixing ? PA_RESAMPLER_NO_LFE : 0)))) {
247 pa_log_warn("Unsupported resampling operation.");
248 return -PA_ERR_NOTSUPPORTED;
252 i = pa_msgobject_new(pa_sink_input);
253 i->parent.parent.free = sink_input_free;
254 i->parent.process_msg = pa_sink_input_process_msg;
257 i->state = PA_SINK_INPUT_INIT;
259 i->proplist = pa_proplist_copy(data->proplist);
260 i->driver = pa_xstrdup(pa_path_get_filename(data->driver));
261 i->module = data->module;
262 i->sink = data->sink;
263 i->client = data->client;
265 i->requested_resample_method = data->resample_method;
266 i->actual_resample_method = resampler ? pa_resampler_get_method(resampler) : PA_RESAMPLER_INVALID;
267 i->sample_spec = data->sample_spec;
268 i->channel_map = data->channel_map;
270 if ((i->sink->flags & PA_SINK_FLAT_VOLUME) && !data->volume_is_absolute) {
271 /* When the 'absolute' bool is not set then we'll treat the volume
272 * as relative to the sink volume even in flat volume mode */
274 pa_cvolume v = data->sink->reference_volume;
275 pa_cvolume_remap(&v, &data->sink->channel_map, &data->channel_map);
276 pa_sw_cvolume_multiply(&i->virtual_volume, &data->volume, &v);
278 i->virtual_volume = data->volume;
280 i->volume_factor = data->volume_factor;
281 pa_cvolume_init(&i->soft_volume);
282 memset(i->relative_volume, 0, sizeof(i->relative_volume));
283 i->save_volume = data->save_volume;
284 i->save_sink = data->save_sink;
285 i->save_muted = data->save_muted;
287 i->muted = data->muted;
289 if (data->sync_base) {
290 i->sync_next = data->sync_base->sync_next;
291 i->sync_prev = data->sync_base;
293 if (data->sync_base->sync_next)
294 data->sync_base->sync_next->sync_prev = i;
295 data->sync_base->sync_next = i;
297 i->sync_next = i->sync_prev = NULL;
299 i->direct_outputs = pa_idxset_new(NULL, NULL);
304 i->thread_info.state = i->state;
305 i->thread_info.attached = FALSE;
306 pa_atomic_store(&i->thread_info.drained, 1);
307 i->thread_info.sample_spec = i->sample_spec;
308 i->thread_info.resampler = resampler;
309 i->thread_info.soft_volume = i->soft_volume;
310 i->thread_info.muted = i->muted;
311 i->thread_info.requested_sink_latency = (pa_usec_t) -1;
312 i->thread_info.rewrite_nbytes = 0;
313 i->thread_info.rewrite_flush = FALSE;
314 i->thread_info.dont_rewind_render = FALSE;
315 i->thread_info.underrun_for = (uint64_t) -1;
316 i->thread_info.playing_for = 0;
317 i->thread_info.direct_outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
319 i->thread_info.render_memblockq = pa_memblockq_new(
323 pa_frame_size(&i->sink->sample_spec),
329 pa_assert_se(pa_idxset_put(core->sink_inputs, i, &i->index) == 0);
330 pa_assert_se(pa_idxset_put(i->sink->inputs, pa_sink_input_ref(i), NULL) == 0);
333 pa_assert_se(pa_idxset_put(i->client->sink_inputs, i, NULL) >= 0);
335 pa_log_info("Created input %u \"%s\" on %s with sample spec %s and channel map %s",
337 pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)),
339 pa_sample_spec_snprint(st, sizeof(st), &i->sample_spec),
340 pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map));
342 /* Don't forget to call pa_sink_input_put! */
348 /* Called from main context */
349 static void update_n_corked(pa_sink_input *i, pa_sink_input_state_t state) {
355 if (i->state == PA_SINK_INPUT_CORKED && state != PA_SINK_INPUT_CORKED)
356 pa_assert_se(i->sink->n_corked -- >= 1);
357 else if (i->state != PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_CORKED)
361 /* Called from main context */
362 static void sink_input_set_state(pa_sink_input *i, pa_sink_input_state_t state) {
363 pa_sink_input *ssync;
366 if (state == PA_SINK_INPUT_DRAINED)
367 state = PA_SINK_INPUT_RUNNING;
369 if (i->state == state)
372 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);
374 update_n_corked(i, state);
377 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev) {
378 update_n_corked(ssync, state);
379 ssync->state = state;
381 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next) {
382 update_n_corked(ssync, state);
383 ssync->state = state;
386 if (state != PA_SINK_INPUT_UNLINKED) {
387 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], i);
389 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev)
390 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
392 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next)
393 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
396 pa_sink_update_status(i->sink);
399 /* Called from main context */
400 void pa_sink_input_unlink(pa_sink_input *i) {
402 pa_source_output *o, *p = NULL;
405 /* See pa_sink_unlink() for a couple of comments how this function
408 pa_sink_input_ref(i);
410 linked = PA_SINK_INPUT_IS_LINKED(i->state);
413 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], i);
416 i->sync_prev->sync_next = i->sync_next;
418 i->sync_next->sync_prev = i->sync_prev;
420 i->sync_prev = i->sync_next = NULL;
422 pa_idxset_remove_by_data(i->core->sink_inputs, i, NULL);
425 if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL))
426 pa_sink_input_unref(i);
429 pa_idxset_remove_by_data(i->client->sink_inputs, i, NULL);
431 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
433 pa_source_output_kill(o);
437 update_n_corked(i, PA_SINK_INPUT_UNLINKED);
438 i->state = PA_SINK_INPUT_UNLINKED;
440 if (linked && i->sink) {
441 /* We might need to update the sink's volume if we are in flat volume mode. */
442 if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
443 pa_cvolume new_volume;
444 pa_sink_update_flat_volume(i->sink, &new_volume);
445 pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE, FALSE);
448 if (i->sink->asyncmsgq)
449 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_REMOVE_INPUT, i, 0, NULL) == 0);
455 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_REMOVE, i->index);
456 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST], i);
460 pa_sink_update_status(i->sink);
464 pa_core_maybe_vacuum(i->core);
466 pa_sink_input_unref(i);
469 /* Called from main context */
470 static void sink_input_free(pa_object *o) {
471 pa_sink_input* i = PA_SINK_INPUT(o);
474 pa_assert(pa_sink_input_refcnt(i) == 0);
476 if (PA_SINK_INPUT_IS_LINKED(i->state))
477 pa_sink_input_unlink(i);
479 pa_log_info("Freeing input %u \"%s\"", i->index, pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)));
481 pa_assert(!i->thread_info.attached);
483 if (i->thread_info.render_memblockq)
484 pa_memblockq_free(i->thread_info.render_memblockq);
486 if (i->thread_info.resampler)
487 pa_resampler_free(i->thread_info.resampler);
490 pa_proplist_free(i->proplist);
492 if (i->direct_outputs)
493 pa_idxset_free(i->direct_outputs, NULL, NULL);
495 if (i->thread_info.direct_outputs)
496 pa_hashmap_free(i->thread_info.direct_outputs, NULL, NULL);
502 /* Called from main context */
503 void pa_sink_input_put(pa_sink_input *i) {
504 pa_sink_input_state_t state;
505 pa_sink_input_assert_ref(i);
507 pa_assert(i->state == PA_SINK_INPUT_INIT);
509 /* The following fields must be initialized properly */
511 pa_assert(i->process_rewind);
514 state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING;
516 update_n_corked(i, state);
519 /* We might need to update the sink's volume if we are in flat volume mode. */
520 if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
521 pa_cvolume new_volume;
522 pa_sink_update_flat_volume(i->sink, &new_volume);
523 pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE, FALSE);
525 pa_sink_input_set_relative_volume(i, &i->virtual_volume);
527 i->thread_info.soft_volume = i->soft_volume;
528 i->thread_info.muted = i->muted;
530 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_ADD_INPUT, i, 0, NULL) == 0);
532 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, i->index);
533 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], i);
535 pa_sink_update_status(i->sink);
538 /* Called from main context */
539 void pa_sink_input_kill(pa_sink_input*i) {
540 pa_sink_input_assert_ref(i);
541 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
546 /* Called from main context */
547 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency) {
548 pa_usec_t r[2] = { 0, 0 };
550 pa_sink_input_assert_ref(i);
551 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
553 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_LATENCY, r, 0, NULL) == 0);
556 r[0] += i->get_latency(i);
559 *sink_latency = r[1];
564 /* Called from thread context */
565 void pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink frames */, pa_memchunk *chunk, pa_cvolume *volume) {
566 pa_bool_t do_volume_adj_here;
567 pa_bool_t volume_is_norm;
568 size_t block_size_max_sink, block_size_max_sink_input;
571 pa_sink_input_assert_ref(i);
572 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
573 pa_assert(pa_frame_aligned(slength, &i->sink->sample_spec));
577 /* pa_log_debug("peek"); */
579 pa_assert(i->thread_info.state == PA_SINK_INPUT_RUNNING ||
580 i->thread_info.state == PA_SINK_INPUT_CORKED ||
581 i->thread_info.state == PA_SINK_INPUT_DRAINED);
583 block_size_max_sink_input = i->thread_info.resampler ?
584 pa_resampler_max_block_size(i->thread_info.resampler) :
585 pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sample_spec);
587 block_size_max_sink = pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sink->sample_spec);
589 /* Default buffer size */
591 slength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sink->sample_spec);
593 if (slength > block_size_max_sink)
594 slength = block_size_max_sink;
596 if (i->thread_info.resampler) {
597 ilength = pa_resampler_request(i->thread_info.resampler, slength);
600 ilength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sample_spec);
604 if (ilength > block_size_max_sink_input)
605 ilength = block_size_max_sink_input;
607 /* If the channel maps of the sink and this stream differ, we need
608 * to adjust the volume *before* we resample. Otherwise we can do
609 * it after and leave it for the sink code */
611 do_volume_adj_here = !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map);
612 volume_is_norm = pa_cvolume_is_norm(&i->thread_info.soft_volume) && !i->thread_info.muted;
614 while (!pa_memblockq_is_readable(i->thread_info.render_memblockq)) {
617 /* There's nothing in our render queue. We need to fill it up
618 * with data from the implementor. */
620 if (i->thread_info.state == PA_SINK_INPUT_CORKED ||
621 i->pop(i, ilength, &tchunk) < 0) {
623 /* OK, we're corked or the implementor didn't give us any
624 * data, so let's just hand out silence */
625 pa_atomic_store(&i->thread_info.drained, 1);
627 pa_memblockq_seek(i->thread_info.render_memblockq, (int64_t) slength, PA_SEEK_RELATIVE, TRUE);
628 i->thread_info.playing_for = 0;
629 if (i->thread_info.underrun_for != (uint64_t) -1)
630 i->thread_info.underrun_for += ilength;
634 pa_atomic_store(&i->thread_info.drained, 0);
636 pa_assert(tchunk.length > 0);
637 pa_assert(tchunk.memblock);
639 i->thread_info.underrun_for = 0;
640 i->thread_info.playing_for += tchunk.length;
642 while (tchunk.length > 0) {
646 pa_memblock_ref(wchunk.memblock);
648 if (wchunk.length > block_size_max_sink_input)
649 wchunk.length = block_size_max_sink_input;
651 /* It might be necessary to adjust the volume here */
652 if (do_volume_adj_here && !volume_is_norm) {
653 pa_memchunk_make_writable(&wchunk, 0);
655 if (i->thread_info.muted)
656 pa_silence_memchunk(&wchunk, &i->thread_info.sample_spec);
658 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.soft_volume);
661 if (!i->thread_info.resampler)
662 pa_memblockq_push_align(i->thread_info.render_memblockq, &wchunk);
665 pa_resampler_run(i->thread_info.resampler, &wchunk, &rchunk);
667 /* pa_log_debug("pushing %lu", (unsigned long) rchunk.length); */
669 if (rchunk.memblock) {
670 pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk);
671 pa_memblock_unref(rchunk.memblock);
675 pa_memblock_unref(wchunk.memblock);
677 tchunk.index += wchunk.length;
678 tchunk.length -= wchunk.length;
681 pa_memblock_unref(tchunk.memblock);
684 pa_assert_se(pa_memblockq_peek(i->thread_info.render_memblockq, chunk) >= 0);
686 pa_assert(chunk->length > 0);
687 pa_assert(chunk->memblock);
689 /* pa_log_debug("peeking %lu", (unsigned long) chunk->length); */
691 if (chunk->length > block_size_max_sink)
692 chunk->length = block_size_max_sink;
694 /* Let's see if we had to apply the volume adjustment ourselves,
695 * or if this can be done by the sink for us */
697 if (do_volume_adj_here)
698 /* We had different channel maps, so we already did the adjustment */
699 pa_cvolume_reset(volume, i->sink->sample_spec.channels);
700 else if (i->thread_info.muted)
701 /* We've both the same channel map, so let's have the sink do the adjustment for us*/
702 pa_cvolume_mute(volume, i->sink->sample_spec.channels);
704 *volume = i->thread_info.soft_volume;
707 /* Called from thread context */
708 void pa_sink_input_drop(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
709 pa_sink_input_assert_ref(i);
711 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
712 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
713 pa_assert(nbytes > 0);
715 /* pa_log_debug("dropping %lu", (unsigned long) nbytes); */
717 pa_memblockq_drop(i->thread_info.render_memblockq, nbytes);
720 /* Called from thread context */
721 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
723 pa_bool_t called = FALSE;
724 pa_sink_input_assert_ref(i);
726 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
727 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
729 /* pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes); */
731 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
733 if (nbytes > 0 && !i->thread_info.dont_rewind_render) {
734 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes);
735 pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes);
738 if (i->thread_info.rewrite_nbytes == (size_t) -1) {
740 /* We were asked to drop all buffered data, and rerequest new
741 * data from implementor the next time push() is called */
743 pa_memblockq_flush_write(i->thread_info.render_memblockq);
745 } else if (i->thread_info.rewrite_nbytes > 0) {
746 size_t max_rewrite, amount;
748 /* Calculate how much make sense to rewrite at most */
749 max_rewrite = nbytes + lbq;
751 /* Transform into local domain */
752 if (i->thread_info.resampler)
753 max_rewrite = pa_resampler_request(i->thread_info.resampler, max_rewrite);
755 /* Calculate how much of the rewinded data should actually be rewritten */
756 amount = PA_MIN(i->thread_info.rewrite_nbytes, max_rewrite);
759 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount);
761 /* Tell the implementor */
762 if (i->process_rewind)
763 i->process_rewind(i, amount);
766 /* Convert back to to sink domain */
767 if (i->thread_info.resampler)
768 amount = pa_resampler_result(i->thread_info.resampler, amount);
771 /* Ok, now update the write pointer */
772 pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) amount), PA_SEEK_RELATIVE, TRUE);
774 if (i->thread_info.rewrite_flush)
775 pa_memblockq_silence(i->thread_info.render_memblockq);
777 /* And reset the resampler */
778 if (i->thread_info.resampler)
779 pa_resampler_reset(i->thread_info.resampler);
784 if (i->process_rewind)
785 i->process_rewind(i, 0);
787 i->thread_info.rewrite_nbytes = 0;
788 i->thread_info.rewrite_flush = FALSE;
789 i->thread_info.dont_rewind_render = FALSE;
792 /* Called from thread context */
793 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
794 pa_sink_input_assert_ref(i);
795 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
796 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
798 pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes);
800 if (i->update_max_rewind)
801 i->update_max_rewind(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
804 /* Called from thread context */
805 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
806 pa_sink_input_assert_ref(i);
807 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
808 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
810 if (i->update_max_request)
811 i->update_max_request(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
814 /* Called from thread context */
815 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) {
816 pa_sink_input_assert_ref(i);
818 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
819 usec = i->sink->fixed_latency;
821 if (usec != (pa_usec_t) -1)
822 usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
824 i->thread_info.requested_sink_latency = usec;
825 pa_sink_invalidate_requested_latency(i->sink);
830 /* Called from main context */
831 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) {
832 pa_sink_input_assert_ref(i);
834 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
835 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
839 /* If this sink input is not realized yet or we are being moved,
840 * we have to touch the thread info data directly */
843 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
844 usec = i->sink->fixed_latency;
846 if (usec != (pa_usec_t) -1) {
847 pa_usec_t min_latency, max_latency;
848 pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
849 usec = PA_CLAMP(usec, min_latency, max_latency);
853 i->thread_info.requested_sink_latency = usec;
858 /* Called from main context */
859 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
860 pa_sink_input_assert_ref(i);
862 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
864 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
868 /* If this sink input is not realized yet or we are being moved,
869 * we have to touch the thread info data directly */
871 return i->thread_info.requested_sink_latency;
874 /* Called from main context */
875 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, pa_bool_t save, pa_bool_t absolute) {
878 pa_sink_input_assert_ref(i);
879 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
881 pa_assert(pa_cvolume_valid(volume));
882 pa_assert(pa_cvolume_compatible(volume, &i->sample_spec));
884 if ((i->sink->flags & PA_SINK_FLAT_VOLUME) && !absolute) {
885 v = i->sink->reference_volume;
886 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
887 volume = pa_sw_cvolume_multiply(&v, &v, volume);
890 if (pa_cvolume_equal(volume, &i->virtual_volume))
893 i->virtual_volume = *volume;
894 i->save_volume = save;
896 if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
897 pa_cvolume new_volume;
899 /* We are in flat volume mode, so let's update all sink input
900 * volumes and update the flat volume of the sink */
902 pa_sink_update_flat_volume(i->sink, &new_volume);
903 pa_sink_set_volume(i->sink, &new_volume, FALSE, TRUE, FALSE, FALSE);
907 /* OK, we are in normal volume mode. The volume only affects
909 pa_sink_input_set_relative_volume(i, volume);
911 /* Hooks have the ability to play games with i->soft_volume */
912 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME], i);
914 /* Copy the new soft_volume to the thread_info struct */
915 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
918 /* The virtual volume changed, let's tell people so */
919 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
922 /* Called from main context */
923 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, pa_bool_t absolute) {
924 pa_sink_input_assert_ref(i);
925 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
927 if ((i->sink->flags & PA_SINK_FLAT_VOLUME) && !absolute) {
928 pa_cvolume v = i->sink->reference_volume;
929 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
930 pa_sw_cvolume_divide(volume, &i->virtual_volume, &v);
932 *volume = i->virtual_volume;
937 /* Called from main context */
938 pa_cvolume *pa_sink_input_get_relative_volume(pa_sink_input *i, pa_cvolume *v) {
941 pa_sink_input_assert_ref(i);
943 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
945 /* This always returns the relative volume. Converts the float
946 * version into a pa_cvolume */
948 v->channels = i->sample_spec.channels;
950 for (c = 0; c < v->channels; c++)
951 v->values[c] = pa_sw_volume_from_linear(i->relative_volume[c]);
956 /* Called from main context */
957 void pa_sink_input_set_relative_volume(pa_sink_input *i, const pa_cvolume *v) {
961 pa_sink_input_assert_ref(i);
962 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
963 pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
966 v = pa_cvolume_reset(&_v, i->sample_spec.channels);
968 /* This basically calculates:
970 * i->relative_volume := v
971 * i->soft_volume := i->relative_volume * i->volume_factor */
973 i->soft_volume.channels = i->sample_spec.channels;
975 for (c = 0; c < i->sample_spec.channels; c++) {
976 i->relative_volume[c] = pa_sw_volume_to_linear(v->values[c]);
978 i->soft_volume.values[c] = pa_sw_volume_from_linear(
979 i->relative_volume[c] *
980 pa_sw_volume_to_linear(i->volume_factor.values[c]));
983 /* We don't copy the data to the thread_info data. That's left for someone else to do */
986 /* Called from main context */
987 void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute, pa_bool_t save) {
989 pa_sink_input_assert_ref(i);
990 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
992 if (!i->muted == !mute)
996 i->save_muted = save;
998 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
999 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1002 /* Called from main context */
1003 pa_bool_t pa_sink_input_get_mute(pa_sink_input *i) {
1004 pa_sink_input_assert_ref(i);
1005 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1010 /* Called from main thread */
1011 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1012 pa_sink_input_assert_ref(i);
1015 pa_proplist_update(i->proplist, mode, p);
1017 if (PA_SINK_IS_LINKED(i->state)) {
1018 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1019 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1023 /* Called from main context */
1024 void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b) {
1025 pa_sink_input_assert_ref(i);
1026 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1028 sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1031 /* Called from main context */
1032 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1033 pa_sink_input_assert_ref(i);
1034 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1035 pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1037 if (i->sample_spec.rate == rate)
1040 i->sample_spec.rate = rate;
1042 pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1044 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1048 /* Called from main context */
1049 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1051 pa_sink_input_assert_ref(i);
1053 if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1056 old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1058 if (old && name && !strcmp(old, name))
1062 pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1064 pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1066 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1067 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1068 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1072 /* Called from main context */
1073 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1074 pa_sink_input_assert_ref(i);
1076 return i->actual_resample_method;
1079 /* Called from main context */
1080 pa_bool_t pa_sink_input_may_move(pa_sink_input *i) {
1081 pa_sink_input_assert_ref(i);
1082 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1084 if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1087 if (i->sync_next || i->sync_prev) {
1088 pa_log_warn("Moving synchronised streams not supported.");
1095 /* Called from main context */
1096 pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1097 pa_sink_input_assert_ref(i);
1098 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1099 pa_sink_assert_ref(dest);
1101 if (dest == i->sink)
1104 if (!pa_sink_input_may_move(i))
1107 if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1108 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1113 if (!i->may_move_to(i, dest))
1119 /* Called from main context */
1120 int pa_sink_input_start_move(pa_sink_input *i) {
1121 pa_source_output *o, *p = NULL;
1125 pa_sink_input_assert_ref(i);
1126 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1129 if (!pa_sink_input_may_move(i))
1130 return -PA_ERR_NOTSUPPORTED;
1132 if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1137 /* Kill directly connected outputs */
1138 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1140 pa_source_output_kill(o);
1143 pa_assert(pa_idxset_isempty(i->direct_outputs));
1145 pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1147 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1148 pa_assert_se(i->sink->n_corked-- >= 1);
1150 if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
1151 pa_cvolume new_volume;
1153 /* Make the virtual volume relative */
1154 pa_sink_input_get_relative_volume(i, &i->virtual_volume);
1156 /* And reset the the relative volume */
1157 pa_sink_input_set_relative_volume(i, NULL);
1159 /* We might need to update the sink's volume if we are in flat
1161 pa_sink_update_flat_volume(i->sink, &new_volume);
1162 pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE, FALSE);
1165 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1167 pa_sink_update_status(i->sink);
1170 pa_sink_input_unref(i);
1175 /* Called from main context */
1176 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1177 pa_resampler *new_resampler;
1179 pa_sink_input_assert_ref(i);
1180 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1181 pa_assert(!i->sink);
1182 pa_sink_assert_ref(dest);
1184 if (!pa_sink_input_may_move_to(i, dest))
1185 return -PA_ERR_NOTSUPPORTED;
1187 if (i->thread_info.resampler &&
1188 pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &dest->sample_spec) &&
1189 pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &dest->channel_map))
1191 /* Try to reuse the old resampler if possible */
1192 new_resampler = i->thread_info.resampler;
1194 else if ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
1195 !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec) ||
1196 !pa_channel_map_equal(&i->channel_map, &dest->channel_map)) {
1198 /* Okey, we need a new resampler for the new sink */
1200 if (!(new_resampler = pa_resampler_new(
1202 &i->sample_spec, &i->channel_map,
1203 &dest->sample_spec, &dest->channel_map,
1204 i->requested_resample_method,
1205 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
1206 ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
1207 (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0)))) {
1208 pa_log_warn("Unsupported resampling operation.");
1209 return -PA_ERR_NOTSUPPORTED;
1212 new_resampler = NULL;
1218 i->save_sink = save;
1219 pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1221 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1222 i->sink->n_corked++;
1224 /* Replace resampler and render queue */
1225 if (new_resampler != i->thread_info.resampler) {
1227 if (i->thread_info.resampler)
1228 pa_resampler_free(i->thread_info.resampler);
1229 i->thread_info.resampler = new_resampler;
1231 pa_memblockq_free(i->thread_info.render_memblockq);
1233 i->thread_info.render_memblockq = pa_memblockq_new(
1235 MEMBLOCKQ_MAXLENGTH,
1237 pa_frame_size(&i->sink->sample_spec),
1243 pa_sink_update_status(dest);
1245 if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
1246 pa_cvolume new_volume;
1248 /* Make relative volume absolute again */
1249 pa_cvolume t = dest->reference_volume;
1250 pa_cvolume_remap(&t, &dest->channel_map, &i->channel_map);
1251 pa_sw_cvolume_multiply(&i->virtual_volume, &i->virtual_volume, &t);
1253 /* We might need to update the sink's volume if we are in flat volume mode. */
1254 pa_sink_update_flat_volume(i->sink, &new_volume);
1255 pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE, FALSE);
1258 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1260 pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1262 /* Notify everyone */
1263 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1264 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1269 /* Called from main context */
1270 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1273 pa_sink_input_assert_ref(i);
1274 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1276 pa_sink_assert_ref(dest);
1278 if (dest == i->sink)
1281 if (!pa_sink_input_may_move_to(i, dest))
1282 return -PA_ERR_NOTSUPPORTED;
1284 pa_sink_input_ref(i);
1286 if ((r = pa_sink_input_start_move(i)) < 0) {
1287 pa_sink_input_unref(i);
1291 if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1292 pa_sink_input_unref(i);
1296 pa_sink_input_unref(i);
1301 /* Called from IO thread context */
1302 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1303 pa_bool_t corking, uncorking;
1304 pa_sink_input_assert_ref(i);
1306 if (state == i->thread_info.state)
1309 if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1310 !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1311 pa_atomic_store(&i->thread_info.drained, 1);
1313 corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1314 uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1316 if (i->state_change)
1317 i->state_change(i, state);
1319 i->thread_info.state = state;
1323 pa_log_debug("Requesting rewind due to corking");
1325 /* This will tell the implementing sink input driver to rewind
1326 * so that the unplayed already mixed data is not lost */
1327 pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1329 } else if (uncorking) {
1331 i->thread_info.underrun_for = (uint64_t) -1;
1332 i->thread_info.playing_for = 0;
1334 pa_log_debug("Requesting rewind due to uncorking");
1336 /* OK, we're being uncorked. Make sure we're not rewound when
1337 * the hw buffer is remixed and request a remix. */
1338 pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1342 /* Called from thread context, except when it is not. */
1343 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1344 pa_sink_input *i = PA_SINK_INPUT(o);
1345 pa_sink_input_assert_ref(i);
1349 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1350 if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1351 i->thread_info.soft_volume = i->soft_volume;
1352 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1356 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1357 if (i->thread_info.muted != i->muted) {
1358 i->thread_info.muted = i->muted;
1359 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1363 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1364 pa_usec_t *r = userdata;
1366 r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1367 r[1] += pa_sink_get_latency_within_thread(i->sink);
1372 case PA_SINK_INPUT_MESSAGE_SET_RATE:
1374 i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1375 pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1379 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1380 pa_sink_input *ssync;
1382 pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
1384 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
1385 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1387 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
1388 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1393 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
1394 pa_usec_t *usec = userdata;
1396 *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
1400 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
1401 pa_usec_t *r = userdata;
1403 *r = i->thread_info.requested_sink_latency;
1408 return -PA_ERR_NOTIMPLEMENTED;
1411 /* Called from main thread */
1412 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
1413 pa_sink_input_assert_ref(i);
1415 if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
1416 return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
1421 /* Called from IO context */
1422 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
1423 pa_sink_input_assert_ref(i);
1425 if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
1426 return pa_memblockq_is_empty(i->thread_info.render_memblockq);
1431 /* Called from IO context */
1432 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) {
1435 /* If 'rewrite' is TRUE the sink is rewound as far as requested
1436 * and possible and the exact value of this is passed back the
1437 * implementor via process_rewind(). If 'flush' is also TRUE all
1438 * already rendered data is also dropped.
1440 * If 'rewrite' is FALSE the sink is rewound as far as requested
1441 * and possible and the already rendered data is dropped so that
1442 * in the next iteration we read new data from the
1443 * implementor. This implies 'flush' is TRUE. If
1444 * dont_rewind_render is TRUE then the render memblockq is not
1447 pa_sink_input_assert_ref(i);
1449 nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
1451 /* pa_log_debug("request rewrite %lu", (unsigned long) nbytes); */
1453 /* We don't take rewind requests while we are corked */
1454 if (i->thread_info.state == PA_SINK_INPUT_CORKED)
1457 pa_assert(rewrite || flush);
1458 pa_assert(!dont_rewind_render || !rewrite);
1460 /* Calculate how much we can rewind locally without having to
1463 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1467 /* Check if rewinding for the maximum is requested, and if so, fix up */
1470 /* Calculate maximum number of bytes that could be rewound in theory */
1471 nbytes = i->sink->thread_info.max_rewind + lbq;
1473 /* Transform from sink domain */
1474 if (i->thread_info.resampler)
1475 nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
1478 if (i->thread_info.rewrite_nbytes != (size_t) -1) {
1480 /* Make sure to not overwrite over underruns */
1481 if (nbytes > i->thread_info.playing_for)
1482 nbytes = (size_t) i->thread_info.playing_for;
1484 i->thread_info.rewrite_nbytes = nbytes;
1486 i->thread_info.rewrite_nbytes = (size_t) -1;
1489 i->thread_info.rewrite_flush =
1490 i->thread_info.rewrite_flush ||
1491 (flush && i->thread_info.rewrite_nbytes != 0);
1493 i->thread_info.dont_rewind_render =
1494 i->thread_info.dont_rewind_render ||
1497 if (nbytes != (size_t) -1) {
1499 /* Transform to sink domain */
1500 if (i->thread_info.resampler)
1501 nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
1504 pa_sink_request_rewind(i->sink, nbytes - lbq);
1506 /* This call will make sure process_rewind() is called later */
1507 pa_sink_request_rewind(i->sink, 0);
1511 /* Called from main context */
1512 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
1513 pa_sink_input_assert_ref(i);
1516 pa_silence_memchunk_get(
1517 &i->core->silence_cache,
1521 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
1526 /* Called from main context */
1527 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
1528 pa_proplist *pl = NULL;
1529 pa_sink_input_send_event_hook_data hook_data;
1531 pa_sink_input_assert_ref(i);
1538 data = pl = pa_proplist_new();
1540 hook_data.sink_input = i;
1541 hook_data.data = data;
1542 hook_data.event = event;
1544 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
1547 i->send_event(i, event, data);
1551 pa_proplist_free(pl);