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 PA_DEFINE_PUBLIC_CLASS(pa_sink_input, pa_msgobject);
49 static void sink_input_free(pa_object *o);
50 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v);
52 pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data) {
56 data->resample_method = PA_RESAMPLER_INVALID;
57 data->proplist = pa_proplist_new();
62 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec) {
65 if ((data->sample_spec_is_set = !!spec))
66 data->sample_spec = *spec;
69 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map) {
72 if ((data->channel_map_is_set = !!map))
73 data->channel_map = *map;
76 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume) {
79 if ((data->volume_is_set = !!volume))
80 data->volume = *volume;
83 void pa_sink_input_new_data_apply_volume_factor(pa_sink_input_new_data *data, const pa_cvolume *volume_factor) {
85 pa_assert(volume_factor);
87 if (data->volume_factor_is_set)
88 pa_sw_cvolume_multiply(&data->volume_factor, &data->volume_factor, volume_factor);
90 data->volume_factor_is_set = TRUE;
91 data->volume_factor = *volume_factor;
95 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, pa_bool_t mute) {
98 data->muted_is_set = TRUE;
102 void pa_sink_input_new_data_done(pa_sink_input_new_data *data) {
105 pa_proplist_free(data->proplist);
108 /* Called from main context */
109 static void reset_callbacks(pa_sink_input *i) {
113 i->process_rewind = NULL;
114 i->update_max_rewind = NULL;
115 i->update_max_request = NULL;
116 i->update_sink_requested_latency = NULL;
117 i->update_sink_latency_range = NULL;
118 i->update_sink_fixed_latency = NULL;
122 i->suspend_within_thread = NULL;
125 i->get_latency = NULL;
126 i->state_change = NULL;
127 i->may_move_to = NULL;
128 i->send_event = NULL;
129 i->volume_changed = NULL;
130 i->mute_changed = NULL;
133 /* Called from main context */
134 int pa_sink_input_new(
137 pa_sink_input_new_data *data) {
140 pa_resampler *resampler = NULL;
141 char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
142 pa_channel_map original_cm;
148 pa_assert_ctl_context();
151 pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->client->proplist);
153 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], data)) < 0)
156 pa_return_val_if_fail(!data->driver || pa_utf8_valid(data->driver), -PA_ERR_INVALID);
159 data->sink = pa_namereg_get(core, NULL, PA_NAMEREG_SINK);
160 data->save_sink = FALSE;
163 pa_return_val_if_fail(data->sink, -PA_ERR_NOENTITY);
164 pa_return_val_if_fail(PA_SINK_IS_LINKED(pa_sink_get_state(data->sink)), -PA_ERR_BADSTATE);
165 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);
167 if (!data->sample_spec_is_set)
168 data->sample_spec = data->sink->sample_spec;
170 pa_return_val_if_fail(pa_sample_spec_valid(&data->sample_spec), -PA_ERR_INVALID);
172 if (!data->channel_map_is_set) {
173 if (pa_channel_map_compatible(&data->sink->channel_map, &data->sample_spec))
174 data->channel_map = data->sink->channel_map;
176 pa_channel_map_init_extend(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
179 pa_return_val_if_fail(pa_channel_map_valid(&data->channel_map), -PA_ERR_INVALID);
180 pa_return_val_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec), -PA_ERR_INVALID);
182 if (!data->volume_is_set) {
183 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
184 data->volume_is_absolute = FALSE;
185 data->save_volume = FALSE;
188 pa_return_val_if_fail(pa_cvolume_valid(&data->volume), -PA_ERR_INVALID);
189 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec), -PA_ERR_INVALID);
191 if (!data->volume_factor_is_set)
192 pa_cvolume_reset(&data->volume_factor, data->sample_spec.channels);
194 pa_return_val_if_fail(pa_cvolume_valid(&data->volume_factor), -PA_ERR_INVALID);
195 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume_factor, &data->sample_spec), -PA_ERR_INVALID);
197 if (!data->muted_is_set)
200 if (data->flags & PA_SINK_INPUT_FIX_FORMAT)
201 data->sample_spec.format = data->sink->sample_spec.format;
203 if (data->flags & PA_SINK_INPUT_FIX_RATE)
204 data->sample_spec.rate = data->sink->sample_spec.rate;
206 original_cm = data->channel_map;
208 if (data->flags & PA_SINK_INPUT_FIX_CHANNELS) {
209 data->sample_spec.channels = data->sink->sample_spec.channels;
210 data->channel_map = data->sink->channel_map;
213 pa_assert(pa_sample_spec_valid(&data->sample_spec));
214 pa_assert(pa_channel_map_valid(&data->channel_map));
216 /* Due to the fixing of the sample spec the volume might not match anymore */
217 pa_cvolume_remap(&data->volume, &original_cm, &data->channel_map);
219 if (data->resample_method == PA_RESAMPLER_INVALID)
220 data->resample_method = core->resample_method;
222 pa_return_val_if_fail(data->resample_method < PA_RESAMPLER_MAX, -PA_ERR_INVALID);
224 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], data)) < 0)
227 if ((data->flags & PA_SINK_INPUT_NO_CREATE_ON_SUSPEND) &&
228 pa_sink_get_state(data->sink) == PA_SINK_SUSPENDED) {
229 pa_log_warn("Failed to create sink input: sink is suspended.");
230 return -PA_ERR_BADSTATE;
233 if (pa_idxset_size(data->sink->inputs) >= PA_MAX_INPUTS_PER_SINK) {
234 pa_log_warn("Failed to create sink input: too many inputs per sink.");
235 return -PA_ERR_TOOLARGE;
238 if ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
239 !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec) ||
240 !pa_channel_map_equal(&data->channel_map, &data->sink->channel_map)) {
242 if (!(resampler = pa_resampler_new(
244 &data->sample_spec, &data->channel_map,
245 &data->sink->sample_spec, &data->sink->channel_map,
246 data->resample_method,
247 ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
248 ((data->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
249 (core->disable_remixing || (data->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0) |
250 (core->disable_lfe_remixing ? PA_RESAMPLER_NO_LFE : 0)))) {
251 pa_log_warn("Unsupported resampling operation.");
252 return -PA_ERR_NOTSUPPORTED;
256 i = pa_msgobject_new(pa_sink_input);
257 i->parent.parent.free = sink_input_free;
258 i->parent.process_msg = pa_sink_input_process_msg;
261 i->state = PA_SINK_INPUT_INIT;
262 i->flags = data->flags;
263 i->proplist = pa_proplist_copy(data->proplist);
264 i->driver = pa_xstrdup(pa_path_get_filename(data->driver));
265 i->module = data->module;
266 i->sink = data->sink;
267 i->client = data->client;
269 i->requested_resample_method = data->resample_method;
270 i->actual_resample_method = resampler ? pa_resampler_get_method(resampler) : PA_RESAMPLER_INVALID;
271 i->sample_spec = data->sample_spec;
272 i->channel_map = data->channel_map;
274 if ((i->sink->flags & PA_SINK_FLAT_VOLUME) && !data->volume_is_absolute) {
277 /* When the 'absolute' bool is not set then we'll treat the volume
278 * as relative to the sink volume even in flat volume mode */
279 remapped = data->sink->reference_volume;
280 pa_cvolume_remap(&remapped, &data->sink->channel_map, &data->channel_map);
281 pa_sw_cvolume_multiply(&i->volume, &data->volume, &remapped);
283 i->volume = data->volume;
285 i->volume_factor = data->volume_factor;
286 i->real_ratio = i->reference_ratio = data->volume;
287 pa_cvolume_reset(&i->soft_volume, i->sample_spec.channels);
288 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
289 i->save_volume = data->save_volume;
290 i->save_sink = data->save_sink;
291 i->save_muted = data->save_muted;
293 i->muted = data->muted;
295 if (data->sync_base) {
296 i->sync_next = data->sync_base->sync_next;
297 i->sync_prev = data->sync_base;
299 if (data->sync_base->sync_next)
300 data->sync_base->sync_next->sync_prev = i;
301 data->sync_base->sync_next = i;
303 i->sync_next = i->sync_prev = NULL;
305 i->direct_outputs = pa_idxset_new(NULL, NULL);
310 i->thread_info.state = i->state;
311 i->thread_info.attached = FALSE;
312 pa_atomic_store(&i->thread_info.drained, 1);
313 i->thread_info.sample_spec = i->sample_spec;
314 i->thread_info.resampler = resampler;
315 i->thread_info.soft_volume = i->soft_volume;
316 i->thread_info.muted = i->muted;
317 i->thread_info.requested_sink_latency = (pa_usec_t) -1;
318 i->thread_info.rewrite_nbytes = 0;
319 i->thread_info.rewrite_flush = FALSE;
320 i->thread_info.dont_rewind_render = FALSE;
321 i->thread_info.underrun_for = (uint64_t) -1;
322 i->thread_info.playing_for = 0;
323 i->thread_info.direct_outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
325 i->thread_info.render_memblockq = pa_memblockq_new(
329 pa_frame_size(&i->sink->sample_spec),
335 pa_assert_se(pa_idxset_put(core->sink_inputs, i, &i->index) == 0);
336 pa_assert_se(pa_idxset_put(i->sink->inputs, pa_sink_input_ref(i), NULL) == 0);
339 pa_assert_se(pa_idxset_put(i->client->sink_inputs, i, NULL) >= 0);
341 pa_log_info("Created input %u \"%s\" on %s with sample spec %s and channel map %s",
343 pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)),
345 pa_sample_spec_snprint(st, sizeof(st), &i->sample_spec),
346 pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map));
348 /* Don't forget to call pa_sink_input_put! */
354 /* Called from main context */
355 static void update_n_corked(pa_sink_input *i, pa_sink_input_state_t state) {
357 pa_assert_ctl_context();
362 if (i->state == PA_SINK_INPUT_CORKED && state != PA_SINK_INPUT_CORKED)
363 pa_assert_se(i->sink->n_corked -- >= 1);
364 else if (i->state != PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_CORKED)
368 /* Called from main context */
369 static void sink_input_set_state(pa_sink_input *i, pa_sink_input_state_t state) {
370 pa_sink_input *ssync;
372 pa_assert_ctl_context();
374 if (state == PA_SINK_INPUT_DRAINED)
375 state = PA_SINK_INPUT_RUNNING;
377 if (i->state == state)
380 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);
382 update_n_corked(i, state);
385 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev) {
386 update_n_corked(ssync, state);
387 ssync->state = state;
389 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next) {
390 update_n_corked(ssync, state);
391 ssync->state = state;
394 if (state != PA_SINK_INPUT_UNLINKED) {
395 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], i);
397 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev)
398 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
400 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next)
401 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
404 pa_sink_update_status(i->sink);
407 /* Called from main context */
408 void pa_sink_input_unlink(pa_sink_input *i) {
410 pa_source_output *o, *p = NULL;
413 pa_assert_ctl_context();
415 /* See pa_sink_unlink() for a couple of comments how this function
418 pa_sink_input_ref(i);
420 linked = PA_SINK_INPUT_IS_LINKED(i->state);
423 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], i);
426 i->sync_prev->sync_next = i->sync_next;
428 i->sync_next->sync_prev = i->sync_prev;
430 i->sync_prev = i->sync_next = NULL;
432 pa_idxset_remove_by_data(i->core->sink_inputs, i, NULL);
435 if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL))
436 pa_sink_input_unref(i);
439 pa_idxset_remove_by_data(i->client->sink_inputs, i, NULL);
441 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
443 pa_source_output_kill(o);
447 update_n_corked(i, PA_SINK_INPUT_UNLINKED);
448 i->state = PA_SINK_INPUT_UNLINKED;
450 if (linked && i->sink) {
451 /* We might need to update the sink's volume if we are in flat volume mode. */
452 if (i->sink->flags & PA_SINK_FLAT_VOLUME)
453 pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
455 if (i->sink->asyncmsgq)
456 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_REMOVE_INPUT, i, 0, NULL) == 0);
462 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_REMOVE, i->index);
463 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST], i);
467 pa_sink_update_status(i->sink);
471 pa_core_maybe_vacuum(i->core);
473 pa_sink_input_unref(i);
476 /* Called from main context */
477 static void sink_input_free(pa_object *o) {
478 pa_sink_input* i = PA_SINK_INPUT(o);
481 pa_assert_ctl_context();
482 pa_assert(pa_sink_input_refcnt(i) == 0);
484 if (PA_SINK_INPUT_IS_LINKED(i->state))
485 pa_sink_input_unlink(i);
487 pa_log_info("Freeing input %u \"%s\"", i->index, pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)));
489 /* Side note: this function must be able to destruct properly any
490 * kind of sink input in any state, even those which are
491 * "half-moved" or are connected to sinks that have no asyncmsgq
492 * and are hence half-destructed themselves! */
494 if (i->thread_info.render_memblockq)
495 pa_memblockq_free(i->thread_info.render_memblockq);
497 if (i->thread_info.resampler)
498 pa_resampler_free(i->thread_info.resampler);
501 pa_proplist_free(i->proplist);
503 if (i->direct_outputs)
504 pa_idxset_free(i->direct_outputs, NULL, NULL);
506 if (i->thread_info.direct_outputs)
507 pa_hashmap_free(i->thread_info.direct_outputs, NULL, NULL);
513 /* Called from main context */
514 void pa_sink_input_put(pa_sink_input *i) {
515 pa_sink_input_state_t state;
517 pa_sink_input_assert_ref(i);
518 pa_assert_ctl_context();
520 pa_assert(i->state == PA_SINK_INPUT_INIT);
522 /* The following fields must be initialized properly */
524 pa_assert(i->process_rewind);
527 state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING;
529 update_n_corked(i, state);
532 /* We might need to update the sink's volume if we are in flat volume mode. */
533 if (i->sink->flags & PA_SINK_FLAT_VOLUME)
534 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
536 set_real_ratio(i, &i->volume);
538 i->thread_info.soft_volume = i->soft_volume;
539 i->thread_info.muted = i->muted;
541 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_ADD_INPUT, i, 0, NULL) == 0);
543 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, i->index);
544 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], i);
546 pa_sink_update_status(i->sink);
549 /* Called from main context */
550 void pa_sink_input_kill(pa_sink_input*i) {
551 pa_sink_input_assert_ref(i);
552 pa_assert_ctl_context();
553 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
558 /* Called from main context */
559 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency) {
560 pa_usec_t r[2] = { 0, 0 };
562 pa_sink_input_assert_ref(i);
563 pa_assert_ctl_context();
564 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
566 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_LATENCY, r, 0, NULL) == 0);
569 r[0] += i->get_latency(i);
572 *sink_latency = r[1];
577 /* Called from thread context */
578 void pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink frames */, pa_memchunk *chunk, pa_cvolume *volume) {
579 pa_bool_t do_volume_adj_here;
580 pa_bool_t volume_is_norm;
581 size_t block_size_max_sink, block_size_max_sink_input;
584 pa_sink_input_assert_ref(i);
585 pa_sink_input_assert_io_context(i);
586 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
587 pa_assert(pa_frame_aligned(slength, &i->sink->sample_spec));
591 /* pa_log_debug("peek"); */
593 pa_assert(i->thread_info.state == PA_SINK_INPUT_RUNNING ||
594 i->thread_info.state == PA_SINK_INPUT_CORKED ||
595 i->thread_info.state == PA_SINK_INPUT_DRAINED);
597 block_size_max_sink_input = i->thread_info.resampler ?
598 pa_resampler_max_block_size(i->thread_info.resampler) :
599 pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sample_spec);
601 block_size_max_sink = pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sink->sample_spec);
603 /* Default buffer size */
605 slength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sink->sample_spec);
607 if (slength > block_size_max_sink)
608 slength = block_size_max_sink;
610 if (i->thread_info.resampler) {
611 ilength = pa_resampler_request(i->thread_info.resampler, slength);
614 ilength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sample_spec);
618 if (ilength > block_size_max_sink_input)
619 ilength = block_size_max_sink_input;
621 /* If the channel maps of the sink and this stream differ, we need
622 * to adjust the volume *before* we resample. Otherwise we can do
623 * it after and leave it for the sink code */
625 do_volume_adj_here = !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map);
626 volume_is_norm = pa_cvolume_is_norm(&i->thread_info.soft_volume) && !i->thread_info.muted;
628 while (!pa_memblockq_is_readable(i->thread_info.render_memblockq)) {
631 /* There's nothing in our render queue. We need to fill it up
632 * with data from the implementor. */
634 if (i->thread_info.state == PA_SINK_INPUT_CORKED ||
635 i->pop(i, ilength, &tchunk) < 0) {
637 /* OK, we're corked or the implementor didn't give us any
638 * data, so let's just hand out silence */
639 pa_atomic_store(&i->thread_info.drained, 1);
641 pa_memblockq_seek(i->thread_info.render_memblockq, (int64_t) slength, PA_SEEK_RELATIVE, TRUE);
642 i->thread_info.playing_for = 0;
643 if (i->thread_info.underrun_for != (uint64_t) -1)
644 i->thread_info.underrun_for += ilength;
648 pa_atomic_store(&i->thread_info.drained, 0);
650 pa_assert(tchunk.length > 0);
651 pa_assert(tchunk.memblock);
653 i->thread_info.underrun_for = 0;
654 i->thread_info.playing_for += tchunk.length;
656 while (tchunk.length > 0) {
660 pa_memblock_ref(wchunk.memblock);
662 if (wchunk.length > block_size_max_sink_input)
663 wchunk.length = block_size_max_sink_input;
665 /* It might be necessary to adjust the volume here */
666 if (do_volume_adj_here && !volume_is_norm) {
667 pa_memchunk_make_writable(&wchunk, 0);
669 if (i->thread_info.muted)
670 pa_silence_memchunk(&wchunk, &i->thread_info.sample_spec);
672 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.soft_volume);
675 if (!i->thread_info.resampler)
676 pa_memblockq_push_align(i->thread_info.render_memblockq, &wchunk);
679 pa_resampler_run(i->thread_info.resampler, &wchunk, &rchunk);
681 /* pa_log_debug("pushing %lu", (unsigned long) rchunk.length); */
683 if (rchunk.memblock) {
684 pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk);
685 pa_memblock_unref(rchunk.memblock);
689 pa_memblock_unref(wchunk.memblock);
691 tchunk.index += wchunk.length;
692 tchunk.length -= wchunk.length;
695 pa_memblock_unref(tchunk.memblock);
698 pa_assert_se(pa_memblockq_peek(i->thread_info.render_memblockq, chunk) >= 0);
700 pa_assert(chunk->length > 0);
701 pa_assert(chunk->memblock);
703 /* pa_log_debug("peeking %lu", (unsigned long) chunk->length); */
705 if (chunk->length > block_size_max_sink)
706 chunk->length = block_size_max_sink;
708 /* Let's see if we had to apply the volume adjustment ourselves,
709 * or if this can be done by the sink for us */
711 if (do_volume_adj_here)
712 /* We had different channel maps, so we already did the adjustment */
713 pa_cvolume_reset(volume, i->sink->sample_spec.channels);
714 else if (i->thread_info.muted)
715 /* We've both the same channel map, so let's have the sink do the adjustment for us*/
716 pa_cvolume_mute(volume, i->sink->sample_spec.channels);
718 *volume = i->thread_info.soft_volume;
721 /* Called from thread context */
722 void pa_sink_input_drop(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
724 pa_sink_input_assert_ref(i);
725 pa_sink_input_assert_io_context(i);
726 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
727 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
728 pa_assert(nbytes > 0);
730 /* pa_log_debug("dropping %lu", (unsigned long) nbytes); */
732 pa_memblockq_drop(i->thread_info.render_memblockq, nbytes);
735 /* Called from thread context */
736 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
738 pa_bool_t called = FALSE;
740 pa_sink_input_assert_ref(i);
741 pa_sink_input_assert_io_context(i);
742 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
743 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
745 /* pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes); */
747 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
749 if (nbytes > 0 && !i->thread_info.dont_rewind_render) {
750 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes);
751 pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes);
754 if (i->thread_info.rewrite_nbytes == (size_t) -1) {
756 /* We were asked to drop all buffered data, and rerequest new
757 * data from implementor the next time push() is called */
759 pa_memblockq_flush_write(i->thread_info.render_memblockq);
761 } else if (i->thread_info.rewrite_nbytes > 0) {
762 size_t max_rewrite, amount;
764 /* Calculate how much make sense to rewrite at most */
765 max_rewrite = nbytes + lbq;
767 /* Transform into local domain */
768 if (i->thread_info.resampler)
769 max_rewrite = pa_resampler_request(i->thread_info.resampler, max_rewrite);
771 /* Calculate how much of the rewinded data should actually be rewritten */
772 amount = PA_MIN(i->thread_info.rewrite_nbytes, max_rewrite);
775 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount);
777 /* Tell the implementor */
778 if (i->process_rewind)
779 i->process_rewind(i, amount);
782 /* Convert back to to sink domain */
783 if (i->thread_info.resampler)
784 amount = pa_resampler_result(i->thread_info.resampler, amount);
787 /* Ok, now update the write pointer */
788 pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) amount), PA_SEEK_RELATIVE, TRUE);
790 if (i->thread_info.rewrite_flush)
791 pa_memblockq_silence(i->thread_info.render_memblockq);
793 /* And reset the resampler */
794 if (i->thread_info.resampler)
795 pa_resampler_reset(i->thread_info.resampler);
800 if (i->process_rewind)
801 i->process_rewind(i, 0);
803 i->thread_info.rewrite_nbytes = 0;
804 i->thread_info.rewrite_flush = FALSE;
805 i->thread_info.dont_rewind_render = FALSE;
808 /* Called from thread context */
809 size_t pa_sink_input_get_max_rewind(pa_sink_input *i) {
810 pa_sink_input_assert_ref(i);
811 pa_sink_input_assert_io_context(i);
813 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_rewind) : i->sink->thread_info.max_rewind;
816 /* Called from thread context */
817 size_t pa_sink_input_get_max_request(pa_sink_input *i) {
818 pa_sink_input_assert_ref(i);
819 pa_sink_input_assert_io_context(i);
821 /* We're not verifying the status here, to allow this to be called
822 * in the state change handler between _INIT and _RUNNING */
824 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_request) : i->sink->thread_info.max_request;
827 /* Called from thread context */
828 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
829 pa_sink_input_assert_ref(i);
830 pa_sink_input_assert_io_context(i);
831 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
832 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
834 pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes);
836 if (i->update_max_rewind)
837 i->update_max_rewind(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
840 /* Called from thread context */
841 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
842 pa_sink_input_assert_ref(i);
843 pa_sink_input_assert_io_context(i);
844 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
845 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
847 if (i->update_max_request)
848 i->update_max_request(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
851 /* Called from thread context */
852 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) {
853 pa_sink_input_assert_ref(i);
854 pa_sink_input_assert_io_context(i);
856 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
857 usec = i->sink->thread_info.fixed_latency;
859 if (usec != (pa_usec_t) -1)
860 usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
862 i->thread_info.requested_sink_latency = usec;
863 pa_sink_invalidate_requested_latency(i->sink, TRUE);
868 /* Called from main context */
869 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) {
870 pa_sink_input_assert_ref(i);
871 pa_assert_ctl_context();
873 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
874 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
878 /* If this sink input is not realized yet or we are being moved,
879 * we have to touch the thread info data directly */
882 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
883 usec = pa_sink_get_fixed_latency(i->sink);
885 if (usec != (pa_usec_t) -1) {
886 pa_usec_t min_latency, max_latency;
887 pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
888 usec = PA_CLAMP(usec, min_latency, max_latency);
892 i->thread_info.requested_sink_latency = usec;
897 /* Called from main context */
898 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
899 pa_sink_input_assert_ref(i);
900 pa_assert_ctl_context();
902 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
904 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
908 /* If this sink input is not realized yet or we are being moved,
909 * we have to touch the thread info data directly */
911 return i->thread_info.requested_sink_latency;
914 /* Called from main context */
915 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
916 pa_sink_input_assert_ref(i);
917 pa_assert_ctl_context();
918 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
919 pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
921 /* This basically calculates:
924 * i->soft_volume := i->real_ratio * i->volume_factor */
929 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
931 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
932 /* We don't copy the data to the thread_info data. That's left for someone else to do */
935 /* Called from main context */
936 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, pa_bool_t save, pa_bool_t absolute) {
939 pa_sink_input_assert_ref(i);
940 pa_assert_ctl_context();
941 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
943 pa_assert(pa_cvolume_valid(volume));
944 pa_assert(volume->channels == 1 || pa_cvolume_compatible(volume, &i->sample_spec));
946 if ((i->sink->flags & PA_SINK_FLAT_VOLUME) && !absolute) {
947 v = i->sink->reference_volume;
948 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
950 if (pa_cvolume_compatible(volume, &i->sample_spec))
951 volume = pa_sw_cvolume_multiply(&v, &v, volume);
953 volume = pa_sw_cvolume_multiply_scalar(&v, &v, pa_cvolume_max(volume));
956 if (!pa_cvolume_compatible(volume, &i->sample_spec)) {
958 volume = pa_cvolume_scale(&v, pa_cvolume_max(volume));
962 if (pa_cvolume_equal(volume, &i->volume)) {
963 i->save_volume = i->save_volume || save;
968 i->save_volume = save;
970 if (i->sink->flags & PA_SINK_FLAT_VOLUME)
971 /* We are in flat volume mode, so let's update all sink input
972 * volumes and update the flat volume of the sink */
974 pa_sink_set_volume(i->sink, NULL, TRUE, save);
977 /* OK, we are in normal volume mode. The volume only affects
979 set_real_ratio(i, volume);
981 /* Copy the new soft_volume to the thread_info struct */
982 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
985 /* The volume changed, let's tell people so */
986 if (i->volume_changed)
987 i->volume_changed(i);
989 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
992 /* Called from main context */
993 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, pa_bool_t absolute) {
994 pa_sink_input_assert_ref(i);
995 pa_assert_ctl_context();
996 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
998 if (absolute || !(i->sink->flags & PA_SINK_FLAT_VOLUME))
1001 *volume = i->reference_ratio;
1006 /* Called from main context */
1007 void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute, pa_bool_t save) {
1008 pa_sink_input_assert_ref(i);
1009 pa_assert_ctl_context();
1010 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1012 if (!i->muted == !mute)
1016 i->save_muted = save;
1018 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1020 /* The mute status changed, let's tell people so */
1021 if (i->mute_changed)
1024 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1027 /* Called from main context */
1028 pa_bool_t pa_sink_input_get_mute(pa_sink_input *i) {
1029 pa_sink_input_assert_ref(i);
1030 pa_assert_ctl_context();
1031 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1036 /* Called from main thread */
1037 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1038 pa_sink_input_assert_ref(i);
1039 pa_assert_ctl_context();
1042 pa_proplist_update(i->proplist, mode, p);
1044 if (PA_SINK_IS_LINKED(i->state)) {
1045 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1046 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1050 /* Called from main context */
1051 void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b) {
1052 pa_sink_input_assert_ref(i);
1053 pa_assert_ctl_context();
1054 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1056 sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1059 /* Called from main context */
1060 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1061 pa_sink_input_assert_ref(i);
1062 pa_assert_ctl_context();
1063 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1064 pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1066 if (i->sample_spec.rate == rate)
1069 i->sample_spec.rate = rate;
1071 pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1073 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1077 /* Called from main context */
1078 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1080 pa_sink_input_assert_ref(i);
1081 pa_assert_ctl_context();
1083 if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1086 old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1088 if (old && name && pa_streq(old, name))
1092 pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1094 pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1096 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1097 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1098 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1102 /* Called from main context */
1103 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1104 pa_sink_input_assert_ref(i);
1105 pa_assert_ctl_context();
1107 return i->actual_resample_method;
1110 /* Called from main context */
1111 pa_bool_t pa_sink_input_may_move(pa_sink_input *i) {
1112 pa_sink_input_assert_ref(i);
1113 pa_assert_ctl_context();
1114 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1116 if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1119 if (i->sync_next || i->sync_prev) {
1120 pa_log_warn("Moving synchronised streams not supported.");
1127 /* Called from main context */
1128 pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1129 pa_sink_input_assert_ref(i);
1130 pa_assert_ctl_context();
1131 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1132 pa_sink_assert_ref(dest);
1134 if (dest == i->sink)
1137 if (!pa_sink_input_may_move(i))
1140 if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1141 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1146 if (!i->may_move_to(i, dest))
1152 /* Called from main context */
1153 int pa_sink_input_start_move(pa_sink_input *i) {
1154 pa_source_output *o, *p = NULL;
1158 pa_sink_input_assert_ref(i);
1159 pa_assert_ctl_context();
1160 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1163 if (!pa_sink_input_may_move(i))
1164 return -PA_ERR_NOTSUPPORTED;
1166 if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1171 /* Kill directly connected outputs */
1172 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1174 pa_source_output_kill(o);
1177 pa_assert(pa_idxset_isempty(i->direct_outputs));
1179 pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1181 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1182 pa_assert_se(i->sink->n_corked-- >= 1);
1184 if (i->sink->flags & PA_SINK_FLAT_VOLUME)
1185 /* We might need to update the sink's volume if we are in flat
1187 pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
1189 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1191 pa_sink_update_status(i->sink);
1194 pa_sink_input_unref(i);
1199 /* Called from main context */
1200 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1201 pa_resampler *new_resampler;
1203 pa_sink_input_assert_ref(i);
1204 pa_assert_ctl_context();
1205 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1206 pa_assert(!i->sink);
1207 pa_sink_assert_ref(dest);
1209 if (!pa_sink_input_may_move_to(i, dest))
1210 return -PA_ERR_NOTSUPPORTED;
1212 if (i->thread_info.resampler &&
1213 pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &dest->sample_spec) &&
1214 pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &dest->channel_map))
1216 /* Try to reuse the old resampler if possible */
1217 new_resampler = i->thread_info.resampler;
1219 else if ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
1220 !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec) ||
1221 !pa_channel_map_equal(&i->channel_map, &dest->channel_map)) {
1223 /* Okey, we need a new resampler for the new sink */
1225 if (!(new_resampler = pa_resampler_new(
1227 &i->sample_spec, &i->channel_map,
1228 &dest->sample_spec, &dest->channel_map,
1229 i->requested_resample_method,
1230 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
1231 ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
1232 (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0)))) {
1233 pa_log_warn("Unsupported resampling operation.");
1234 return -PA_ERR_NOTSUPPORTED;
1237 new_resampler = NULL;
1243 i->save_sink = save;
1244 pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1246 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1247 i->sink->n_corked++;
1249 /* Replace resampler and render queue */
1250 if (new_resampler != i->thread_info.resampler) {
1252 if (i->thread_info.resampler)
1253 pa_resampler_free(i->thread_info.resampler);
1254 i->thread_info.resampler = new_resampler;
1256 pa_memblockq_free(i->thread_info.render_memblockq);
1258 i->thread_info.render_memblockq = pa_memblockq_new(
1260 MEMBLOCKQ_MAXLENGTH,
1262 pa_frame_size(&i->sink->sample_spec),
1268 pa_sink_update_status(dest);
1270 if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
1271 pa_cvolume remapped;
1273 /* Make relative volumes absolute */
1274 remapped = dest->reference_volume;
1275 pa_cvolume_remap(&remapped, &dest->channel_map, &i->channel_map);
1276 pa_sw_cvolume_multiply(&i->volume, &i->reference_ratio, &remapped);
1278 /* We might need to update the sink's volume if we are in flat volume mode. */
1279 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
1282 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1284 pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1286 /* Notify everyone */
1287 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1289 if (i->volume_changed)
1290 i->volume_changed(i);
1292 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1297 /* Called from main context */
1298 void pa_sink_input_fail_move(pa_sink_input *i) {
1300 pa_sink_input_assert_ref(i);
1301 pa_assert_ctl_context();
1302 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1303 pa_assert(!i->sink);
1305 /* Check if someone wants this sink input? */
1306 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1312 pa_sink_input_kill(i);
1315 /* Called from main context */
1316 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1319 pa_sink_input_assert_ref(i);
1320 pa_assert_ctl_context();
1321 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1323 pa_sink_assert_ref(dest);
1325 if (dest == i->sink)
1328 if (!pa_sink_input_may_move_to(i, dest))
1329 return -PA_ERR_NOTSUPPORTED;
1331 pa_sink_input_ref(i);
1333 if ((r = pa_sink_input_start_move(i)) < 0) {
1334 pa_sink_input_unref(i);
1338 if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1339 pa_sink_input_fail_move(i);
1340 pa_sink_input_unref(i);
1344 pa_sink_input_unref(i);
1349 /* Called from IO thread context */
1350 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1351 pa_bool_t corking, uncorking;
1353 pa_sink_input_assert_ref(i);
1354 pa_sink_input_assert_io_context(i);
1356 if (state == i->thread_info.state)
1359 if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1360 !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1361 pa_atomic_store(&i->thread_info.drained, 1);
1363 corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1364 uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1366 if (i->state_change)
1367 i->state_change(i, state);
1369 i->thread_info.state = state;
1373 pa_log_debug("Requesting rewind due to corking");
1375 /* This will tell the implementing sink input driver to rewind
1376 * so that the unplayed already mixed data is not lost */
1377 pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1379 } else if (uncorking) {
1381 i->thread_info.underrun_for = (uint64_t) -1;
1382 i->thread_info.playing_for = 0;
1384 pa_log_debug("Requesting rewind due to uncorking");
1386 /* OK, we're being uncorked. Make sure we're not rewound when
1387 * the hw buffer is remixed and request a remix. */
1388 pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1392 /* Called from thread context, except when it is not. */
1393 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1394 pa_sink_input *i = PA_SINK_INPUT(o);
1395 pa_sink_input_assert_ref(i);
1399 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1400 if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1401 i->thread_info.soft_volume = i->soft_volume;
1402 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1406 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1407 if (i->thread_info.muted != i->muted) {
1408 i->thread_info.muted = i->muted;
1409 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1413 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1414 pa_usec_t *r = userdata;
1416 r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1417 r[1] += pa_sink_get_latency_within_thread(i->sink);
1422 case PA_SINK_INPUT_MESSAGE_SET_RATE:
1424 i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1425 pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1429 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1430 pa_sink_input *ssync;
1432 pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
1434 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
1435 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1437 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
1438 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1443 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
1444 pa_usec_t *usec = userdata;
1446 *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
1450 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
1451 pa_usec_t *r = userdata;
1453 *r = i->thread_info.requested_sink_latency;
1458 return -PA_ERR_NOTIMPLEMENTED;
1461 /* Called from main thread */
1462 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
1463 pa_sink_input_assert_ref(i);
1464 pa_assert_ctl_context();
1466 if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
1467 return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
1472 /* Called from IO context */
1473 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
1474 pa_sink_input_assert_ref(i);
1475 pa_sink_input_assert_io_context(i);
1477 if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
1478 return pa_memblockq_is_empty(i->thread_info.render_memblockq);
1483 /* Called from IO context */
1484 void pa_sink_input_request_rewind(
1486 size_t nbytes /* in our sample spec */,
1489 pa_bool_t dont_rewind_render) {
1493 /* If 'rewrite' is TRUE the sink is rewound as far as requested
1494 * and possible and the exact value of this is passed back the
1495 * implementor via process_rewind(). If 'flush' is also TRUE all
1496 * already rendered data is also dropped.
1498 * If 'rewrite' is FALSE the sink is rewound as far as requested
1499 * and possible and the already rendered data is dropped so that
1500 * in the next iteration we read new data from the
1501 * implementor. This implies 'flush' is TRUE. If
1502 * dont_rewind_render is TRUE then the render memblockq is not
1505 /* nbytes = 0 means maximum rewind request */
1507 pa_sink_input_assert_ref(i);
1508 pa_sink_input_assert_io_context(i);
1509 pa_assert(rewrite || flush);
1510 pa_assert(!dont_rewind_render || !rewrite);
1512 /* We don't take rewind requests while we are corked */
1513 if (i->thread_info.state == PA_SINK_INPUT_CORKED)
1516 nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
1518 /* pa_log_debug("request rewrite %zu", nbytes); */
1520 /* Calculate how much we can rewind locally without having to
1523 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1527 /* Check if rewinding for the maximum is requested, and if so, fix up */
1530 /* Calculate maximum number of bytes that could be rewound in theory */
1531 nbytes = i->sink->thread_info.max_rewind + lbq;
1533 /* Transform from sink domain */
1534 if (i->thread_info.resampler)
1535 nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
1538 /* Remember how much we actually want to rewrite */
1539 if (i->thread_info.rewrite_nbytes != (size_t) -1) {
1541 /* Make sure to not overwrite over underruns */
1542 if (nbytes > i->thread_info.playing_for)
1543 nbytes = (size_t) i->thread_info.playing_for;
1545 i->thread_info.rewrite_nbytes = nbytes;
1547 i->thread_info.rewrite_nbytes = (size_t) -1;
1550 i->thread_info.rewrite_flush =
1551 i->thread_info.rewrite_flush ||
1552 (flush && i->thread_info.rewrite_nbytes != 0);
1554 i->thread_info.dont_rewind_render =
1555 i->thread_info.dont_rewind_render ||
1558 if (nbytes != (size_t) -1) {
1560 /* Transform to sink domain */
1561 if (i->thread_info.resampler)
1562 nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
1565 pa_sink_request_rewind(i->sink, nbytes - lbq);
1567 /* This call will make sure process_rewind() is called later */
1568 pa_sink_request_rewind(i->sink, 0);
1572 /* Called from main context */
1573 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
1574 pa_sink_input_assert_ref(i);
1575 pa_assert_ctl_context();
1578 /* FIXME: Shouldn't access resampler object from main context! */
1580 pa_silence_memchunk_get(
1581 &i->core->silence_cache,
1585 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
1590 /* Called from main context */
1591 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
1592 pa_proplist *pl = NULL;
1593 pa_sink_input_send_event_hook_data hook_data;
1595 pa_sink_input_assert_ref(i);
1596 pa_assert_ctl_context();
1603 data = pl = pa_proplist_new();
1605 hook_data.sink_input = i;
1606 hook_data.data = data;
1607 hook_data.event = event;
1609 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
1612 i->send_event(i, event, data);
1616 pa_proplist_free(pl);