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/mix.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 struct volume_factor_entry {
56 static struct volume_factor_entry *volume_factor_entry_new(const char *key, const pa_cvolume *volume) {
57 struct volume_factor_entry *entry;
62 entry = pa_xnew(struct volume_factor_entry, 1);
63 entry->key = pa_xstrdup(key);
65 entry->volume = *volume;
70 static void volume_factor_entry_free(struct volume_factor_entry *volume_entry) {
71 pa_assert(volume_entry);
73 pa_xfree(volume_entry->key);
74 pa_xfree(volume_entry);
77 static void volume_factor_from_hashmap(pa_cvolume *v, pa_hashmap *items, uint8_t channels) {
78 struct volume_factor_entry *entry;
81 pa_cvolume_reset(v, channels);
82 PA_HASHMAP_FOREACH(entry, items, state)
83 pa_sw_cvolume_multiply(v, v, &entry->volume);
86 static void sink_input_free(pa_object *o);
87 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v);
89 static int check_passthrough_connection(bool passthrough, pa_sink *dest) {
90 if (pa_sink_is_passthrough(dest)) {
91 pa_log_warn("Sink is already connected to PASSTHROUGH input");
95 /* If current input(s) exist, check new input is not PASSTHROUGH */
96 if (pa_idxset_size(dest->inputs) > 0 && passthrough) {
97 pa_log_warn("Sink is already connected, cannot accept new PASSTHROUGH INPUT");
104 pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data) {
108 data->resample_method = PA_RESAMPLER_INVALID;
109 data->proplist = pa_proplist_new();
110 data->volume_writable = true;
112 data->volume_factor_items = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL,
113 (pa_free_cb_t) volume_factor_entry_free);
114 data->volume_factor_sink_items = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL,
115 (pa_free_cb_t) volume_factor_entry_free);
120 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec) {
123 if ((data->sample_spec_is_set = !!spec))
124 data->sample_spec = *spec;
127 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map) {
130 if ((data->channel_map_is_set = !!map))
131 data->channel_map = *map;
134 bool pa_sink_input_new_data_is_passthrough(pa_sink_input_new_data *data) {
137 if (PA_LIKELY(data->format) && PA_UNLIKELY(!pa_format_info_is_pcm(data->format)))
140 if (PA_UNLIKELY(data->flags & PA_SINK_INPUT_PASSTHROUGH))
146 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume) {
148 pa_assert(data->volume_writable);
150 if ((data->volume_is_set = !!volume))
151 data->volume = *volume;
154 void pa_sink_input_new_data_add_volume_factor(pa_sink_input_new_data *data, const char *key, const pa_cvolume *volume_factor) {
155 struct volume_factor_entry *v;
159 pa_assert(volume_factor);
161 v = volume_factor_entry_new(key, volume_factor);
162 pa_assert_se(pa_hashmap_put(data->volume_factor_items, v->key, v) >= 0);
165 void pa_sink_input_new_data_add_volume_factor_sink(pa_sink_input_new_data *data, const char *key, const pa_cvolume *volume_factor) {
166 struct volume_factor_entry *v;
170 pa_assert(volume_factor);
172 v = volume_factor_entry_new(key, volume_factor);
173 pa_assert_se(pa_hashmap_put(data->volume_factor_sink_items, v->key, v) >= 0);
176 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, bool mute) {
179 data->muted_is_set = true;
180 data->muted = !!mute;
183 bool pa_sink_input_new_data_set_sink(pa_sink_input_new_data *data, pa_sink *s, bool save) {
185 pa_idxset *formats = NULL;
190 if (!data->req_formats) {
191 /* We're not working with the extended API */
193 data->save_sink = save;
195 /* Extended API: let's see if this sink supports the formats the client can provide */
196 formats = pa_sink_check_formats(s, data->req_formats);
198 if (formats && !pa_idxset_isempty(formats)) {
199 /* Sink supports at least one of the requested formats */
201 data->save_sink = save;
202 if (data->nego_formats)
203 pa_idxset_free(data->nego_formats, (pa_free_cb_t) pa_format_info_free);
204 data->nego_formats = formats;
206 /* Sink doesn't support any of the formats requested by the client */
208 pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
216 bool pa_sink_input_new_data_set_formats(pa_sink_input_new_data *data, pa_idxset *formats) {
220 if (data->req_formats)
221 pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
223 data->req_formats = formats;
226 /* Trigger format negotiation */
227 return pa_sink_input_new_data_set_sink(data, data->sink, data->save_sink);
233 void pa_sink_input_new_data_done(pa_sink_input_new_data *data) {
236 if (data->req_formats)
237 pa_idxset_free(data->req_formats, (pa_free_cb_t) pa_format_info_free);
239 if (data->nego_formats)
240 pa_idxset_free(data->nego_formats, (pa_free_cb_t) pa_format_info_free);
243 pa_format_info_free(data->format);
245 if (data->volume_factor_items)
246 pa_hashmap_free(data->volume_factor_items);
248 if (data->volume_factor_sink_items)
249 pa_hashmap_free(data->volume_factor_sink_items);
251 pa_proplist_free(data->proplist);
254 /* Called from main context */
255 static void reset_callbacks(pa_sink_input *i) {
259 i->process_underrun = NULL;
260 i->process_rewind = NULL;
261 i->update_max_rewind = NULL;
262 i->update_max_request = NULL;
263 i->update_sink_requested_latency = NULL;
264 i->update_sink_latency_range = NULL;
265 i->update_sink_fixed_latency = NULL;
269 i->suspend_within_thread = NULL;
272 i->get_latency = NULL;
273 i->state_change = NULL;
274 i->may_move_to = NULL;
275 i->send_event = NULL;
276 i->volume_changed = NULL;
277 i->mute_changed = NULL;
280 /* Called from main context */
281 int pa_sink_input_new(
284 pa_sink_input_new_data *data) {
287 pa_resampler *resampler = NULL;
288 char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX], fmt[PA_FORMAT_INFO_SNPRINT_MAX];
289 pa_channel_map original_cm;
292 char *memblockq_name;
299 pa_assert_ctl_context();
302 pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->client->proplist);
304 if (data->origin_sink && (data->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
305 data->volume_writable = false;
307 if (!data->req_formats) {
308 /* From this point on, we want to work only with formats, and get back
309 * to using the sample spec and channel map after all decisions w.r.t.
310 * routing are complete. */
311 pa_idxset *tmp = pa_idxset_new(NULL, NULL);
312 pa_format_info *f = pa_format_info_from_sample_spec(&data->sample_spec,
313 data->channel_map_is_set ? &data->channel_map : NULL);
314 pa_idxset_put(tmp, f, NULL);
315 pa_sink_input_new_data_set_formats(data, tmp);
318 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], data)) < 0)
321 pa_return_val_if_fail(!data->driver || pa_utf8_valid(data->driver), -PA_ERR_INVALID);
324 pa_sink *sink = pa_namereg_get(core, NULL, PA_NAMEREG_SINK);
325 pa_return_val_if_fail(sink, -PA_ERR_NOENTITY);
326 pa_sink_input_new_data_set_sink(data, sink, false);
328 /* Routing's done, we have a sink. Now let's fix the format and set up the
331 /* If something didn't pick a format for us, pick the top-most format since
332 * we assume this is sorted in priority order */
333 if (!data->format && data->nego_formats && !pa_idxset_isempty(data->nego_formats))
334 data->format = pa_format_info_copy(pa_idxset_first(data->nego_formats, NULL));
336 if (PA_LIKELY(data->format)) {
337 pa_log_debug("Negotiated format: %s", pa_format_info_snprint(fmt, sizeof(fmt), data->format));
339 pa_format_info *format;
342 pa_log_info("Sink does not support any requested format:");
343 PA_IDXSET_FOREACH(format, data->req_formats, idx)
344 pa_log_info(" -- %s", pa_format_info_snprint(fmt, sizeof(fmt), format));
346 return -PA_ERR_NOTSUPPORTED;
349 /* Now populate the sample spec and format according to the final
350 * format that we've negotiated */
351 pa_return_val_if_fail(pa_format_info_to_sample_spec(data->format, &ss, &map) == 0, -PA_ERR_INVALID);
352 pa_sink_input_new_data_set_sample_spec(data, &ss);
353 if (pa_format_info_is_pcm(data->format) && pa_channel_map_valid(&map))
354 pa_sink_input_new_data_set_channel_map(data, &map);
356 pa_return_val_if_fail(PA_SINK_IS_LINKED(pa_sink_get_state(data->sink)), -PA_ERR_BADSTATE);
357 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);
359 r = check_passthrough_connection(pa_sink_input_new_data_is_passthrough(data), data->sink);
363 if (!data->sample_spec_is_set)
364 data->sample_spec = data->sink->sample_spec;
366 pa_return_val_if_fail(pa_sample_spec_valid(&data->sample_spec), -PA_ERR_INVALID);
368 if (!data->channel_map_is_set) {
369 if (pa_channel_map_compatible(&data->sink->channel_map, &data->sample_spec))
370 data->channel_map = data->sink->channel_map;
372 pa_channel_map_init_extend(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
375 pa_return_val_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec), -PA_ERR_INVALID);
377 /* Don't restore (or save) stream volume for passthrough streams and
378 * prevent attenuation/gain */
379 if (pa_sink_input_new_data_is_passthrough(data)) {
380 data->volume_is_set = true;
381 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
382 data->volume_is_absolute = true;
383 data->save_volume = false;
386 if (!data->volume_is_set) {
387 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
388 data->volume_is_absolute = false;
389 data->save_volume = false;
392 if (!data->volume_writable)
393 data->save_volume = false;
395 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec), -PA_ERR_INVALID);
397 if (!data->muted_is_set)
400 if (data->flags & PA_SINK_INPUT_FIX_FORMAT) {
401 pa_return_val_if_fail(pa_format_info_is_pcm(data->format), -PA_ERR_INVALID);
402 data->sample_spec.format = data->sink->sample_spec.format;
403 pa_format_info_set_sample_format(data->format, data->sample_spec.format);
406 if (data->flags & PA_SINK_INPUT_FIX_RATE) {
407 pa_return_val_if_fail(pa_format_info_is_pcm(data->format), -PA_ERR_INVALID);
408 data->sample_spec.rate = data->sink->sample_spec.rate;
409 pa_format_info_set_rate(data->format, data->sample_spec.rate);
412 original_cm = data->channel_map;
414 if (data->flags & PA_SINK_INPUT_FIX_CHANNELS) {
415 pa_return_val_if_fail(pa_format_info_is_pcm(data->format), -PA_ERR_INVALID);
416 data->sample_spec.channels = data->sink->sample_spec.channels;
417 data->channel_map = data->sink->channel_map;
418 pa_format_info_set_channels(data->format, data->sample_spec.channels);
419 pa_format_info_set_channel_map(data->format, &data->channel_map);
422 pa_assert(pa_sample_spec_valid(&data->sample_spec));
423 pa_assert(pa_channel_map_valid(&data->channel_map));
425 if (!(data->flags & PA_SINK_INPUT_VARIABLE_RATE) &&
426 !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec)) {
427 /* try to change sink rate. This is done before the FIXATE hook since
428 module-suspend-on-idle can resume a sink */
430 pa_log_info("Trying to change sample rate");
431 if (pa_sink_update_rate(data->sink, data->sample_spec.rate, pa_sink_input_new_data_is_passthrough(data)) >= 0)
432 pa_log_info("Rate changed to %u Hz", data->sink->sample_spec.rate);
435 if (pa_sink_input_new_data_is_passthrough(data) &&
436 !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec)) {
437 /* rate update failed, or other parts of sample spec didn't match */
439 pa_log_debug("Could not update sink sample spec to match passthrough stream");
440 return -PA_ERR_NOTSUPPORTED;
443 /* Due to the fixing of the sample spec the volume might not match anymore */
444 pa_cvolume_remap(&data->volume, &original_cm, &data->channel_map);
446 if (data->resample_method == PA_RESAMPLER_INVALID)
447 data->resample_method = core->resample_method;
449 pa_return_val_if_fail(data->resample_method < PA_RESAMPLER_MAX, -PA_ERR_INVALID);
451 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], data)) < 0)
454 if ((data->flags & PA_SINK_INPUT_NO_CREATE_ON_SUSPEND) &&
455 pa_sink_get_state(data->sink) == PA_SINK_SUSPENDED) {
456 pa_log_warn("Failed to create sink input: sink is suspended.");
457 return -PA_ERR_BADSTATE;
460 if (pa_idxset_size(data->sink->inputs) >= PA_MAX_INPUTS_PER_SINK) {
461 pa_log_warn("Failed to create sink input: too many inputs per sink.");
462 return -PA_ERR_TOOLARGE;
465 if ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
466 !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec) ||
467 !pa_channel_map_equal(&data->channel_map, &data->sink->channel_map)) {
469 /* Note: for passthrough content we need to adjust the output rate to that of the current sink-input */
470 if (!pa_sink_input_new_data_is_passthrough(data)) /* no resampler for passthrough content */
471 if (!(resampler = pa_resampler_new(
473 &data->sample_spec, &data->channel_map,
474 &data->sink->sample_spec, &data->sink->channel_map,
475 data->resample_method,
476 ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
477 ((data->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
478 (core->disable_remixing || (data->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0) |
479 (core->disable_lfe_remixing ? PA_RESAMPLER_NO_LFE : 0)))) {
480 pa_log_warn("Unsupported resampling operation.");
481 return -PA_ERR_NOTSUPPORTED;
485 i = pa_msgobject_new(pa_sink_input);
486 i->parent.parent.free = sink_input_free;
487 i->parent.process_msg = pa_sink_input_process_msg;
490 i->state = PA_SINK_INPUT_INIT;
491 i->flags = data->flags;
492 i->proplist = pa_proplist_copy(data->proplist);
493 i->driver = pa_xstrdup(pa_path_get_filename(data->driver));
494 i->module = data->module;
495 i->sink = data->sink;
496 i->origin_sink = data->origin_sink;
497 i->client = data->client;
499 i->requested_resample_method = data->resample_method;
500 i->actual_resample_method = resampler ? pa_resampler_get_method(resampler) : PA_RESAMPLER_INVALID;
501 i->sample_spec = data->sample_spec;
502 i->channel_map = data->channel_map;
503 i->format = pa_format_info_copy(data->format);
505 if (!data->volume_is_absolute && pa_sink_flat_volume_enabled(i->sink)) {
508 /* When the 'absolute' bool is not set then we'll treat the volume
509 * as relative to the sink volume even in flat volume mode */
510 remapped = data->sink->reference_volume;
511 pa_cvolume_remap(&remapped, &data->sink->channel_map, &data->channel_map);
512 pa_sw_cvolume_multiply(&i->volume, &data->volume, &remapped);
514 i->volume = data->volume;
516 i->volume_factor_items = data->volume_factor_items;
517 data->volume_factor_items = NULL;
518 volume_factor_from_hashmap(&i->volume_factor, i->volume_factor_items, i->sample_spec.channels);
520 i->volume_factor_sink_items = data->volume_factor_sink_items;
521 data->volume_factor_sink_items = NULL;
522 volume_factor_from_hashmap(&i->volume_factor_sink, i->volume_factor_sink_items, i->sample_spec.channels);
524 i->real_ratio = i->reference_ratio = data->volume;
525 pa_cvolume_reset(&i->soft_volume, i->sample_spec.channels);
526 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
527 i->volume_writable = data->volume_writable;
528 i->save_volume = data->save_volume;
529 i->save_sink = data->save_sink;
530 i->save_muted = data->save_muted;
532 i->muted = data->muted;
534 if (data->sync_base) {
535 i->sync_next = data->sync_base->sync_next;
536 i->sync_prev = data->sync_base;
538 if (data->sync_base->sync_next)
539 data->sync_base->sync_next->sync_prev = i;
540 data->sync_base->sync_next = i;
542 i->sync_next = i->sync_prev = NULL;
544 i->direct_outputs = pa_idxset_new(NULL, NULL);
549 i->thread_info.state = i->state;
550 i->thread_info.attached = false;
551 pa_atomic_store(&i->thread_info.drained, 1);
552 i->thread_info.sample_spec = i->sample_spec;
553 i->thread_info.resampler = resampler;
554 i->thread_info.soft_volume = i->soft_volume;
555 i->thread_info.muted = i->muted;
556 i->thread_info.requested_sink_latency = (pa_usec_t) -1;
557 i->thread_info.rewrite_nbytes = 0;
558 i->thread_info.rewrite_flush = false;
559 i->thread_info.dont_rewind_render = false;
560 i->thread_info.underrun_for = (uint64_t) -1;
561 i->thread_info.underrun_for_sink = 0;
562 i->thread_info.playing_for = 0;
563 i->thread_info.direct_outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
565 pa_assert_se(pa_idxset_put(core->sink_inputs, i, &i->index) == 0);
566 pa_assert_se(pa_idxset_put(i->sink->inputs, pa_sink_input_ref(i), NULL) == 0);
569 pa_assert_se(pa_idxset_put(i->client->sink_inputs, i, NULL) >= 0);
571 memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
572 i->thread_info.render_memblockq = pa_memblockq_new(
577 &i->sink->sample_spec,
582 pa_xfree(memblockq_name);
584 pt = pa_proplist_to_string_sep(i->proplist, "\n ");
585 pa_log_info("Created input %u \"%s\" on %s with sample spec %s and channel map %s\n %s",
587 pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)),
589 pa_sample_spec_snprint(st, sizeof(st), &i->sample_spec),
590 pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
594 /* Don't forget to call pa_sink_input_put! */
600 /* Called from main context */
601 static void update_n_corked(pa_sink_input *i, pa_sink_input_state_t state) {
603 pa_assert_ctl_context();
608 if (i->state == PA_SINK_INPUT_CORKED && state != PA_SINK_INPUT_CORKED)
609 pa_assert_se(i->sink->n_corked -- >= 1);
610 else if (i->state != PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_CORKED)
614 /* Called from main context */
615 static void sink_input_set_state(pa_sink_input *i, pa_sink_input_state_t state) {
616 pa_sink_input *ssync;
618 pa_assert_ctl_context();
620 if (state == PA_SINK_INPUT_DRAINED)
621 state = PA_SINK_INPUT_RUNNING;
623 if (i->state == state)
626 if (i->state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING && pa_sink_used_by(i->sink) == 0 &&
627 !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec)) {
628 /* We were uncorked and the sink was not playing anything -- let's try
629 * to update the sample rate to avoid resampling */
630 pa_sink_update_rate(i->sink, i->sample_spec.rate, pa_sink_input_is_passthrough(i));
633 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);
635 update_n_corked(i, state);
638 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev) {
639 update_n_corked(ssync, state);
640 ssync->state = state;
642 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next) {
643 update_n_corked(ssync, state);
644 ssync->state = state;
647 if (state != PA_SINK_INPUT_UNLINKED) {
648 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], i);
650 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev)
651 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
653 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next)
654 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
656 if (PA_SINK_INPUT_IS_LINKED(state))
657 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
660 pa_sink_update_status(i->sink);
663 /* Called from main context */
664 void pa_sink_input_unlink(pa_sink_input *i) {
666 pa_source_output *o, *p = NULL;
669 pa_assert_ctl_context();
671 /* See pa_sink_unlink() for a couple of comments how this function
674 pa_sink_input_ref(i);
676 linked = PA_SINK_INPUT_IS_LINKED(i->state);
679 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], i);
682 i->sync_prev->sync_next = i->sync_next;
684 i->sync_next->sync_prev = i->sync_prev;
686 i->sync_prev = i->sync_next = NULL;
688 pa_idxset_remove_by_data(i->core->sink_inputs, i, NULL);
691 if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL))
692 pa_sink_input_unref(i);
695 pa_idxset_remove_by_data(i->client->sink_inputs, i, NULL);
697 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
699 pa_source_output_kill(o);
703 update_n_corked(i, PA_SINK_INPUT_UNLINKED);
704 i->state = PA_SINK_INPUT_UNLINKED;
706 if (linked && i->sink) {
707 if (pa_sink_input_is_passthrough(i))
708 pa_sink_leave_passthrough(i->sink);
710 /* We might need to update the sink's volume if we are in flat volume mode. */
711 if (pa_sink_flat_volume_enabled(i->sink))
712 pa_sink_set_volume(i->sink, NULL, false, false);
714 if (i->sink->asyncmsgq)
715 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_REMOVE_INPUT, i, 0, NULL) == 0);
721 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_REMOVE, i->index);
722 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST], i);
726 if (PA_SINK_IS_LINKED(pa_sink_get_state(i->sink)))
727 pa_sink_update_status(i->sink);
732 pa_core_maybe_vacuum(i->core);
734 pa_sink_input_unref(i);
737 /* Called from main context */
738 static void sink_input_free(pa_object *o) {
739 pa_sink_input* i = PA_SINK_INPUT(o);
742 pa_assert_ctl_context();
743 pa_assert(pa_sink_input_refcnt(i) == 0);
745 if (PA_SINK_INPUT_IS_LINKED(i->state))
746 pa_sink_input_unlink(i);
748 pa_log_info("Freeing input %u \"%s\"", i->index, pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)));
750 /* Side note: this function must be able to destruct properly any
751 * kind of sink input in any state, even those which are
752 * "half-moved" or are connected to sinks that have no asyncmsgq
753 * and are hence half-destructed themselves! */
755 if (i->thread_info.render_memblockq)
756 pa_memblockq_free(i->thread_info.render_memblockq);
758 if (i->thread_info.resampler)
759 pa_resampler_free(i->thread_info.resampler);
762 pa_format_info_free(i->format);
765 pa_proplist_free(i->proplist);
767 if (i->direct_outputs)
768 pa_idxset_free(i->direct_outputs, NULL);
770 if (i->thread_info.direct_outputs)
771 pa_hashmap_free(i->thread_info.direct_outputs);
773 if (i->volume_factor_items)
774 pa_hashmap_free(i->volume_factor_items);
776 if (i->volume_factor_sink_items)
777 pa_hashmap_free(i->volume_factor_sink_items);
783 /* Called from main context */
784 void pa_sink_input_put(pa_sink_input *i) {
785 pa_sink_input_state_t state;
787 pa_sink_input_assert_ref(i);
788 pa_assert_ctl_context();
790 pa_assert(i->state == PA_SINK_INPUT_INIT);
792 /* The following fields must be initialized properly */
794 pa_assert(i->process_rewind);
797 state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING;
799 update_n_corked(i, state);
802 /* We might need to update the sink's volume if we are in flat volume mode. */
803 if (pa_sink_flat_volume_enabled(i->sink))
804 pa_sink_set_volume(i->sink, NULL, false, i->save_volume);
806 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
807 pa_assert(pa_cvolume_is_norm(&i->volume));
808 pa_assert(pa_cvolume_is_norm(&i->reference_ratio));
811 set_real_ratio(i, &i->volume);
814 if (pa_sink_input_is_passthrough(i))
815 pa_sink_enter_passthrough(i->sink);
817 i->thread_info.soft_volume = i->soft_volume;
818 i->thread_info.muted = i->muted;
820 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_ADD_INPUT, i, 0, NULL) == 0);
822 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, i->index);
823 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], i);
825 pa_sink_update_status(i->sink);
828 /* Called from main context */
829 void pa_sink_input_kill(pa_sink_input*i) {
830 pa_sink_input_assert_ref(i);
831 pa_assert_ctl_context();
832 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
837 /* Called from main context */
838 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency) {
839 pa_usec_t r[2] = { 0, 0 };
841 pa_sink_input_assert_ref(i);
842 pa_assert_ctl_context();
843 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
845 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_LATENCY, r, 0, NULL) == 0);
848 r[0] += i->get_latency(i);
851 *sink_latency = r[1];
856 /* Called from thread context */
857 void pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink bytes */, pa_memchunk *chunk, pa_cvolume *volume) {
858 bool do_volume_adj_here, need_volume_factor_sink;
860 size_t block_size_max_sink, block_size_max_sink_input;
864 pa_sink_input_assert_ref(i);
865 pa_sink_input_assert_io_context(i);
866 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
867 pa_assert(pa_frame_aligned(slength, &i->sink->sample_spec));
871 #ifdef SINK_INPUT_DEBUG
872 pa_log_debug("peek");
875 block_size_max_sink_input = i->thread_info.resampler ?
876 pa_resampler_max_block_size(i->thread_info.resampler) :
877 pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sample_spec);
879 block_size_max_sink = pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sink->sample_spec);
881 /* Default buffer size */
883 slength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sink->sample_spec);
885 if (slength > block_size_max_sink)
886 slength = block_size_max_sink;
888 if (i->thread_info.resampler) {
889 ilength = pa_resampler_request(i->thread_info.resampler, slength);
892 ilength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sample_spec);
896 /* Length corresponding to slength (without limiting to
897 * block_size_max_sink_input). */
898 ilength_full = ilength;
900 if (ilength > block_size_max_sink_input)
901 ilength = block_size_max_sink_input;
903 /* If the channel maps of the sink and this stream differ, we need
904 * to adjust the volume *before* we resample. Otherwise we can do
905 * it after and leave it for the sink code */
907 do_volume_adj_here = !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map);
908 volume_is_norm = pa_cvolume_is_norm(&i->thread_info.soft_volume) && !i->thread_info.muted;
909 need_volume_factor_sink = !pa_cvolume_is_norm(&i->volume_factor_sink);
911 while (!pa_memblockq_is_readable(i->thread_info.render_memblockq)) {
914 /* There's nothing in our render queue. We need to fill it up
915 * with data from the implementor. */
917 if (i->thread_info.state == PA_SINK_INPUT_CORKED ||
918 i->pop(i, ilength, &tchunk) < 0) {
920 /* OK, we're corked or the implementor didn't give us any
921 * data, so let's just hand out silence */
922 pa_atomic_store(&i->thread_info.drained, 1);
924 pa_memblockq_seek(i->thread_info.render_memblockq, (int64_t) slength, PA_SEEK_RELATIVE, true);
925 i->thread_info.playing_for = 0;
926 if (i->thread_info.underrun_for != (uint64_t) -1) {
927 i->thread_info.underrun_for += ilength_full;
928 i->thread_info.underrun_for_sink += slength;
933 pa_atomic_store(&i->thread_info.drained, 0);
935 pa_assert(tchunk.length > 0);
936 pa_assert(tchunk.memblock);
938 i->thread_info.underrun_for = 0;
939 i->thread_info.underrun_for_sink = 0;
940 i->thread_info.playing_for += tchunk.length;
942 while (tchunk.length > 0) {
944 bool nvfs = need_volume_factor_sink;
947 pa_memblock_ref(wchunk.memblock);
949 if (wchunk.length > block_size_max_sink_input)
950 wchunk.length = block_size_max_sink_input;
952 /* It might be necessary to adjust the volume here */
953 if (do_volume_adj_here && !volume_is_norm) {
954 pa_memchunk_make_writable(&wchunk, 0);
956 if (i->thread_info.muted) {
957 pa_silence_memchunk(&wchunk, &i->thread_info.sample_spec);
960 } else if (!i->thread_info.resampler && nvfs) {
963 /* If we don't need a resampler we can merge the
964 * post and the pre volume adjustment into one */
966 pa_sw_cvolume_multiply(&v, &i->thread_info.soft_volume, &i->volume_factor_sink);
967 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &v);
971 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.soft_volume);
974 if (!i->thread_info.resampler) {
977 pa_memchunk_make_writable(&wchunk, 0);
978 pa_volume_memchunk(&wchunk, &i->sink->sample_spec, &i->volume_factor_sink);
981 pa_memblockq_push_align(i->thread_info.render_memblockq, &wchunk);
984 pa_resampler_run(i->thread_info.resampler, &wchunk, &rchunk);
986 #ifdef SINK_INPUT_DEBUG
987 pa_log_debug("pushing %lu", (unsigned long) rchunk.length);
990 if (rchunk.memblock) {
993 pa_memchunk_make_writable(&rchunk, 0);
994 pa_volume_memchunk(&rchunk, &i->sink->sample_spec, &i->volume_factor_sink);
997 pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk);
998 pa_memblock_unref(rchunk.memblock);
1002 pa_memblock_unref(wchunk.memblock);
1004 tchunk.index += wchunk.length;
1005 tchunk.length -= wchunk.length;
1008 pa_memblock_unref(tchunk.memblock);
1011 pa_assert_se(pa_memblockq_peek(i->thread_info.render_memblockq, chunk) >= 0);
1013 pa_assert(chunk->length > 0);
1014 pa_assert(chunk->memblock);
1016 #ifdef SINK_INPUT_DEBUG
1017 pa_log_debug("peeking %lu", (unsigned long) chunk->length);
1020 if (chunk->length > block_size_max_sink)
1021 chunk->length = block_size_max_sink;
1023 /* Let's see if we had to apply the volume adjustment ourselves,
1024 * or if this can be done by the sink for us */
1026 if (do_volume_adj_here)
1027 /* We had different channel maps, so we already did the adjustment */
1028 pa_cvolume_reset(volume, i->sink->sample_spec.channels);
1029 else if (i->thread_info.muted)
1030 /* We've both the same channel map, so let's have the sink do the adjustment for us*/
1031 pa_cvolume_mute(volume, i->sink->sample_spec.channels);
1033 *volume = i->thread_info.soft_volume;
1036 /* Called from thread context */
1037 void pa_sink_input_drop(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
1039 pa_sink_input_assert_ref(i);
1040 pa_sink_input_assert_io_context(i);
1041 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1042 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1043 pa_assert(nbytes > 0);
1045 #ifdef SINK_INPUT_DEBUG
1046 pa_log_debug("dropping %lu", (unsigned long) nbytes);
1049 pa_memblockq_drop(i->thread_info.render_memblockq, nbytes);
1052 /* Called from thread context */
1053 bool pa_sink_input_process_underrun(pa_sink_input *i) {
1054 pa_sink_input_assert_ref(i);
1055 pa_sink_input_assert_io_context(i);
1057 if (pa_memblockq_is_readable(i->thread_info.render_memblockq))
1060 if (i->process_underrun && i->process_underrun(i)) {
1061 /* All valid data has been played back, so we can empty this queue. */
1062 pa_memblockq_silence(i->thread_info.render_memblockq);
1068 /* Called from thread context */
1069 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
1071 bool called = false;
1073 pa_sink_input_assert_ref(i);
1074 pa_sink_input_assert_io_context(i);
1075 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1076 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1078 #ifdef SINK_INPUT_DEBUG
1079 pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes);
1082 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1084 if (nbytes > 0 && !i->thread_info.dont_rewind_render) {
1085 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes);
1086 pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes);
1089 if (i->thread_info.rewrite_nbytes == (size_t) -1) {
1091 /* We were asked to drop all buffered data, and rerequest new
1092 * data from implementor the next time peek() is called */
1094 pa_memblockq_flush_write(i->thread_info.render_memblockq, true);
1096 } else if (i->thread_info.rewrite_nbytes > 0) {
1097 size_t max_rewrite, amount;
1099 /* Calculate how much make sense to rewrite at most */
1100 max_rewrite = nbytes + lbq;
1102 /* Transform into local domain */
1103 if (i->thread_info.resampler)
1104 max_rewrite = pa_resampler_request(i->thread_info.resampler, max_rewrite);
1106 /* Calculate how much of the rewinded data should actually be rewritten */
1107 amount = PA_MIN(i->thread_info.rewrite_nbytes, max_rewrite);
1110 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount);
1112 /* Tell the implementor */
1113 if (i->process_rewind)
1114 i->process_rewind(i, amount);
1117 /* Convert back to to sink domain */
1118 if (i->thread_info.resampler)
1119 amount = pa_resampler_result(i->thread_info.resampler, amount);
1122 /* Ok, now update the write pointer */
1123 pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) amount), PA_SEEK_RELATIVE, true);
1125 if (i->thread_info.rewrite_flush)
1126 pa_memblockq_silence(i->thread_info.render_memblockq);
1128 /* And reset the resampler */
1129 if (i->thread_info.resampler)
1130 pa_resampler_reset(i->thread_info.resampler);
1135 if (i->process_rewind)
1136 i->process_rewind(i, 0);
1138 i->thread_info.rewrite_nbytes = 0;
1139 i->thread_info.rewrite_flush = false;
1140 i->thread_info.dont_rewind_render = false;
1143 /* Called from thread context */
1144 size_t pa_sink_input_get_max_rewind(pa_sink_input *i) {
1145 pa_sink_input_assert_ref(i);
1146 pa_sink_input_assert_io_context(i);
1148 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_rewind) : i->sink->thread_info.max_rewind;
1151 /* Called from thread context */
1152 size_t pa_sink_input_get_max_request(pa_sink_input *i) {
1153 pa_sink_input_assert_ref(i);
1154 pa_sink_input_assert_io_context(i);
1156 /* We're not verifying the status here, to allow this to be called
1157 * in the state change handler between _INIT and _RUNNING */
1159 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_request) : i->sink->thread_info.max_request;
1162 /* Called from thread context */
1163 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1164 pa_sink_input_assert_ref(i);
1165 pa_sink_input_assert_io_context(i);
1166 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1167 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1169 pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes);
1171 if (i->update_max_rewind)
1172 i->update_max_rewind(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1175 /* Called from thread context */
1176 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1177 pa_sink_input_assert_ref(i);
1178 pa_sink_input_assert_io_context(i);
1179 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1180 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1182 if (i->update_max_request)
1183 i->update_max_request(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1186 /* Called from thread context */
1187 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) {
1188 pa_sink_input_assert_ref(i);
1189 pa_sink_input_assert_io_context(i);
1191 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1192 usec = i->sink->thread_info.fixed_latency;
1194 if (usec != (pa_usec_t) -1)
1195 usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
1197 i->thread_info.requested_sink_latency = usec;
1198 pa_sink_invalidate_requested_latency(i->sink, true);
1203 /* Called from main context */
1204 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) {
1205 pa_sink_input_assert_ref(i);
1206 pa_assert_ctl_context();
1208 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1209 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1213 /* If this sink input is not realized yet or we are being moved,
1214 * we have to touch the thread info data directly */
1217 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1218 usec = pa_sink_get_fixed_latency(i->sink);
1220 if (usec != (pa_usec_t) -1) {
1221 pa_usec_t min_latency, max_latency;
1222 pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
1223 usec = PA_CLAMP(usec, min_latency, max_latency);
1227 i->thread_info.requested_sink_latency = usec;
1232 /* Called from main context */
1233 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
1234 pa_sink_input_assert_ref(i);
1235 pa_assert_ctl_context();
1237 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1239 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1243 /* If this sink input is not realized yet or we are being moved,
1244 * we have to touch the thread info data directly */
1246 return i->thread_info.requested_sink_latency;
1249 /* Called from main context */
1250 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, bool save, bool absolute) {
1253 pa_sink_input_assert_ref(i);
1254 pa_assert_ctl_context();
1255 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1257 pa_assert(pa_cvolume_valid(volume));
1258 pa_assert(volume->channels == 1 || pa_cvolume_compatible(volume, &i->sample_spec));
1259 pa_assert(i->volume_writable);
1261 if (!absolute && pa_sink_flat_volume_enabled(i->sink)) {
1262 v = i->sink->reference_volume;
1263 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
1265 if (pa_cvolume_compatible(volume, &i->sample_spec))
1266 volume = pa_sw_cvolume_multiply(&v, &v, volume);
1268 volume = pa_sw_cvolume_multiply_scalar(&v, &v, pa_cvolume_max(volume));
1270 if (!pa_cvolume_compatible(volume, &i->sample_spec)) {
1272 volume = pa_cvolume_scale(&v, pa_cvolume_max(volume));
1276 if (pa_cvolume_equal(volume, &i->volume)) {
1277 i->save_volume = i->save_volume || save;
1281 i->volume = *volume;
1282 i->save_volume = save;
1284 if (pa_sink_flat_volume_enabled(i->sink)) {
1285 /* We are in flat volume mode, so let's update all sink input
1286 * volumes and update the flat volume of the sink */
1288 pa_sink_set_volume(i->sink, NULL, true, save);
1291 /* OK, we are in normal volume mode. The volume only affects
1293 set_real_ratio(i, volume);
1294 i->reference_ratio = i->volume;
1296 /* Copy the new soft_volume to the thread_info struct */
1297 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1300 /* The volume changed, let's tell people so */
1301 if (i->volume_changed)
1302 i->volume_changed(i);
1304 /* The virtual volume changed, let's tell people so */
1305 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1308 void pa_sink_input_add_volume_factor(pa_sink_input *i, const char *key, const pa_cvolume *volume_factor) {
1309 struct volume_factor_entry *v;
1311 pa_sink_input_assert_ref(i);
1312 pa_assert_ctl_context();
1313 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1314 pa_assert(volume_factor);
1316 pa_assert(pa_cvolume_valid(volume_factor));
1317 pa_assert(volume_factor->channels == 1 || pa_cvolume_compatible(volume_factor, &i->sample_spec));
1319 v = volume_factor_entry_new(key, volume_factor);
1320 if (!pa_cvolume_compatible(volume_factor, &i->sample_spec))
1321 pa_cvolume_set(&v->volume, i->sample_spec.channels, volume_factor->values[0]);
1323 pa_assert_se(pa_hashmap_put(i->volume_factor_items, v->key, v) >= 0);
1324 if (pa_hashmap_size(i->volume_factor_items) == 1)
1325 i->volume_factor = v->volume;
1327 pa_sw_cvolume_multiply(&i->volume_factor, &i->volume_factor, &v->volume);
1329 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1331 /* Copy the new soft_volume to the thread_info struct */
1332 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1335 /* Returns 0 if an entry was removed and -1 if no entry for the given key was
1337 int pa_sink_input_remove_volume_factor(pa_sink_input *i, const char *key) {
1338 struct volume_factor_entry *v;
1340 pa_sink_input_assert_ref(i);
1342 pa_assert_ctl_context();
1343 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1345 v = pa_hashmap_remove(i->volume_factor_items, key);
1350 volume_factor_entry_free(v);
1352 switch (pa_hashmap_size(i->volume_factor_items)) {
1354 pa_cvolume_reset(&i->volume_factor, i->sample_spec.channels);
1357 v = pa_hashmap_first(i->volume_factor_items);
1358 i->volume_factor = v->volume;
1361 volume_factor_from_hashmap(&i->volume_factor, i->volume_factor_items, i->volume_factor.channels);
1364 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1366 /* Copy the new soft_volume to the thread_info struct */
1367 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1372 /* Called from main context */
1373 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
1374 pa_sink_input_assert_ref(i);
1375 pa_assert_ctl_context();
1376 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1377 pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
1379 /* This basically calculates:
1381 * i->real_ratio := v
1382 * i->soft_volume := i->real_ratio * i->volume_factor */
1387 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
1389 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1390 /* We don't copy the data to the thread_info data. That's left for someone else to do */
1393 /* Called from main or I/O context */
1394 bool pa_sink_input_is_passthrough(pa_sink_input *i) {
1395 pa_sink_input_assert_ref(i);
1397 if (PA_UNLIKELY(!pa_format_info_is_pcm(i->format)))
1400 if (PA_UNLIKELY(i->flags & PA_SINK_INPUT_PASSTHROUGH))
1406 /* Called from main context */
1407 bool pa_sink_input_is_volume_readable(pa_sink_input *i) {
1408 pa_sink_input_assert_ref(i);
1409 pa_assert_ctl_context();
1411 return !pa_sink_input_is_passthrough(i);
1414 /* Called from main context */
1415 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, bool absolute) {
1416 pa_sink_input_assert_ref(i);
1417 pa_assert_ctl_context();
1418 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1419 pa_assert(pa_sink_input_is_volume_readable(i));
1421 if (absolute || !pa_sink_flat_volume_enabled(i->sink))
1422 *volume = i->volume;
1424 *volume = i->reference_ratio;
1429 /* Called from main context */
1430 void pa_sink_input_set_mute(pa_sink_input *i, bool mute, bool save) {
1431 pa_sink_input_assert_ref(i);
1432 pa_assert_ctl_context();
1433 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1435 if (!i->muted == !mute) {
1436 i->save_muted = i->save_muted || mute;
1441 i->save_muted = save;
1443 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1445 /* The mute status changed, let's tell people so */
1446 if (i->mute_changed)
1449 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1452 /* Called from main context */
1453 bool pa_sink_input_get_mute(pa_sink_input *i) {
1454 pa_sink_input_assert_ref(i);
1455 pa_assert_ctl_context();
1456 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1461 /* Called from main thread */
1462 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1463 pa_sink_input_assert_ref(i);
1464 pa_assert_ctl_context();
1467 pa_proplist_update(i->proplist, mode, p);
1469 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1470 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1471 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1475 /* Called from main context */
1476 void pa_sink_input_cork(pa_sink_input *i, bool b) {
1477 pa_sink_input_assert_ref(i);
1478 pa_assert_ctl_context();
1479 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1481 sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1484 /* Called from main context */
1485 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1486 pa_sink_input_assert_ref(i);
1487 pa_assert_ctl_context();
1488 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1489 pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1491 if (i->sample_spec.rate == rate)
1494 i->sample_spec.rate = rate;
1496 pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1498 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1502 /* Called from main context */
1503 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1505 pa_sink_input_assert_ref(i);
1506 pa_assert_ctl_context();
1508 if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1511 old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1513 if (old && name && pa_streq(old, name))
1517 pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1519 pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1521 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1522 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1523 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1527 /* Called from main context */
1528 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1529 pa_sink_input_assert_ref(i);
1530 pa_assert_ctl_context();
1532 return i->actual_resample_method;
1535 /* Called from main context */
1536 bool pa_sink_input_may_move(pa_sink_input *i) {
1537 pa_sink_input_assert_ref(i);
1538 pa_assert_ctl_context();
1539 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1541 if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1544 if (i->sync_next || i->sync_prev) {
1545 pa_log_warn("Moving synchronized streams not supported.");
1552 static bool find_filter_sink_input(pa_sink_input *target, pa_sink *s) {
1554 while (s && s->input_to_master) {
1555 if (s->input_to_master == target)
1557 s = s->input_to_master->sink;
1558 pa_assert(i++ < 100);
1563 /* Called from main context */
1564 bool pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1565 pa_sink_input_assert_ref(i);
1566 pa_assert_ctl_context();
1567 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1568 pa_sink_assert_ref(dest);
1570 if (dest == i->sink)
1573 if (!pa_sink_input_may_move(i))
1576 /* Make sure we're not creating a filter sink cycle */
1577 if (find_filter_sink_input(i, dest)) {
1578 pa_log_debug("Can't connect input to %s, as that would create a cycle.", dest->name);
1582 if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1583 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1587 if (check_passthrough_connection(pa_sink_input_is_passthrough(i), dest) < 0)
1591 if (!i->may_move_to(i, dest))
1597 /* Called from main context */
1598 int pa_sink_input_start_move(pa_sink_input *i) {
1599 pa_source_output *o, *p = NULL;
1600 struct volume_factor_entry *v;
1604 pa_sink_input_assert_ref(i);
1605 pa_assert_ctl_context();
1606 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1609 if (!pa_sink_input_may_move(i))
1610 return -PA_ERR_NOTSUPPORTED;
1612 if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1615 /* Kill directly connected outputs */
1616 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1618 pa_source_output_kill(o);
1621 pa_assert(pa_idxset_isempty(i->direct_outputs));
1623 pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1625 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1626 pa_assert_se(i->sink->n_corked-- >= 1);
1628 if (pa_sink_input_is_passthrough(i))
1629 pa_sink_leave_passthrough(i->sink);
1631 if (pa_sink_flat_volume_enabled(i->sink))
1632 /* We might need to update the sink's volume if we are in flat
1634 pa_sink_set_volume(i->sink, NULL, false, false);
1636 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1638 pa_sink_update_status(i->sink);
1640 PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state)
1641 pa_cvolume_remap(&v->volume, &i->sink->channel_map, &i->channel_map);
1643 pa_cvolume_remap(&i->volume_factor_sink, &i->sink->channel_map, &i->channel_map);
1647 pa_sink_input_unref(i);
1652 /* Called from main context. If i has an origin sink that uses volume sharing,
1653 * then also the origin sink and all streams connected to it need to update
1654 * their volume - this function does all that by using recursion. */
1655 static void update_volume_due_to_moving(pa_sink_input *i, pa_sink *dest) {
1656 pa_cvolume old_volume;
1660 pa_assert(i->sink); /* The destination sink should already be set. */
1662 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1663 pa_sink *root_sink = pa_sink_get_master(i->sink);
1664 pa_sink_input *origin_sink_input;
1667 if (PA_UNLIKELY(!root_sink))
1670 if (pa_sink_flat_volume_enabled(i->sink)) {
1671 /* Ok, so the origin sink uses volume sharing, and flat volume is
1672 * enabled. The volume will have to be updated as follows:
1674 * i->volume := i->sink->real_volume
1675 * (handled later by pa_sink_set_volume)
1676 * i->reference_ratio := i->volume / i->sink->reference_volume
1677 * (handled later by pa_sink_set_volume)
1678 * i->real_ratio stays unchanged
1679 * (streams whose origin sink uses volume sharing should
1680 * always have real_ratio of 0 dB)
1681 * i->soft_volume stays unchanged
1682 * (streams whose origin sink uses volume sharing should
1683 * always have volume_factor as soft_volume, so no change
1684 * should be needed) */
1686 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1687 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1689 /* Notifications will be sent by pa_sink_set_volume(). */
1692 /* Ok, so the origin sink uses volume sharing, and flat volume is
1693 * disabled. The volume will have to be updated as follows:
1696 * i->reference_ratio := 0 dB
1697 * i->real_ratio stays unchanged
1698 * (streams whose origin sink uses volume sharing should
1699 * always have real_ratio of 0 dB)
1700 * i->soft_volume stays unchanged
1701 * (streams whose origin sink uses volume sharing should
1702 * always have volume_factor as soft_volume, so no change
1703 * should be needed) */
1705 old_volume = i->volume;
1706 pa_cvolume_reset(&i->volume, i->volume.channels);
1707 pa_cvolume_reset(&i->reference_ratio, i->reference_ratio.channels);
1708 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1709 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1711 /* Notify others about the changed sink input volume. */
1712 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1713 if (i->volume_changed)
1714 i->volume_changed(i);
1716 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1720 /* Additionally, the origin sink volume needs updating:
1722 * i->origin_sink->reference_volume := root_sink->reference_volume
1723 * i->origin_sink->real_volume := root_sink->real_volume
1724 * i->origin_sink->soft_volume stays unchanged
1725 * (sinks that use volume sharing should always have
1726 * soft_volume of 0 dB) */
1728 old_volume = i->origin_sink->reference_volume;
1730 i->origin_sink->reference_volume = root_sink->reference_volume;
1731 pa_cvolume_remap(&i->origin_sink->reference_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1733 i->origin_sink->real_volume = root_sink->real_volume;
1734 pa_cvolume_remap(&i->origin_sink->real_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1736 pa_assert(pa_cvolume_is_norm(&i->origin_sink->soft_volume));
1738 /* Notify others about the changed sink volume. If you wonder whether
1739 * i->origin_sink->set_volume() should be called somewhere, that's not
1740 * the case, because sinks that use volume sharing shouldn't have any
1741 * internal volume that set_volume() would update. If you wonder
1742 * whether the thread_info variables should be synced, yes, they
1743 * should, and it's done by the PA_SINK_MESSAGE_FINISH_MOVE message
1745 if (!pa_cvolume_equal(&i->origin_sink->reference_volume, &old_volume))
1746 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, i->origin_sink->index);
1748 /* Recursively update origin sink inputs. */
1749 PA_IDXSET_FOREACH(origin_sink_input, i->origin_sink->inputs, idx)
1750 update_volume_due_to_moving(origin_sink_input, dest);
1753 old_volume = i->volume;
1755 if (pa_sink_flat_volume_enabled(i->sink)) {
1756 /* Ok, so this is a regular stream, and flat volume is enabled. The
1757 * volume will have to be updated as follows:
1759 * i->volume := i->reference_ratio * i->sink->reference_volume
1760 * i->reference_ratio stays unchanged
1761 * i->real_ratio := i->volume / i->sink->real_volume
1762 * (handled later by pa_sink_set_volume)
1763 * i->soft_volume := i->real_ratio * i->volume_factor
1764 * (handled later by pa_sink_set_volume) */
1766 i->volume = i->sink->reference_volume;
1767 pa_cvolume_remap(&i->volume, &i->sink->channel_map, &i->channel_map);
1768 pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1771 /* Ok, so this is a regular stream, and flat volume is disabled.
1772 * The volume will have to be updated as follows:
1774 * i->volume := i->reference_ratio
1775 * i->reference_ratio stays unchanged
1776 * i->real_ratio := i->reference_ratio
1777 * i->soft_volume := i->real_ratio * i->volume_factor */
1779 i->volume = i->reference_ratio;
1780 i->real_ratio = i->reference_ratio;
1781 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1784 /* Notify others about the changed sink input volume. */
1785 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1786 /* XXX: In case i->sink has flat volume enabled, then real_ratio
1787 * and soft_volume are not updated yet. Let's hope that the
1788 * callback implementation doesn't care about those variables... */
1789 if (i->volume_changed)
1790 i->volume_changed(i);
1792 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1796 /* If i->sink == dest, then recursion has finished, and we can finally call
1797 * pa_sink_set_volume(), which will do the rest of the updates. */
1798 if ((i->sink == dest) && pa_sink_flat_volume_enabled(i->sink))
1799 pa_sink_set_volume(i->sink, NULL, false, i->save_volume);
1802 /* Called from main context */
1803 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, bool save) {
1804 struct volume_factor_entry *v;
1807 pa_sink_input_assert_ref(i);
1808 pa_assert_ctl_context();
1809 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1810 pa_assert(!i->sink);
1811 pa_sink_assert_ref(dest);
1813 if (!pa_sink_input_may_move_to(i, dest))
1814 return -PA_ERR_NOTSUPPORTED;
1816 if (pa_sink_input_is_passthrough(i) && !pa_sink_check_format(dest, i->format)) {
1817 pa_proplist *p = pa_proplist_new();
1818 pa_log_debug("New sink doesn't support stream format, sending format-changed and killing");
1819 /* Tell the client what device we want to be on if it is going to
1821 pa_proplist_sets(p, "device", dest->name);
1822 pa_sink_input_send_event(i, PA_STREAM_EVENT_FORMAT_LOST, p);
1823 pa_proplist_free(p);
1824 return -PA_ERR_NOTSUPPORTED;
1827 if (!(i->flags & PA_SINK_INPUT_VARIABLE_RATE) &&
1828 !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec)) {
1829 /* try to change dest sink rate if possible without glitches.
1830 module-suspend-on-idle resumes destination sink with
1831 SINK_INPUT_MOVE_FINISH hook */
1833 pa_log_info("Trying to change sample rate");
1834 if (pa_sink_update_rate(dest, i->sample_spec.rate, pa_sink_input_is_passthrough(i)) >= 0)
1835 pa_log_info("Rate changed to %u Hz", dest->sample_spec.rate);
1842 i->save_sink = save;
1843 pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1845 PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state)
1846 pa_cvolume_remap(&v->volume, &i->channel_map, &i->sink->channel_map);
1848 pa_cvolume_remap(&i->volume_factor_sink, &i->channel_map, &i->sink->channel_map);
1850 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1851 i->sink->n_corked++;
1853 pa_sink_input_update_rate(i);
1855 pa_sink_update_status(dest);
1857 update_volume_due_to_moving(i, dest);
1859 if (pa_sink_input_is_passthrough(i))
1860 pa_sink_enter_passthrough(i->sink);
1862 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1864 pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1866 /* Notify everyone */
1867 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1868 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1873 /* Called from main context */
1874 void pa_sink_input_fail_move(pa_sink_input *i) {
1876 pa_sink_input_assert_ref(i);
1877 pa_assert_ctl_context();
1878 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1879 pa_assert(!i->sink);
1881 /* Check if someone wants this sink input? */
1882 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1888 pa_sink_input_kill(i);
1891 /* Called from main context */
1892 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, bool save) {
1895 pa_sink_input_assert_ref(i);
1896 pa_assert_ctl_context();
1897 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1899 pa_sink_assert_ref(dest);
1901 if (dest == i->sink)
1904 if (!pa_sink_input_may_move_to(i, dest))
1905 return -PA_ERR_NOTSUPPORTED;
1907 pa_sink_input_ref(i);
1909 if ((r = pa_sink_input_start_move(i)) < 0) {
1910 pa_sink_input_unref(i);
1914 if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1915 pa_sink_input_fail_move(i);
1916 pa_sink_input_unref(i);
1920 pa_sink_input_unref(i);
1925 /* Called from IO thread context */
1926 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1927 bool corking, uncorking;
1929 pa_sink_input_assert_ref(i);
1930 pa_sink_input_assert_io_context(i);
1932 if (state == i->thread_info.state)
1935 if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1936 !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1937 pa_atomic_store(&i->thread_info.drained, 1);
1939 corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1940 uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1942 if (i->state_change)
1943 i->state_change(i, state);
1947 pa_log_debug("Requesting rewind due to corking");
1949 /* This will tell the implementing sink input driver to rewind
1950 * so that the unplayed already mixed data is not lost */
1951 pa_sink_input_request_rewind(i, 0, true, true, false);
1953 /* Set the corked state *after* requesting rewind */
1954 i->thread_info.state = state;
1956 } else if (uncorking) {
1958 pa_log_debug("Requesting rewind due to uncorking");
1960 i->thread_info.underrun_for = (uint64_t) -1;
1961 i->thread_info.underrun_for_sink = 0;
1962 i->thread_info.playing_for = 0;
1964 /* Set the uncorked state *before* requesting rewind */
1965 i->thread_info.state = state;
1967 /* OK, we're being uncorked. Make sure we're not rewound when
1968 * the hw buffer is remixed and request a remix. */
1969 pa_sink_input_request_rewind(i, 0, false, true, true);
1971 /* We may not be corking or uncorking, but we still need to set the state. */
1972 i->thread_info.state = state;
1975 /* Called from thread context, except when it is not. */
1976 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1977 pa_sink_input *i = PA_SINK_INPUT(o);
1978 pa_sink_input_assert_ref(i);
1982 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1983 if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1984 i->thread_info.soft_volume = i->soft_volume;
1985 pa_sink_input_request_rewind(i, 0, true, false, false);
1989 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1990 if (i->thread_info.muted != i->muted) {
1991 i->thread_info.muted = i->muted;
1992 pa_sink_input_request_rewind(i, 0, true, false, false);
1996 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1997 pa_usec_t *r = userdata;
1999 r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
2000 r[1] += pa_sink_get_latency_within_thread(i->sink);
2005 case PA_SINK_INPUT_MESSAGE_SET_RATE:
2007 i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
2008 pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
2012 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
2013 pa_sink_input *ssync;
2015 pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
2017 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
2018 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
2020 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
2021 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
2026 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
2027 pa_usec_t *usec = userdata;
2029 *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
2033 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
2034 pa_usec_t *r = userdata;
2036 *r = i->thread_info.requested_sink_latency;
2041 return -PA_ERR_NOTIMPLEMENTED;
2044 /* Called from main thread */
2045 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
2046 pa_sink_input_assert_ref(i);
2047 pa_assert_ctl_context();
2049 if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
2050 return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
2055 /* Called from IO context */
2056 bool pa_sink_input_safe_to_remove(pa_sink_input *i) {
2057 pa_sink_input_assert_ref(i);
2058 pa_sink_input_assert_io_context(i);
2060 if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
2061 return pa_memblockq_is_empty(i->thread_info.render_memblockq);
2066 /* Called from IO context */
2067 void pa_sink_input_request_rewind(
2069 size_t nbytes /* in our sample spec */,
2072 bool dont_rewind_render) {
2076 /* If 'rewrite' is true the sink is rewound as far as requested
2077 * and possible and the exact value of this is passed back the
2078 * implementor via process_rewind(). If 'flush' is also true all
2079 * already rendered data is also dropped.
2081 * If 'rewrite' is false the sink is rewound as far as requested
2082 * and possible and the already rendered data is dropped so that
2083 * in the next iteration we read new data from the
2084 * implementor. This implies 'flush' is true. If
2085 * dont_rewind_render is true then the render memblockq is not
2088 /* nbytes = 0 means maximum rewind request */
2090 pa_sink_input_assert_ref(i);
2091 pa_sink_input_assert_io_context(i);
2092 pa_assert(rewrite || flush);
2093 pa_assert(!dont_rewind_render || !rewrite);
2095 /* We don't take rewind requests while we are corked */
2096 if (i->thread_info.state == PA_SINK_INPUT_CORKED)
2099 nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
2101 #ifdef SINK_INPUT_DEBUG
2102 pa_log_debug("request rewrite %zu", nbytes);
2105 /* Calculate how much we can rewind locally without having to
2108 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
2112 /* Check if rewinding for the maximum is requested, and if so, fix up */
2115 /* Calculate maximum number of bytes that could be rewound in theory */
2116 nbytes = i->sink->thread_info.max_rewind + lbq;
2118 /* Transform from sink domain */
2119 if (i->thread_info.resampler)
2120 nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
2123 /* Remember how much we actually want to rewrite */
2124 if (i->thread_info.rewrite_nbytes != (size_t) -1) {
2126 /* Make sure to not overwrite over underruns */
2127 if (nbytes > i->thread_info.playing_for)
2128 nbytes = (size_t) i->thread_info.playing_for;
2130 i->thread_info.rewrite_nbytes = nbytes;
2132 i->thread_info.rewrite_nbytes = (size_t) -1;
2135 i->thread_info.rewrite_flush =
2136 i->thread_info.rewrite_flush || flush;
2138 i->thread_info.dont_rewind_render =
2139 i->thread_info.dont_rewind_render ||
2142 /* nbytes is -1 if some earlier rewind request had rewrite == false. */
2143 if (nbytes != (size_t) -1) {
2145 /* Transform to sink domain */
2146 if (i->thread_info.resampler)
2147 nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
2150 pa_sink_request_rewind(i->sink, nbytes - lbq);
2152 /* This call will make sure process_rewind() is called later */
2153 pa_sink_request_rewind(i->sink, 0);
2157 /* Called from main context */
2158 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
2159 pa_sink_input_assert_ref(i);
2160 pa_assert_ctl_context();
2163 /* FIXME: Shouldn't access resampler object from main context! */
2165 pa_silence_memchunk_get(
2166 &i->core->silence_cache,
2170 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
2175 /* Called from main context */
2176 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
2177 pa_proplist *pl = NULL;
2178 pa_sink_input_send_event_hook_data hook_data;
2180 pa_sink_input_assert_ref(i);
2181 pa_assert_ctl_context();
2188 data = pl = pa_proplist_new();
2190 hook_data.sink_input = i;
2191 hook_data.data = data;
2192 hook_data.event = event;
2194 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
2197 i->send_event(i, event, data);
2201 pa_proplist_free(pl);
2204 /* Called from main context */
2205 /* Updates the sink input's resampler with whatever the current sink requires
2206 * -- useful when the underlying sink's rate might have changed */
2207 int pa_sink_input_update_rate(pa_sink_input *i) {
2208 pa_resampler *new_resampler;
2209 char *memblockq_name;
2211 pa_sink_input_assert_ref(i);
2212 pa_assert_ctl_context();
2214 if (i->thread_info.resampler &&
2215 pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &i->sink->sample_spec) &&
2216 pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &i->sink->channel_map))
2218 new_resampler = i->thread_info.resampler;
2220 else if (!pa_sink_input_is_passthrough(i) &&
2221 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
2222 !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec) ||
2223 !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map))) {
2225 new_resampler = pa_resampler_new(i->core->mempool,
2226 &i->sample_spec, &i->channel_map,
2227 &i->sink->sample_spec, &i->sink->channel_map,
2228 i->requested_resample_method,
2229 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
2230 ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
2231 (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0));
2233 if (!new_resampler) {
2234 pa_log_warn("Unsupported resampling operation.");
2235 return -PA_ERR_NOTSUPPORTED;
2238 new_resampler = NULL;
2240 if (new_resampler == i->thread_info.resampler)
2243 if (i->thread_info.resampler)
2244 pa_resampler_free(i->thread_info.resampler);
2246 i->thread_info.resampler = new_resampler;
2248 pa_memblockq_free(i->thread_info.render_memblockq);
2250 memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
2251 i->thread_info.render_memblockq = pa_memblockq_new(
2254 MEMBLOCKQ_MAXLENGTH,
2256 &i->sink->sample_spec,
2261 pa_xfree(memblockq_name);
2263 i->actual_resample_method = new_resampler ? pa_resampler_get_method(new_resampler) : PA_RESAMPLER_INVALID;
2265 pa_log_debug("Updated resampler for sink input %d", i->index);