2 This file is part of PulseAudio.
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
30 #include <pulse/utf8.h>
31 #include <pulse/xmalloc.h>
32 #include <pulse/util.h>
33 #include <pulse/internal.h>
35 #include <pulsecore/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 SINK_INPUT_DEBUG */
46 #define MEMBLOCKQ_MAXLENGTH (32*1024*1024)
47 #define CONVERT_BUFFER_LENGTH (PA_PAGE_SIZE)
49 PA_DEFINE_PUBLIC_CLASS(pa_sink_input, pa_msgobject);
51 static void sink_input_free(pa_object *o);
52 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v);
54 static int check_passthrough_connection(pa_bool_t passthrough, pa_sink *dest) {
55 if (pa_sink_is_passthrough(dest)) {
56 pa_log_warn("Sink is already connected to PASSTHROUGH input");
60 /* If current input(s) exist, check new input is not PASSTHROUGH */
61 if (pa_idxset_size(dest->inputs) > 0 && passthrough) {
62 pa_log_warn("Sink is already connected, cannot accept new PASSTHROUGH INPUT");
69 pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data) {
73 data->resample_method = PA_RESAMPLER_INVALID;
74 data->proplist = pa_proplist_new();
75 data->volume_writable = TRUE;
80 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec) {
83 if ((data->sample_spec_is_set = !!spec))
84 data->sample_spec = *spec;
87 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map) {
90 if ((data->channel_map_is_set = !!map))
91 data->channel_map = *map;
94 pa_bool_t pa_sink_input_new_data_is_passthrough(pa_sink_input_new_data *data) {
97 if (PA_LIKELY(data->format) && PA_UNLIKELY(!pa_format_info_is_pcm(data->format)))
100 if (PA_UNLIKELY(data->flags & PA_SINK_INPUT_PASSTHROUGH))
106 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume) {
108 pa_assert(data->volume_writable);
110 if ((data->volume_is_set = !!volume))
111 data->volume = *volume;
114 void pa_sink_input_new_data_apply_volume_factor(pa_sink_input_new_data *data, const pa_cvolume *volume_factor) {
116 pa_assert(volume_factor);
118 if (data->volume_factor_is_set)
119 pa_sw_cvolume_multiply(&data->volume_factor, &data->volume_factor, volume_factor);
121 data->volume_factor_is_set = TRUE;
122 data->volume_factor = *volume_factor;
126 void pa_sink_input_new_data_apply_volume_factor_sink(pa_sink_input_new_data *data, const pa_cvolume *volume_factor) {
128 pa_assert(volume_factor);
130 if (data->volume_factor_sink_is_set)
131 pa_sw_cvolume_multiply(&data->volume_factor_sink, &data->volume_factor_sink, volume_factor);
133 data->volume_factor_sink_is_set = TRUE;
134 data->volume_factor_sink = *volume_factor;
138 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, pa_bool_t mute) {
141 data->muted_is_set = TRUE;
142 data->muted = !!mute;
145 pa_bool_t pa_sink_input_new_data_set_sink(pa_sink_input_new_data *data, pa_sink *s, pa_bool_t save) {
146 pa_bool_t ret = TRUE;
147 pa_idxset *formats = NULL;
152 if (!data->req_formats) {
153 /* We're not working with the extended API */
155 data->save_sink = save;
157 /* Extended API: let's see if this sink supports the formats the client can provide */
158 formats = pa_sink_check_formats(s, data->req_formats);
160 if (formats && !pa_idxset_isempty(formats)) {
161 /* Sink supports at least one of the requested formats */
163 data->save_sink = save;
164 if (data->nego_formats)
165 pa_idxset_free(data->nego_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
166 data->nego_formats = formats;
168 /* Sink doesn't support any of the formats requested by the client */
170 pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
178 pa_bool_t pa_sink_input_new_data_set_formats(pa_sink_input_new_data *data, pa_idxset *formats) {
182 if (data->req_formats)
183 pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
185 data->req_formats = formats;
188 /* Trigger format negotiation */
189 return pa_sink_input_new_data_set_sink(data, data->sink, data->save_sink);
195 void pa_sink_input_new_data_done(pa_sink_input_new_data *data) {
198 if (data->req_formats)
199 pa_idxset_free(data->req_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
201 if (data->nego_formats)
202 pa_idxset_free(data->nego_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
205 pa_format_info_free(data->format);
207 pa_proplist_free(data->proplist);
210 /* Called from main context */
211 static void reset_callbacks(pa_sink_input *i) {
215 i->process_rewind = NULL;
216 i->update_max_rewind = NULL;
217 i->update_max_request = NULL;
218 i->update_sink_requested_latency = NULL;
219 i->update_sink_latency_range = NULL;
220 i->update_sink_fixed_latency = NULL;
224 i->suspend_within_thread = NULL;
227 i->get_latency = NULL;
228 i->state_change = NULL;
229 i->may_move_to = NULL;
230 i->send_event = NULL;
231 i->volume_changed = NULL;
232 i->mute_changed = NULL;
235 /* Called from main context */
236 int pa_sink_input_new(
239 pa_sink_input_new_data *data) {
242 pa_resampler *resampler = NULL;
243 char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
244 pa_channel_map original_cm;
247 char *memblockq_name;
254 pa_assert_ctl_context();
257 pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->client->proplist);
259 if (data->origin_sink && (data->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
260 data->volume_writable = FALSE;
262 if (!data->req_formats) {
263 /* From this point on, we want to work only with formats, and get back
264 * to using the sample spec and channel map after all decisions w.r.t.
265 * routing are complete. */
266 pa_idxset *tmp = pa_idxset_new(NULL, NULL);
267 pa_format_info *f = pa_format_info_from_sample_spec(&data->sample_spec,
268 data->channel_map_is_set ? &data->channel_map : NULL);
269 pa_idxset_put(tmp, f, NULL);
270 pa_sink_input_new_data_set_formats(data, tmp);
273 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], data)) < 0)
276 pa_return_val_if_fail(!data->driver || pa_utf8_valid(data->driver), -PA_ERR_INVALID);
279 pa_sink *sink = pa_namereg_get(core, NULL, PA_NAMEREG_SINK);
280 pa_return_val_if_fail(sink, -PA_ERR_NOENTITY);
281 pa_sink_input_new_data_set_sink(data, sink, FALSE);
283 /* Routing's done, we have a sink. Now let's fix the format and set up the
286 /* If something didn't pick a format for us, pick the top-most format since
287 * we assume this is sorted in priority order */
288 if (!data->format && data->nego_formats && !pa_idxset_isempty(data->nego_formats))
289 data->format = pa_format_info_copy(pa_idxset_first(data->nego_formats, NULL));
291 pa_return_val_if_fail(data->format, -PA_ERR_NOTSUPPORTED);
293 /* Now populate the sample spec and format according to the final
294 * format that we've negotiated */
295 if (PA_LIKELY(data->format->encoding == PA_ENCODING_PCM)) {
296 pa_return_val_if_fail(pa_format_info_to_sample_spec(data->format, &ss, &map), -PA_ERR_INVALID);
297 pa_sink_input_new_data_set_sample_spec(data, &ss);
298 if (pa_channel_map_valid(&map))
299 pa_sink_input_new_data_set_channel_map(data, &map);
301 pa_return_val_if_fail(pa_format_info_to_sample_spec_fake(data->format, &ss), -PA_ERR_INVALID);
302 pa_sink_input_new_data_set_sample_spec(data, &ss);
305 pa_return_val_if_fail(PA_SINK_IS_LINKED(pa_sink_get_state(data->sink)), -PA_ERR_BADSTATE);
306 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);
308 r = check_passthrough_connection(pa_sink_input_new_data_is_passthrough(data), data->sink);
312 if (!data->sample_spec_is_set)
313 data->sample_spec = data->sink->sample_spec;
315 pa_return_val_if_fail(pa_sample_spec_valid(&data->sample_spec), -PA_ERR_INVALID);
317 if (!data->channel_map_is_set) {
318 if (pa_channel_map_compatible(&data->sink->channel_map, &data->sample_spec))
319 data->channel_map = data->sink->channel_map;
321 pa_channel_map_init_extend(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
324 pa_return_val_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec), -PA_ERR_INVALID);
326 /* Don't restore (or save) stream volume for passthrough streams and
327 * prevent attenuation/gain */
328 if (pa_sink_input_new_data_is_passthrough(data)) {
329 data->volume_is_set = TRUE;
330 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
331 data->volume_is_absolute = TRUE;
332 data->save_volume = FALSE;
335 if (!data->volume_is_set) {
336 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
337 data->volume_is_absolute = FALSE;
338 data->save_volume = FALSE;
341 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec), -PA_ERR_INVALID);
343 if (!data->volume_factor_is_set)
344 pa_cvolume_reset(&data->volume_factor, data->sample_spec.channels);
346 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume_factor, &data->sample_spec), -PA_ERR_INVALID);
348 if (!data->volume_factor_sink_is_set)
349 pa_cvolume_reset(&data->volume_factor_sink, data->sink->sample_spec.channels);
351 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume_factor_sink, &data->sink->sample_spec), -PA_ERR_INVALID);
353 if (!data->muted_is_set)
356 if (data->flags & PA_SINK_INPUT_FIX_FORMAT)
357 data->sample_spec.format = data->sink->sample_spec.format;
359 if (data->flags & PA_SINK_INPUT_FIX_RATE)
360 data->sample_spec.rate = data->sink->sample_spec.rate;
362 original_cm = data->channel_map;
364 if (data->flags & PA_SINK_INPUT_FIX_CHANNELS) {
365 data->sample_spec.channels = data->sink->sample_spec.channels;
366 data->channel_map = data->sink->channel_map;
369 pa_assert(pa_sample_spec_valid(&data->sample_spec));
370 pa_assert(pa_channel_map_valid(&data->channel_map));
372 if (!(data->flags & PA_SINK_INPUT_VARIABLE_RATE) &&
373 !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec)) {
374 /* try to change sink rate. This is done before the FIXATE hook since
375 module-suspend-on-idle can resume a sink */
377 pa_log_info("Trying to change sample rate");
378 if (pa_sink_update_rate(data->sink, data->sample_spec.rate, pa_sink_input_new_data_is_passthrough(data)) == TRUE)
379 pa_log_info("Rate changed to %u kHz",
380 data->sink->sample_spec.rate);
382 pa_log_info("Resampling enabled to %u kHz", data->sink->sample_spec.rate);
385 /* Due to the fixing of the sample spec the volume might not match anymore */
386 pa_cvolume_remap(&data->volume, &original_cm, &data->channel_map);
388 if (data->resample_method == PA_RESAMPLER_INVALID)
389 data->resample_method = core->resample_method;
391 pa_return_val_if_fail(data->resample_method < PA_RESAMPLER_MAX, -PA_ERR_INVALID);
393 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], data)) < 0)
396 if ((data->flags & PA_SINK_INPUT_NO_CREATE_ON_SUSPEND) &&
397 pa_sink_get_state(data->sink) == PA_SINK_SUSPENDED) {
398 pa_log_warn("Failed to create sink input: sink is suspended.");
399 return -PA_ERR_BADSTATE;
402 if (pa_idxset_size(data->sink->inputs) >= PA_MAX_INPUTS_PER_SINK) {
403 pa_log_warn("Failed to create sink input: too many inputs per sink.");
404 return -PA_ERR_TOOLARGE;
407 if ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
408 !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec) ||
409 !pa_channel_map_equal(&data->channel_map, &data->sink->channel_map)) {
411 /* Note: for passthrough content we need to adjust the output rate to that of the current sink-input */
412 if (!pa_sink_input_new_data_is_passthrough(data)) /* no resampler for passthrough content */
413 if (!(resampler = pa_resampler_new(
415 &data->sample_spec, &data->channel_map,
416 &data->sink->sample_spec, &data->sink->channel_map,
417 data->resample_method,
418 ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
419 ((data->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
420 (core->disable_remixing || (data->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0) |
421 (core->disable_lfe_remixing ? PA_RESAMPLER_NO_LFE : 0)))) {
422 pa_log_warn("Unsupported resampling operation.");
423 return -PA_ERR_NOTSUPPORTED;
427 i = pa_msgobject_new(pa_sink_input);
428 i->parent.parent.free = sink_input_free;
429 i->parent.process_msg = pa_sink_input_process_msg;
432 i->state = PA_SINK_INPUT_INIT;
433 i->flags = data->flags;
434 i->proplist = pa_proplist_copy(data->proplist);
435 i->driver = pa_xstrdup(pa_path_get_filename(data->driver));
436 i->module = data->module;
437 i->sink = data->sink;
438 i->origin_sink = data->origin_sink;
439 i->client = data->client;
441 i->requested_resample_method = data->resample_method;
442 i->actual_resample_method = resampler ? pa_resampler_get_method(resampler) : PA_RESAMPLER_INVALID;
443 i->sample_spec = data->sample_spec;
444 i->channel_map = data->channel_map;
445 i->format = pa_format_info_copy(data->format);
447 if (!data->volume_is_absolute && pa_sink_flat_volume_enabled(i->sink)) {
450 /* When the 'absolute' bool is not set then we'll treat the volume
451 * as relative to the sink volume even in flat volume mode */
452 remapped = data->sink->reference_volume;
453 pa_cvolume_remap(&remapped, &data->sink->channel_map, &data->channel_map);
454 pa_sw_cvolume_multiply(&i->volume, &data->volume, &remapped);
456 i->volume = data->volume;
458 i->volume_factor = data->volume_factor;
459 i->volume_factor_sink = data->volume_factor_sink;
460 i->real_ratio = i->reference_ratio = data->volume;
461 pa_cvolume_reset(&i->soft_volume, i->sample_spec.channels);
462 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
463 i->volume_writable = data->volume_writable;
464 i->save_volume = data->save_volume;
465 i->save_sink = data->save_sink;
466 i->save_muted = data->save_muted;
468 i->muted = data->muted;
470 if (data->sync_base) {
471 i->sync_next = data->sync_base->sync_next;
472 i->sync_prev = data->sync_base;
474 if (data->sync_base->sync_next)
475 data->sync_base->sync_next->sync_prev = i;
476 data->sync_base->sync_next = i;
478 i->sync_next = i->sync_prev = NULL;
480 i->direct_outputs = pa_idxset_new(NULL, NULL);
485 i->thread_info.state = i->state;
486 i->thread_info.attached = FALSE;
487 pa_atomic_store(&i->thread_info.drained, 1);
488 i->thread_info.sample_spec = i->sample_spec;
489 i->thread_info.resampler = resampler;
490 i->thread_info.soft_volume = i->soft_volume;
491 i->thread_info.muted = i->muted;
492 i->thread_info.requested_sink_latency = (pa_usec_t) -1;
493 i->thread_info.rewrite_nbytes = 0;
494 i->thread_info.rewrite_flush = FALSE;
495 i->thread_info.dont_rewind_render = FALSE;
496 i->thread_info.underrun_for = (uint64_t) -1;
497 i->thread_info.playing_for = 0;
498 i->thread_info.direct_outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
500 pa_assert_se(pa_idxset_put(core->sink_inputs, i, &i->index) == 0);
501 pa_assert_se(pa_idxset_put(i->sink->inputs, pa_sink_input_ref(i), NULL) == 0);
504 pa_assert_se(pa_idxset_put(i->client->sink_inputs, i, NULL) >= 0);
506 memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
507 i->thread_info.render_memblockq = pa_memblockq_new(
512 &i->sink->sample_spec,
517 pa_xfree(memblockq_name);
519 pt = pa_proplist_to_string_sep(i->proplist, "\n ");
520 pa_log_info("Created input %u \"%s\" on %s with sample spec %s and channel map %s\n %s",
522 pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)),
524 pa_sample_spec_snprint(st, sizeof(st), &i->sample_spec),
525 pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
529 /* Don't forget to call pa_sink_input_put! */
535 /* Called from main context */
536 static void update_n_corked(pa_sink_input *i, pa_sink_input_state_t state) {
538 pa_assert_ctl_context();
543 if (i->state == PA_SINK_INPUT_CORKED && state != PA_SINK_INPUT_CORKED)
544 pa_assert_se(i->sink->n_corked -- >= 1);
545 else if (i->state != PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_CORKED)
549 /* Called from main context */
550 static void sink_input_set_state(pa_sink_input *i, pa_sink_input_state_t state) {
551 pa_sink_input *ssync;
553 pa_assert_ctl_context();
555 if (state == PA_SINK_INPUT_DRAINED)
556 state = PA_SINK_INPUT_RUNNING;
558 if (i->state == state)
561 if (i->state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING && pa_sink_used_by(i->sink) == 0) {
562 /* We were uncorked and the sink was not playing anything -- let's try
563 * to update the sample rate to avoid resampling */
564 pa_sink_update_rate(i->sink, i->sample_spec.rate, pa_sink_input_is_passthrough(i));
567 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);
569 update_n_corked(i, state);
572 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev) {
573 update_n_corked(ssync, state);
574 ssync->state = state;
576 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next) {
577 update_n_corked(ssync, state);
578 ssync->state = state;
581 if (state != PA_SINK_INPUT_UNLINKED) {
582 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], i);
584 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev)
585 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
587 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next)
588 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
590 if (PA_SINK_INPUT_IS_LINKED(state))
591 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
594 pa_sink_update_status(i->sink);
597 /* Called from main context */
598 void pa_sink_input_unlink(pa_sink_input *i) {
600 pa_source_output *o, *p = NULL;
603 pa_assert_ctl_context();
605 /* See pa_sink_unlink() for a couple of comments how this function
608 pa_sink_input_ref(i);
610 linked = PA_SINK_INPUT_IS_LINKED(i->state);
613 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], i);
616 i->sync_prev->sync_next = i->sync_next;
618 i->sync_next->sync_prev = i->sync_prev;
620 i->sync_prev = i->sync_next = NULL;
622 pa_idxset_remove_by_data(i->core->sink_inputs, i, NULL);
625 if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL))
626 pa_sink_input_unref(i);
629 pa_idxset_remove_by_data(i->client->sink_inputs, i, NULL);
631 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
633 pa_source_output_kill(o);
637 update_n_corked(i, PA_SINK_INPUT_UNLINKED);
638 i->state = PA_SINK_INPUT_UNLINKED;
640 if (linked && i->sink) {
641 if (pa_sink_input_is_passthrough(i))
642 pa_sink_leave_passthrough(i->sink);
644 /* We might need to update the sink's volume if we are in flat volume mode. */
645 if (pa_sink_flat_volume_enabled(i->sink))
646 pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
648 if (i->sink->asyncmsgq)
649 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_REMOVE_INPUT, i, 0, NULL) == 0);
655 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_REMOVE, i->index);
656 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST], i);
660 pa_sink_update_status(i->sink);
664 pa_core_maybe_vacuum(i->core);
666 pa_sink_input_unref(i);
669 /* Called from main context */
670 static void sink_input_free(pa_object *o) {
671 pa_sink_input* i = PA_SINK_INPUT(o);
674 pa_assert_ctl_context();
675 pa_assert(pa_sink_input_refcnt(i) == 0);
677 if (PA_SINK_INPUT_IS_LINKED(i->state))
678 pa_sink_input_unlink(i);
680 pa_log_info("Freeing input %u \"%s\"", i->index, pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)));
682 /* Side note: this function must be able to destruct properly any
683 * kind of sink input in any state, even those which are
684 * "half-moved" or are connected to sinks that have no asyncmsgq
685 * and are hence half-destructed themselves! */
687 if (i->thread_info.render_memblockq)
688 pa_memblockq_free(i->thread_info.render_memblockq);
690 if (i->thread_info.resampler)
691 pa_resampler_free(i->thread_info.resampler);
694 pa_format_info_free(i->format);
697 pa_proplist_free(i->proplist);
699 if (i->direct_outputs)
700 pa_idxset_free(i->direct_outputs, NULL, NULL);
702 if (i->thread_info.direct_outputs)
703 pa_hashmap_free(i->thread_info.direct_outputs, NULL, NULL);
709 /* Called from main context */
710 void pa_sink_input_put(pa_sink_input *i) {
711 pa_sink_input_state_t state;
713 pa_sink_input_assert_ref(i);
714 pa_assert_ctl_context();
716 pa_assert(i->state == PA_SINK_INPUT_INIT);
718 /* The following fields must be initialized properly */
720 pa_assert(i->process_rewind);
723 state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING;
725 update_n_corked(i, state);
728 /* We might need to update the sink's volume if we are in flat volume mode. */
729 if (pa_sink_flat_volume_enabled(i->sink))
730 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
732 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
733 pa_assert(pa_cvolume_is_norm(&i->volume));
734 pa_assert(pa_cvolume_is_norm(&i->reference_ratio));
737 set_real_ratio(i, &i->volume);
740 if (pa_sink_input_is_passthrough(i))
741 pa_sink_enter_passthrough(i->sink);
743 i->thread_info.soft_volume = i->soft_volume;
744 i->thread_info.muted = i->muted;
746 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_ADD_INPUT, i, 0, NULL) == 0);
748 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, i->index);
749 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], i);
751 pa_sink_update_status(i->sink);
754 /* Called from main context */
755 void pa_sink_input_kill(pa_sink_input*i) {
756 pa_sink_input_assert_ref(i);
757 pa_assert_ctl_context();
758 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
763 /* Called from main context */
764 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency) {
765 pa_usec_t r[2] = { 0, 0 };
767 pa_sink_input_assert_ref(i);
768 pa_assert_ctl_context();
769 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
771 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_LATENCY, r, 0, NULL) == 0);
774 r[0] += i->get_latency(i);
777 *sink_latency = r[1];
782 /* Called from thread context */
783 void pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink frames */, pa_memchunk *chunk, pa_cvolume *volume) {
784 pa_bool_t do_volume_adj_here, need_volume_factor_sink;
785 pa_bool_t volume_is_norm;
786 size_t block_size_max_sink, block_size_max_sink_input;
789 pa_sink_input_assert_ref(i);
790 pa_sink_input_assert_io_context(i);
791 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
792 pa_assert(pa_frame_aligned(slength, &i->sink->sample_spec));
796 #ifdef SINK_INPUT_DEBUG
797 pa_log_debug("peek");
800 block_size_max_sink_input = i->thread_info.resampler ?
801 pa_resampler_max_block_size(i->thread_info.resampler) :
802 pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sample_spec);
804 block_size_max_sink = pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sink->sample_spec);
806 /* Default buffer size */
808 slength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sink->sample_spec);
810 if (slength > block_size_max_sink)
811 slength = block_size_max_sink;
813 if (i->thread_info.resampler) {
814 ilength = pa_resampler_request(i->thread_info.resampler, slength);
817 ilength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sample_spec);
821 if (ilength > block_size_max_sink_input)
822 ilength = block_size_max_sink_input;
824 /* If the channel maps of the sink and this stream differ, we need
825 * to adjust the volume *before* we resample. Otherwise we can do
826 * it after and leave it for the sink code */
828 do_volume_adj_here = !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map);
829 volume_is_norm = pa_cvolume_is_norm(&i->thread_info.soft_volume) && !i->thread_info.muted;
830 need_volume_factor_sink = !pa_cvolume_is_norm(&i->volume_factor_sink);
832 while (!pa_memblockq_is_readable(i->thread_info.render_memblockq)) {
835 /* There's nothing in our render queue. We need to fill it up
836 * with data from the implementor. */
838 if (i->thread_info.state == PA_SINK_INPUT_CORKED ||
839 i->pop(i, ilength, &tchunk) < 0) {
841 /* OK, we're corked or the implementor didn't give us any
842 * data, so let's just hand out silence */
843 pa_atomic_store(&i->thread_info.drained, 1);
845 pa_memblockq_seek(i->thread_info.render_memblockq, (int64_t) slength, PA_SEEK_RELATIVE, TRUE);
846 i->thread_info.playing_for = 0;
847 if (i->thread_info.underrun_for != (uint64_t) -1)
848 i->thread_info.underrun_for += ilength;
852 pa_atomic_store(&i->thread_info.drained, 0);
854 pa_assert(tchunk.length > 0);
855 pa_assert(tchunk.memblock);
857 i->thread_info.underrun_for = 0;
858 i->thread_info.playing_for += tchunk.length;
860 while (tchunk.length > 0) {
862 pa_bool_t nvfs = need_volume_factor_sink;
865 pa_memblock_ref(wchunk.memblock);
867 if (wchunk.length > block_size_max_sink_input)
868 wchunk.length = block_size_max_sink_input;
870 /* It might be necessary to adjust the volume here */
871 if (do_volume_adj_here && !volume_is_norm) {
872 pa_memchunk_make_writable(&wchunk, 0);
874 if (i->thread_info.muted) {
875 pa_silence_memchunk(&wchunk, &i->thread_info.sample_spec);
878 } else if (!i->thread_info.resampler && nvfs) {
881 /* If we don't need a resampler we can merge the
882 * post and the pre volume adjustment into one */
884 pa_sw_cvolume_multiply(&v, &i->thread_info.soft_volume, &i->volume_factor_sink);
885 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &v);
889 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.soft_volume);
892 if (!i->thread_info.resampler) {
895 pa_memchunk_make_writable(&wchunk, 0);
896 pa_volume_memchunk(&wchunk, &i->sink->sample_spec, &i->volume_factor_sink);
899 pa_memblockq_push_align(i->thread_info.render_memblockq, &wchunk);
902 pa_resampler_run(i->thread_info.resampler, &wchunk, &rchunk);
904 #ifdef SINK_INPUT_DEBUG
905 pa_log_debug("pushing %lu", (unsigned long) rchunk.length);
908 if (rchunk.memblock) {
911 pa_memchunk_make_writable(&rchunk, 0);
912 pa_volume_memchunk(&rchunk, &i->sink->sample_spec, &i->volume_factor_sink);
915 pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk);
916 pa_memblock_unref(rchunk.memblock);
920 pa_memblock_unref(wchunk.memblock);
922 tchunk.index += wchunk.length;
923 tchunk.length -= wchunk.length;
926 pa_memblock_unref(tchunk.memblock);
929 pa_assert_se(pa_memblockq_peek(i->thread_info.render_memblockq, chunk) >= 0);
931 pa_assert(chunk->length > 0);
932 pa_assert(chunk->memblock);
934 #ifdef SINK_INPUT_DEBUG
935 pa_log_debug("peeking %lu", (unsigned long) chunk->length);
938 if (chunk->length > block_size_max_sink)
939 chunk->length = block_size_max_sink;
941 /* Let's see if we had to apply the volume adjustment ourselves,
942 * or if this can be done by the sink for us */
944 if (do_volume_adj_here)
945 /* We had different channel maps, so we already did the adjustment */
946 pa_cvolume_reset(volume, i->sink->sample_spec.channels);
947 else if (i->thread_info.muted)
948 /* We've both the same channel map, so let's have the sink do the adjustment for us*/
949 pa_cvolume_mute(volume, i->sink->sample_spec.channels);
951 *volume = i->thread_info.soft_volume;
954 /* Called from thread context */
955 void pa_sink_input_drop(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
957 pa_sink_input_assert_ref(i);
958 pa_sink_input_assert_io_context(i);
959 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
960 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
961 pa_assert(nbytes > 0);
963 #ifdef SINK_INPUT_DEBUG
964 pa_log_debug("dropping %lu", (unsigned long) nbytes);
967 pa_memblockq_drop(i->thread_info.render_memblockq, nbytes);
970 /* Called from thread context */
971 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
973 pa_bool_t called = FALSE;
975 pa_sink_input_assert_ref(i);
976 pa_sink_input_assert_io_context(i);
977 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
978 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
980 #ifdef SINK_INPUT_DEBUG
981 pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes);
984 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
986 if (nbytes > 0 && !i->thread_info.dont_rewind_render) {
987 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes);
988 pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes);
991 if (i->thread_info.rewrite_nbytes == (size_t) -1) {
993 /* We were asked to drop all buffered data, and rerequest new
994 * data from implementor the next time push() is called */
996 pa_memblockq_flush_write(i->thread_info.render_memblockq, TRUE);
998 } else if (i->thread_info.rewrite_nbytes > 0) {
999 size_t max_rewrite, amount;
1001 /* Calculate how much make sense to rewrite at most */
1002 max_rewrite = nbytes + lbq;
1004 /* Transform into local domain */
1005 if (i->thread_info.resampler)
1006 max_rewrite = pa_resampler_request(i->thread_info.resampler, max_rewrite);
1008 /* Calculate how much of the rewinded data should actually be rewritten */
1009 amount = PA_MIN(i->thread_info.rewrite_nbytes, max_rewrite);
1012 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount);
1014 /* Tell the implementor */
1015 if (i->process_rewind)
1016 i->process_rewind(i, amount);
1019 /* Convert back to to sink domain */
1020 if (i->thread_info.resampler)
1021 amount = pa_resampler_result(i->thread_info.resampler, amount);
1024 /* Ok, now update the write pointer */
1025 pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) amount), PA_SEEK_RELATIVE, TRUE);
1027 if (i->thread_info.rewrite_flush)
1028 pa_memblockq_silence(i->thread_info.render_memblockq);
1030 /* And reset the resampler */
1031 if (i->thread_info.resampler)
1032 pa_resampler_reset(i->thread_info.resampler);
1037 if (i->process_rewind)
1038 i->process_rewind(i, 0);
1040 i->thread_info.rewrite_nbytes = 0;
1041 i->thread_info.rewrite_flush = FALSE;
1042 i->thread_info.dont_rewind_render = FALSE;
1045 /* Called from thread context */
1046 size_t pa_sink_input_get_max_rewind(pa_sink_input *i) {
1047 pa_sink_input_assert_ref(i);
1048 pa_sink_input_assert_io_context(i);
1050 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_rewind) : i->sink->thread_info.max_rewind;
1053 /* Called from thread context */
1054 size_t pa_sink_input_get_max_request(pa_sink_input *i) {
1055 pa_sink_input_assert_ref(i);
1056 pa_sink_input_assert_io_context(i);
1058 /* We're not verifying the status here, to allow this to be called
1059 * in the state change handler between _INIT and _RUNNING */
1061 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_request) : i->sink->thread_info.max_request;
1064 /* Called from thread context */
1065 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1066 pa_sink_input_assert_ref(i);
1067 pa_sink_input_assert_io_context(i);
1068 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1069 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1071 pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes);
1073 if (i->update_max_rewind)
1074 i->update_max_rewind(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1077 /* Called from thread context */
1078 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1079 pa_sink_input_assert_ref(i);
1080 pa_sink_input_assert_io_context(i);
1081 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1082 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1084 if (i->update_max_request)
1085 i->update_max_request(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1088 /* Called from thread context */
1089 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) {
1090 pa_sink_input_assert_ref(i);
1091 pa_sink_input_assert_io_context(i);
1093 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1094 usec = i->sink->thread_info.fixed_latency;
1096 if (usec != (pa_usec_t) -1)
1097 usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
1099 i->thread_info.requested_sink_latency = usec;
1100 pa_sink_invalidate_requested_latency(i->sink, TRUE);
1105 /* Called from main context */
1106 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) {
1107 pa_sink_input_assert_ref(i);
1108 pa_assert_ctl_context();
1110 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1111 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1115 /* If this sink input is not realized yet or we are being moved,
1116 * we have to touch the thread info data directly */
1119 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1120 usec = pa_sink_get_fixed_latency(i->sink);
1122 if (usec != (pa_usec_t) -1) {
1123 pa_usec_t min_latency, max_latency;
1124 pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
1125 usec = PA_CLAMP(usec, min_latency, max_latency);
1129 i->thread_info.requested_sink_latency = usec;
1134 /* Called from main context */
1135 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
1136 pa_sink_input_assert_ref(i);
1137 pa_assert_ctl_context();
1139 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1141 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1145 /* If this sink input is not realized yet or we are being moved,
1146 * we have to touch the thread info data directly */
1148 return i->thread_info.requested_sink_latency;
1151 /* Called from main context */
1152 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, pa_bool_t save, pa_bool_t absolute) {
1155 pa_sink_input_assert_ref(i);
1156 pa_assert_ctl_context();
1157 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1159 pa_assert(pa_cvolume_valid(volume));
1160 pa_assert(volume->channels == 1 || pa_cvolume_compatible(volume, &i->sample_spec));
1161 pa_assert(i->volume_writable);
1163 if (!absolute && pa_sink_flat_volume_enabled(i->sink)) {
1164 v = i->sink->reference_volume;
1165 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
1167 if (pa_cvolume_compatible(volume, &i->sample_spec))
1168 volume = pa_sw_cvolume_multiply(&v, &v, volume);
1170 volume = pa_sw_cvolume_multiply_scalar(&v, &v, pa_cvolume_max(volume));
1172 if (!pa_cvolume_compatible(volume, &i->sample_spec)) {
1174 volume = pa_cvolume_scale(&v, pa_cvolume_max(volume));
1178 if (pa_cvolume_equal(volume, &i->volume)) {
1179 i->save_volume = i->save_volume || save;
1183 i->volume = *volume;
1184 i->save_volume = save;
1186 if (pa_sink_flat_volume_enabled(i->sink)) {
1187 /* We are in flat volume mode, so let's update all sink input
1188 * volumes and update the flat volume of the sink */
1190 pa_sink_set_volume(i->sink, NULL, TRUE, save);
1193 /* OK, we are in normal volume mode. The volume only affects
1195 set_real_ratio(i, volume);
1197 /* Copy the new soft_volume to the thread_info struct */
1198 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1201 /* The volume changed, let's tell people so */
1202 if (i->volume_changed)
1203 i->volume_changed(i);
1205 /* The virtual volume changed, let's tell people so */
1206 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1209 /* Called from main context */
1210 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
1211 pa_sink_input_assert_ref(i);
1212 pa_assert_ctl_context();
1213 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1214 pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
1216 /* This basically calculates:
1218 * i->real_ratio := v
1219 * i->soft_volume := i->real_ratio * i->volume_factor */
1224 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
1226 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1227 /* We don't copy the data to the thread_info data. That's left for someone else to do */
1230 /* Called from main or I/O context */
1231 pa_bool_t pa_sink_input_is_passthrough(pa_sink_input *i) {
1232 pa_sink_input_assert_ref(i);
1234 if (PA_UNLIKELY(!pa_format_info_is_pcm(i->format)))
1237 if (PA_UNLIKELY(i->flags & PA_SINK_INPUT_PASSTHROUGH))
1243 /* Called from main context */
1244 pa_bool_t pa_sink_input_is_volume_readable(pa_sink_input *i) {
1245 pa_sink_input_assert_ref(i);
1246 pa_assert_ctl_context();
1248 return !pa_sink_input_is_passthrough(i);
1251 /* Called from main context */
1252 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, pa_bool_t absolute) {
1253 pa_sink_input_assert_ref(i);
1254 pa_assert_ctl_context();
1255 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1256 pa_assert(pa_sink_input_is_volume_readable(i));
1258 if (absolute || !pa_sink_flat_volume_enabled(i->sink))
1259 *volume = i->volume;
1261 *volume = i->reference_ratio;
1266 /* Called from main context */
1267 void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute, pa_bool_t save) {
1268 pa_sink_input_assert_ref(i);
1269 pa_assert_ctl_context();
1270 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1272 if (!i->muted == !mute) {
1273 i->save_muted = i->save_muted || mute;
1278 i->save_muted = save;
1280 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1282 /* The mute status changed, let's tell people so */
1283 if (i->mute_changed)
1286 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1289 /* Called from main context */
1290 pa_bool_t pa_sink_input_get_mute(pa_sink_input *i) {
1291 pa_sink_input_assert_ref(i);
1292 pa_assert_ctl_context();
1293 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1298 /* Called from main thread */
1299 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1300 pa_sink_input_assert_ref(i);
1301 pa_assert_ctl_context();
1304 pa_proplist_update(i->proplist, mode, p);
1306 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1307 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1308 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1312 /* Called from main context */
1313 void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b) {
1314 pa_sink_input_assert_ref(i);
1315 pa_assert_ctl_context();
1316 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1318 sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1321 /* Called from main context */
1322 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1323 pa_sink_input_assert_ref(i);
1324 pa_assert_ctl_context();
1325 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1326 pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1328 if (i->sample_spec.rate == rate)
1331 i->sample_spec.rate = rate;
1333 pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1335 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1339 /* Called from main context */
1340 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1342 pa_sink_input_assert_ref(i);
1343 pa_assert_ctl_context();
1345 if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1348 old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1350 if (old && name && pa_streq(old, name))
1354 pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1356 pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1358 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1359 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1360 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1364 /* Called from main context */
1365 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1366 pa_sink_input_assert_ref(i);
1367 pa_assert_ctl_context();
1369 return i->actual_resample_method;
1372 /* Called from main context */
1373 pa_bool_t pa_sink_input_may_move(pa_sink_input *i) {
1374 pa_sink_input_assert_ref(i);
1375 pa_assert_ctl_context();
1376 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1378 if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1381 if (i->sync_next || i->sync_prev) {
1382 pa_log_warn("Moving synchronized streams not supported.");
1389 /* Called from main context */
1390 pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1391 pa_sink_input_assert_ref(i);
1392 pa_assert_ctl_context();
1393 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1394 pa_sink_assert_ref(dest);
1396 if (dest == i->sink)
1399 if (!pa_sink_input_may_move(i))
1402 if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1403 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1407 if (check_passthrough_connection(pa_sink_input_is_passthrough(i), dest) < 0)
1411 if (!i->may_move_to(i, dest))
1417 /* Called from main context */
1418 int pa_sink_input_start_move(pa_sink_input *i) {
1419 pa_source_output *o, *p = NULL;
1422 pa_sink_input_assert_ref(i);
1423 pa_assert_ctl_context();
1424 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1427 if (!pa_sink_input_may_move(i))
1428 return -PA_ERR_NOTSUPPORTED;
1430 if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1433 /* Kill directly connected outputs */
1434 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1436 pa_source_output_kill(o);
1439 pa_assert(pa_idxset_isempty(i->direct_outputs));
1441 pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1443 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1444 pa_assert_se(i->sink->n_corked-- >= 1);
1446 if (pa_sink_input_is_passthrough(i))
1447 pa_sink_leave_passthrough(i->sink);
1449 if (pa_sink_flat_volume_enabled(i->sink))
1450 /* We might need to update the sink's volume if we are in flat
1452 pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
1454 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1456 pa_sink_update_status(i->sink);
1457 pa_cvolume_remap(&i->volume_factor_sink, &i->sink->channel_map, &i->channel_map);
1460 pa_sink_input_unref(i);
1465 /* Called from main context. If i has an origin sink that uses volume sharing,
1466 * then also the origin sink and all streams connected to it need to update
1467 * their volume - this function does all that by using recursion. */
1468 static void update_volume_due_to_moving(pa_sink_input *i, pa_sink *dest) {
1469 pa_cvolume old_volume;
1473 pa_assert(i->sink); /* The destination sink should already be set. */
1475 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1476 pa_sink *root_sink = pa_sink_get_master(i->sink);
1477 pa_sink_input *origin_sink_input;
1480 if (PA_UNLIKELY(!root_sink))
1483 if (pa_sink_flat_volume_enabled(i->sink)) {
1484 /* Ok, so the origin sink uses volume sharing, and flat volume is
1485 * enabled. The volume will have to be updated as follows:
1487 * i->volume := i->sink->real_volume
1488 * (handled later by pa_sink_set_volume)
1489 * i->reference_ratio := i->volume / i->sink->reference_volume
1490 * (handled later by pa_sink_set_volume)
1491 * i->real_ratio stays unchanged
1492 * (streams whose origin sink uses volume sharing should
1493 * always have real_ratio of 0 dB)
1494 * i->soft_volume stays unchanged
1495 * (streams whose origin sink uses volume sharing should
1496 * always have volume_factor as soft_volume, so no change
1497 * should be needed) */
1499 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1500 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1502 /* Notifications will be sent by pa_sink_set_volume(). */
1505 /* Ok, so the origin sink uses volume sharing, and flat volume is
1506 * disabled. The volume will have to be updated as follows:
1509 * i->reference_ratio := 0 dB
1510 * i->real_ratio stays unchanged
1511 * (streams whose origin sink uses volume sharing should
1512 * always have real_ratio of 0 dB)
1513 * i->soft_volume stays unchanged
1514 * (streams whose origin sink uses volume sharing should
1515 * always have volume_factor as soft_volume, so no change
1516 * should be needed) */
1518 old_volume = i->volume;
1519 pa_cvolume_reset(&i->volume, i->volume.channels);
1520 pa_cvolume_reset(&i->reference_ratio, i->reference_ratio.channels);
1521 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1522 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1524 /* Notify others about the changed sink input volume. */
1525 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1526 if (i->volume_changed)
1527 i->volume_changed(i);
1529 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1533 /* Additionally, the origin sink volume needs updating:
1535 * i->origin_sink->reference_volume := root_sink->reference_volume
1536 * i->origin_sink->real_volume := root_sink->real_volume
1537 * i->origin_sink->soft_volume stays unchanged
1538 * (sinks that use volume sharing should always have
1539 * soft_volume of 0 dB) */
1541 old_volume = i->origin_sink->reference_volume;
1543 i->origin_sink->reference_volume = root_sink->reference_volume;
1544 pa_cvolume_remap(&i->origin_sink->reference_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1546 i->origin_sink->real_volume = root_sink->real_volume;
1547 pa_cvolume_remap(&i->origin_sink->real_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1549 pa_assert(pa_cvolume_is_norm(&i->origin_sink->soft_volume));
1551 /* Notify others about the changed sink volume. If you wonder whether
1552 * i->origin_sink->set_volume() should be called somewhere, that's not
1553 * the case, because sinks that use volume sharing shouldn't have any
1554 * internal volume that set_volume() would update. If you wonder
1555 * whether the thread_info variables should be synced, yes, they
1556 * should, and it's done by the PA_SINK_MESSAGE_FINISH_MOVE message
1558 if (!pa_cvolume_equal(&i->origin_sink->reference_volume, &old_volume))
1559 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, i->origin_sink->index);
1561 /* Recursively update origin sink inputs. */
1562 PA_IDXSET_FOREACH(origin_sink_input, i->origin_sink->inputs, idx)
1563 update_volume_due_to_moving(origin_sink_input, dest);
1566 old_volume = i->volume;
1568 if (pa_sink_flat_volume_enabled(i->sink)) {
1569 /* Ok, so this is a regular stream, and flat volume is enabled. The
1570 * volume will have to be updated as follows:
1572 * i->volume := i->reference_ratio * i->sink->reference_volume
1573 * i->reference_ratio stays unchanged
1574 * i->real_ratio := i->volume / i->sink->real_volume
1575 * (handled later by pa_sink_set_volume)
1576 * i->soft_volume := i->real_ratio * i->volume_factor
1577 * (handled later by pa_sink_set_volume) */
1579 i->volume = i->sink->reference_volume;
1580 pa_cvolume_remap(&i->volume, &i->sink->channel_map, &i->channel_map);
1581 pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1584 /* Ok, so this is a regular stream, and flat volume is disabled.
1585 * The volume will have to be updated as follows:
1587 * i->volume := i->reference_ratio
1588 * i->reference_ratio stays unchanged
1589 * i->real_ratio := i->reference_ratio
1590 * i->soft_volume := i->real_ratio * i->volume_factor */
1592 i->volume = i->reference_ratio;
1593 i->real_ratio = i->reference_ratio;
1594 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1597 /* Notify others about the changed sink input volume. */
1598 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1599 /* XXX: In case i->sink has flat volume enabled, then real_ratio
1600 * and soft_volume are not updated yet. Let's hope that the
1601 * callback implementation doesn't care about those variables... */
1602 if (i->volume_changed)
1603 i->volume_changed(i);
1605 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1609 /* If i->sink == dest, then recursion has finished, and we can finally call
1610 * pa_sink_set_volume(), which will do the rest of the updates. */
1611 if ((i->sink == dest) && pa_sink_flat_volume_enabled(i->sink))
1612 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
1615 /* Called from main context */
1616 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1617 pa_sink_input_assert_ref(i);
1618 pa_assert_ctl_context();
1619 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1620 pa_assert(!i->sink);
1621 pa_sink_assert_ref(dest);
1623 if (!pa_sink_input_may_move_to(i, dest))
1624 return -PA_ERR_NOTSUPPORTED;
1626 if (pa_sink_input_is_passthrough(i) && !pa_sink_check_format(dest, i->format)) {
1627 pa_proplist *p = pa_proplist_new();
1628 pa_log_debug("New sink doesn't support stream format, sending format-changed and killing");
1629 /* Tell the client what device we want to be on if it is going to
1631 pa_proplist_sets(p, "device", dest->name);
1632 pa_sink_input_send_event(i, PA_STREAM_EVENT_FORMAT_LOST, p);
1633 pa_proplist_free(p);
1634 return -PA_ERR_NOTSUPPORTED;
1637 if (!(i->flags & PA_SINK_INPUT_VARIABLE_RATE) &&
1638 !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec)) {
1639 /* try to change dest sink rate if possible without glitches.
1640 module-suspend-on-idle resumes destination sink with
1641 SINK_INPUT_MOVE_FINISH hook */
1643 pa_log_info("Trying to change sample rate");
1644 if (pa_sink_update_rate(dest, i->sample_spec.rate, pa_sink_input_is_passthrough(i)) == TRUE)
1645 pa_log_info("Rate changed to %u kHz",
1646 dest->sample_spec.rate);
1648 pa_log_info("Resampling enabled to %u kHz",
1649 dest->sample_spec.rate);
1656 i->save_sink = save;
1657 pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1659 pa_cvolume_remap(&i->volume_factor_sink, &i->channel_map, &i->sink->channel_map);
1661 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1662 i->sink->n_corked++;
1664 pa_sink_input_update_rate(i);
1666 pa_sink_update_status(dest);
1668 update_volume_due_to_moving(i, dest);
1670 if (pa_sink_input_is_passthrough(i))
1671 pa_sink_enter_passthrough(i->sink);
1673 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1675 pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1677 /* Notify everyone */
1678 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1679 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1684 /* Called from main context */
1685 void pa_sink_input_fail_move(pa_sink_input *i) {
1687 pa_sink_input_assert_ref(i);
1688 pa_assert_ctl_context();
1689 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1690 pa_assert(!i->sink);
1692 /* Check if someone wants this sink input? */
1693 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1699 pa_sink_input_kill(i);
1702 /* Called from main context */
1703 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1706 pa_sink_input_assert_ref(i);
1707 pa_assert_ctl_context();
1708 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1710 pa_sink_assert_ref(dest);
1712 if (dest == i->sink)
1715 if (!pa_sink_input_may_move_to(i, dest))
1716 return -PA_ERR_NOTSUPPORTED;
1718 pa_sink_input_ref(i);
1720 if ((r = pa_sink_input_start_move(i)) < 0) {
1721 pa_sink_input_unref(i);
1725 if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1726 pa_sink_input_fail_move(i);
1727 pa_sink_input_unref(i);
1731 pa_sink_input_unref(i);
1736 /* Called from IO thread context */
1737 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1738 pa_bool_t corking, uncorking;
1740 pa_sink_input_assert_ref(i);
1741 pa_sink_input_assert_io_context(i);
1743 if (state == i->thread_info.state)
1746 if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1747 !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1748 pa_atomic_store(&i->thread_info.drained, 1);
1750 corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1751 uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1753 if (i->state_change)
1754 i->state_change(i, state);
1758 pa_log_debug("Requesting rewind due to corking");
1760 /* This will tell the implementing sink input driver to rewind
1761 * so that the unplayed already mixed data is not lost */
1762 pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1764 /* Set the corked state *after* requesting rewind */
1765 i->thread_info.state = state;
1767 } else if (uncorking) {
1769 pa_log_debug("Requesting rewind due to uncorking");
1771 i->thread_info.underrun_for = (uint64_t) -1;
1772 i->thread_info.playing_for = 0;
1774 /* Set the uncorked state *before* requesting rewind */
1775 i->thread_info.state = state;
1777 /* OK, we're being uncorked. Make sure we're not rewound when
1778 * the hw buffer is remixed and request a remix. */
1779 pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1781 /* We may not be corking or uncorking, but we still need to set the state. */
1782 i->thread_info.state = state;
1785 /* Called from thread context, except when it is not. */
1786 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1787 pa_sink_input *i = PA_SINK_INPUT(o);
1788 pa_sink_input_assert_ref(i);
1792 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1793 if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1794 i->thread_info.soft_volume = i->soft_volume;
1795 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1799 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1800 if (i->thread_info.muted != i->muted) {
1801 i->thread_info.muted = i->muted;
1802 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1806 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1807 pa_usec_t *r = userdata;
1809 r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1810 r[1] += pa_sink_get_latency_within_thread(i->sink);
1815 case PA_SINK_INPUT_MESSAGE_SET_RATE:
1817 i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1818 pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1822 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1823 pa_sink_input *ssync;
1825 pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
1827 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
1828 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1830 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
1831 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1836 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
1837 pa_usec_t *usec = userdata;
1839 *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
1843 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
1844 pa_usec_t *r = userdata;
1846 *r = i->thread_info.requested_sink_latency;
1851 return -PA_ERR_NOTIMPLEMENTED;
1854 /* Called from main thread */
1855 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
1856 pa_sink_input_assert_ref(i);
1857 pa_assert_ctl_context();
1859 if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
1860 return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
1865 /* Called from IO context */
1866 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
1867 pa_sink_input_assert_ref(i);
1868 pa_sink_input_assert_io_context(i);
1870 if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
1871 return pa_memblockq_is_empty(i->thread_info.render_memblockq);
1876 /* Called from IO context */
1877 void pa_sink_input_request_rewind(
1879 size_t nbytes /* in our sample spec */,
1882 pa_bool_t dont_rewind_render) {
1886 /* If 'rewrite' is TRUE the sink is rewound as far as requested
1887 * and possible and the exact value of this is passed back the
1888 * implementor via process_rewind(). If 'flush' is also TRUE all
1889 * already rendered data is also dropped.
1891 * If 'rewrite' is FALSE the sink is rewound as far as requested
1892 * and possible and the already rendered data is dropped so that
1893 * in the next iteration we read new data from the
1894 * implementor. This implies 'flush' is TRUE. If
1895 * dont_rewind_render is TRUE then the render memblockq is not
1898 /* nbytes = 0 means maximum rewind request */
1900 pa_sink_input_assert_ref(i);
1901 pa_sink_input_assert_io_context(i);
1902 pa_assert(rewrite || flush);
1903 pa_assert(!dont_rewind_render || !rewrite);
1905 /* We don't take rewind requests while we are corked */
1906 if (i->thread_info.state == PA_SINK_INPUT_CORKED)
1909 nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
1911 #ifdef SINK_INPUT_DEBUG
1912 pa_log_debug("request rewrite %zu", nbytes);
1915 /* Calculate how much we can rewind locally without having to
1918 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1922 /* Check if rewinding for the maximum is requested, and if so, fix up */
1925 /* Calculate maximum number of bytes that could be rewound in theory */
1926 nbytes = i->sink->thread_info.max_rewind + lbq;
1928 /* Transform from sink domain */
1929 if (i->thread_info.resampler)
1930 nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
1933 /* Remember how much we actually want to rewrite */
1934 if (i->thread_info.rewrite_nbytes != (size_t) -1) {
1936 /* Make sure to not overwrite over underruns */
1937 if (nbytes > i->thread_info.playing_for)
1938 nbytes = (size_t) i->thread_info.playing_for;
1940 i->thread_info.rewrite_nbytes = nbytes;
1942 i->thread_info.rewrite_nbytes = (size_t) -1;
1945 i->thread_info.rewrite_flush =
1946 i->thread_info.rewrite_flush ||
1947 (flush && i->thread_info.rewrite_nbytes != 0);
1949 i->thread_info.dont_rewind_render =
1950 i->thread_info.dont_rewind_render ||
1953 if (nbytes != (size_t) -1) {
1955 /* Transform to sink domain */
1956 if (i->thread_info.resampler)
1957 nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
1960 pa_sink_request_rewind(i->sink, nbytes - lbq);
1962 /* This call will make sure process_rewind() is called later */
1963 pa_sink_request_rewind(i->sink, 0);
1967 /* Called from main context */
1968 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
1969 pa_sink_input_assert_ref(i);
1970 pa_assert_ctl_context();
1973 /* FIXME: Shouldn't access resampler object from main context! */
1975 pa_silence_memchunk_get(
1976 &i->core->silence_cache,
1980 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
1985 /* Called from main context */
1986 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
1987 pa_proplist *pl = NULL;
1988 pa_sink_input_send_event_hook_data hook_data;
1990 pa_sink_input_assert_ref(i);
1991 pa_assert_ctl_context();
1998 data = pl = pa_proplist_new();
2000 hook_data.sink_input = i;
2001 hook_data.data = data;
2002 hook_data.event = event;
2004 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
2007 i->send_event(i, event, data);
2011 pa_proplist_free(pl);
2014 /* Called from main context */
2015 /* Updates the sink input's resampler with whatever the current sink requires
2016 * -- useful when the underlying sink's rate might have changed */
2017 int pa_sink_input_update_rate(pa_sink_input *i) {
2018 pa_resampler *new_resampler;
2019 char *memblockq_name;
2021 pa_sink_input_assert_ref(i);
2022 pa_assert_ctl_context();
2024 if (i->thread_info.resampler &&
2025 pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &i->sink->sample_spec) &&
2026 pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &i->sink->channel_map))
2028 new_resampler = i->thread_info.resampler;
2030 else if (!pa_sink_input_is_passthrough(i) &&
2031 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
2032 !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec) ||
2033 !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map))) {
2035 new_resampler = pa_resampler_new(i->core->mempool,
2036 &i->sample_spec, &i->channel_map,
2037 &i->sink->sample_spec, &i->sink->channel_map,
2038 i->requested_resample_method,
2039 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
2040 ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
2041 (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0));
2043 if (!new_resampler) {
2044 pa_log_warn("Unsupported resampling operation.");
2045 return -PA_ERR_NOTSUPPORTED;
2048 new_resampler = NULL;
2050 if (new_resampler == i->thread_info.resampler)
2053 if (i->thread_info.resampler)
2054 pa_resampler_free(i->thread_info.resampler);
2056 i->thread_info.resampler = new_resampler;
2058 pa_memblockq_free(i->thread_info.render_memblockq);
2060 memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
2061 i->thread_info.render_memblockq = pa_memblockq_new(
2064 MEMBLOCKQ_MAXLENGTH,
2066 &i->sink->sample_spec,
2071 pa_xfree(memblockq_name);
2073 i->actual_resample_method = new_resampler ? pa_resampler_get_method(new_resampler) : PA_RESAMPLER_INVALID;
2075 pa_log_debug("Updated resmpler for sink input %d", i->index);