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 MEMBLOCKQ_MAXLENGTH (32*1024*1024)
45 #define CONVERT_BUFFER_LENGTH (PA_PAGE_SIZE)
47 PA_DEFINE_PUBLIC_CLASS(pa_sink_input, pa_msgobject);
49 static void sink_input_free(pa_object *o);
50 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v);
52 static int check_passthrough_connection(pa_bool_t passthrough, pa_sink *dest) {
53 if (pa_sink_is_passthrough(dest)) {
54 pa_log_warn("Sink is already connected to PASSTHROUGH input");
58 /* If current input(s) exist, check new input is not PASSTHROUGH */
59 if (pa_idxset_size(dest->inputs) > 0 && passthrough) {
60 pa_log_warn("Sink is already connected, cannot accept new PASSTHROUGH INPUT");
67 pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data) {
71 data->resample_method = PA_RESAMPLER_INVALID;
72 data->proplist = pa_proplist_new();
73 data->volume_writable = TRUE;
78 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec) {
81 if ((data->sample_spec_is_set = !!spec))
82 data->sample_spec = *spec;
85 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map) {
88 if ((data->channel_map_is_set = !!map))
89 data->channel_map = *map;
92 pa_bool_t pa_sink_input_new_data_is_passthrough(pa_sink_input_new_data *data) {
95 if (PA_LIKELY(data->format) && PA_UNLIKELY(!pa_format_info_is_pcm(data->format)))
98 if (PA_UNLIKELY(data->flags & PA_SINK_INPUT_PASSTHROUGH))
104 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume) {
106 pa_assert(data->volume_writable);
108 if ((data->volume_is_set = !!volume))
109 data->volume = *volume;
112 void pa_sink_input_new_data_apply_volume_factor(pa_sink_input_new_data *data, const pa_cvolume *volume_factor) {
114 pa_assert(volume_factor);
116 if (data->volume_factor_is_set)
117 pa_sw_cvolume_multiply(&data->volume_factor, &data->volume_factor, volume_factor);
119 data->volume_factor_is_set = TRUE;
120 data->volume_factor = *volume_factor;
124 void pa_sink_input_new_data_apply_volume_factor_sink(pa_sink_input_new_data *data, const pa_cvolume *volume_factor) {
126 pa_assert(volume_factor);
128 if (data->volume_factor_sink_is_set)
129 pa_sw_cvolume_multiply(&data->volume_factor_sink, &data->volume_factor_sink, volume_factor);
131 data->volume_factor_sink_is_set = TRUE;
132 data->volume_factor_sink = *volume_factor;
136 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, pa_bool_t mute) {
139 data->muted_is_set = TRUE;
140 data->muted = !!mute;
143 pa_bool_t pa_sink_input_new_data_set_sink(pa_sink_input_new_data *data, pa_sink *s, pa_bool_t save) {
144 pa_bool_t ret = TRUE;
145 pa_idxset *formats = NULL;
150 if (!data->req_formats) {
151 /* We're not working with the extended API */
153 data->save_sink = save;
155 /* Extended API: let's see if this sink supports the formats the client can provide */
156 formats = pa_sink_check_formats(s, data->req_formats);
158 if (formats && !pa_idxset_isempty(formats)) {
159 /* Sink supports at least one of the requested formats */
161 data->save_sink = save;
162 if (data->nego_formats)
163 pa_idxset_free(data->nego_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
164 data->nego_formats = formats;
166 /* Sink doesn't support any of the formats requested by the client */
168 pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
176 pa_bool_t pa_sink_input_new_data_set_formats(pa_sink_input_new_data *data, pa_idxset *formats) {
180 if (data->req_formats)
181 pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
183 data->req_formats = formats;
186 /* Trigger format negotiation */
187 return pa_sink_input_new_data_set_sink(data, data->sink, data->save_sink);
193 void pa_sink_input_new_data_done(pa_sink_input_new_data *data) {
196 if (data->req_formats)
197 pa_idxset_free(data->req_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
199 if (data->nego_formats)
200 pa_idxset_free(data->nego_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
203 pa_format_info_free(data->format);
205 pa_proplist_free(data->proplist);
208 /* Called from main context */
209 static void reset_callbacks(pa_sink_input *i) {
213 i->process_rewind = NULL;
214 i->update_max_rewind = NULL;
215 i->update_max_request = NULL;
216 i->update_sink_requested_latency = NULL;
217 i->update_sink_latency_range = NULL;
218 i->update_sink_fixed_latency = NULL;
222 i->suspend_within_thread = NULL;
225 i->get_latency = NULL;
226 i->state_change = NULL;
227 i->may_move_to = NULL;
228 i->send_event = NULL;
229 i->volume_changed = NULL;
230 i->mute_changed = NULL;
233 /* Called from main context */
234 int pa_sink_input_new(
237 pa_sink_input_new_data *data) {
240 pa_resampler *resampler = NULL;
241 char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
242 pa_channel_map original_cm;
251 pa_assert_ctl_context();
254 pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->client->proplist);
256 if (data->origin_sink && (data->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
257 data->volume_writable = FALSE;
259 if (!data->req_formats) {
260 /* From this point on, we want to work only with formats, and get back
261 * to using the sample spec and channel map after all decisions w.r.t.
262 * routing are complete. */
263 pa_idxset *tmp = pa_idxset_new(NULL, NULL);
264 pa_format_info *f = pa_format_info_from_sample_spec(&data->sample_spec,
265 data->channel_map_is_set ? &data->channel_map : NULL);
266 pa_idxset_put(tmp, f, NULL);
267 pa_sink_input_new_data_set_formats(data, tmp);
270 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], data)) < 0)
273 pa_return_val_if_fail(!data->driver || pa_utf8_valid(data->driver), -PA_ERR_INVALID);
276 pa_sink *sink = pa_namereg_get(core, NULL, PA_NAMEREG_SINK);
277 pa_return_val_if_fail(sink, -PA_ERR_NOENTITY);
278 pa_sink_input_new_data_set_sink(data, sink, FALSE);
280 /* Routing's done, we have a sink. Now let's fix the format and set up the
283 /* If something didn't pick a format for us, pick the top-most format since
284 * we assume this is sorted in priority order */
285 if (!data->format && data->nego_formats && !pa_idxset_isempty(data->nego_formats))
286 data->format = pa_format_info_copy(pa_idxset_first(data->nego_formats, NULL));
288 pa_return_val_if_fail(data->format, -PA_ERR_NOTSUPPORTED);
290 /* Now populate the sample spec and format according to the final
291 * format that we've negotiated */
292 if (PA_LIKELY(data->format->encoding == PA_ENCODING_PCM)) {
293 pa_return_val_if_fail(pa_format_info_to_sample_spec(data->format, &ss, &map), -PA_ERR_INVALID);
294 pa_sink_input_new_data_set_sample_spec(data, &ss);
295 if (pa_channel_map_valid(&map))
296 pa_sink_input_new_data_set_channel_map(data, &map);
298 pa_return_val_if_fail(pa_format_info_to_sample_spec_fake(data->format, &ss), -PA_ERR_INVALID);
299 pa_sink_input_new_data_set_sample_spec(data, &ss);
302 pa_return_val_if_fail(PA_SINK_IS_LINKED(pa_sink_get_state(data->sink)), -PA_ERR_BADSTATE);
303 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);
305 r = check_passthrough_connection(pa_sink_input_new_data_is_passthrough(data), data->sink);
309 if (!data->sample_spec_is_set)
310 data->sample_spec = data->sink->sample_spec;
312 pa_return_val_if_fail(pa_sample_spec_valid(&data->sample_spec), -PA_ERR_INVALID);
314 if (!data->channel_map_is_set) {
315 if (pa_channel_map_compatible(&data->sink->channel_map, &data->sample_spec))
316 data->channel_map = data->sink->channel_map;
318 pa_channel_map_init_extend(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
321 pa_return_val_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec), -PA_ERR_INVALID);
323 /* Don't restore (or save) stream volume for passthrough streams */
324 if (pa_sink_input_new_data_is_passthrough(data)) {
325 data->volume_is_set = FALSE;
326 data->volume_factor_is_set = FALSE;
329 if (!data->volume_is_set) {
330 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
331 data->volume_is_absolute = FALSE;
332 data->save_volume = FALSE;
335 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec), -PA_ERR_INVALID);
337 if (!data->volume_factor_is_set)
338 pa_cvolume_reset(&data->volume_factor, data->sample_spec.channels);
340 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume_factor, &data->sample_spec), -PA_ERR_INVALID);
342 if (!data->volume_factor_sink_is_set)
343 pa_cvolume_reset(&data->volume_factor_sink, data->sink->sample_spec.channels);
345 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume_factor_sink, &data->sink->sample_spec), -PA_ERR_INVALID);
347 if (!data->muted_is_set)
350 if (data->flags & PA_SINK_INPUT_FIX_FORMAT)
351 data->sample_spec.format = data->sink->sample_spec.format;
353 if (data->flags & PA_SINK_INPUT_FIX_RATE)
354 data->sample_spec.rate = data->sink->sample_spec.rate;
356 original_cm = data->channel_map;
358 if (data->flags & PA_SINK_INPUT_FIX_CHANNELS) {
359 data->sample_spec.channels = data->sink->sample_spec.channels;
360 data->channel_map = data->sink->channel_map;
363 pa_assert(pa_sample_spec_valid(&data->sample_spec));
364 pa_assert(pa_channel_map_valid(&data->channel_map));
366 /* Due to the fixing of the sample spec the volume might not match anymore */
367 pa_cvolume_remap(&data->volume, &original_cm, &data->channel_map);
369 if (data->resample_method == PA_RESAMPLER_INVALID)
370 data->resample_method = core->resample_method;
372 pa_return_val_if_fail(data->resample_method < PA_RESAMPLER_MAX, -PA_ERR_INVALID);
374 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], data)) < 0)
377 if ((data->flags & PA_SINK_INPUT_NO_CREATE_ON_SUSPEND) &&
378 pa_sink_get_state(data->sink) == PA_SINK_SUSPENDED) {
379 pa_log_warn("Failed to create sink input: sink is suspended.");
380 return -PA_ERR_BADSTATE;
383 if (pa_idxset_size(data->sink->inputs) >= PA_MAX_INPUTS_PER_SINK) {
384 pa_log_warn("Failed to create sink input: too many inputs per sink.");
385 return -PA_ERR_TOOLARGE;
388 if ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
389 !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec) ||
390 !pa_channel_map_equal(&data->channel_map, &data->sink->channel_map)) {
392 /* Note: for passthrough content we need to adjust the output rate to that of the current sink-input */
393 if (!pa_sink_input_new_data_is_passthrough(data)) /* no resampler for passthrough content */
394 if (!(resampler = pa_resampler_new(
396 &data->sample_spec, &data->channel_map,
397 &data->sink->sample_spec, &data->sink->channel_map,
398 data->resample_method,
399 ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
400 ((data->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
401 (core->disable_remixing || (data->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0) |
402 (core->disable_lfe_remixing ? PA_RESAMPLER_NO_LFE : 0)))) {
403 pa_log_warn("Unsupported resampling operation.");
404 return -PA_ERR_NOTSUPPORTED;
408 i = pa_msgobject_new(pa_sink_input);
409 i->parent.parent.free = sink_input_free;
410 i->parent.process_msg = pa_sink_input_process_msg;
413 i->state = PA_SINK_INPUT_INIT;
414 i->flags = data->flags;
415 i->proplist = pa_proplist_copy(data->proplist);
416 i->driver = pa_xstrdup(pa_path_get_filename(data->driver));
417 i->module = data->module;
418 i->sink = data->sink;
419 i->origin_sink = data->origin_sink;
420 i->client = data->client;
422 i->requested_resample_method = data->resample_method;
423 i->actual_resample_method = resampler ? pa_resampler_get_method(resampler) : PA_RESAMPLER_INVALID;
424 i->sample_spec = data->sample_spec;
425 i->channel_map = data->channel_map;
426 i->format = pa_format_info_copy(data->format);
428 if (!data->volume_is_absolute && pa_sink_flat_volume_enabled(i->sink)) {
431 /* When the 'absolute' bool is not set then we'll treat the volume
432 * as relative to the sink volume even in flat volume mode */
433 remapped = data->sink->reference_volume;
434 pa_cvolume_remap(&remapped, &data->sink->channel_map, &data->channel_map);
435 pa_sw_cvolume_multiply(&i->volume, &data->volume, &remapped);
437 i->volume = data->volume;
439 i->volume_factor = data->volume_factor;
440 i->volume_factor_sink = data->volume_factor_sink;
441 i->real_ratio = i->reference_ratio = data->volume;
442 pa_cvolume_reset(&i->soft_volume, i->sample_spec.channels);
443 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
444 i->volume_writable = data->volume_writable;
445 i->save_volume = data->save_volume;
446 i->save_sink = data->save_sink;
447 i->save_muted = data->save_muted;
449 i->muted = data->muted;
451 if (data->sync_base) {
452 i->sync_next = data->sync_base->sync_next;
453 i->sync_prev = data->sync_base;
455 if (data->sync_base->sync_next)
456 data->sync_base->sync_next->sync_prev = i;
457 data->sync_base->sync_next = i;
459 i->sync_next = i->sync_prev = NULL;
461 i->direct_outputs = pa_idxset_new(NULL, NULL);
466 i->thread_info.state = i->state;
467 i->thread_info.attached = FALSE;
468 pa_atomic_store(&i->thread_info.drained, 1);
469 i->thread_info.sample_spec = i->sample_spec;
470 i->thread_info.resampler = resampler;
471 i->thread_info.soft_volume = i->soft_volume;
472 i->thread_info.muted = i->muted;
473 i->thread_info.requested_sink_latency = (pa_usec_t) -1;
474 i->thread_info.rewrite_nbytes = 0;
475 i->thread_info.rewrite_flush = FALSE;
476 i->thread_info.dont_rewind_render = FALSE;
477 i->thread_info.underrun_for = (uint64_t) -1;
478 i->thread_info.playing_for = 0;
479 i->thread_info.direct_outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
481 i->thread_info.render_memblockq = pa_memblockq_new(
485 pa_frame_size(&i->sink->sample_spec),
491 pa_assert_se(pa_idxset_put(core->sink_inputs, i, &i->index) == 0);
492 pa_assert_se(pa_idxset_put(i->sink->inputs, pa_sink_input_ref(i), NULL) == 0);
495 pa_assert_se(pa_idxset_put(i->client->sink_inputs, i, NULL) >= 0);
497 pt = pa_proplist_to_string_sep(i->proplist, "\n ");
498 pa_log_info("Created input %u \"%s\" on %s with sample spec %s and channel map %s\n %s",
500 pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)),
502 pa_sample_spec_snprint(st, sizeof(st), &i->sample_spec),
503 pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
507 /* Don't forget to call pa_sink_input_put! */
513 /* Called from main context */
514 static void update_n_corked(pa_sink_input *i, pa_sink_input_state_t state) {
516 pa_assert_ctl_context();
521 if (i->state == PA_SINK_INPUT_CORKED && state != PA_SINK_INPUT_CORKED)
522 pa_assert_se(i->sink->n_corked -- >= 1);
523 else if (i->state != PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_CORKED)
527 /* Called from main context */
528 static void sink_input_set_state(pa_sink_input *i, pa_sink_input_state_t state) {
529 pa_sink_input *ssync;
531 pa_assert_ctl_context();
533 if (state == PA_SINK_INPUT_DRAINED)
534 state = PA_SINK_INPUT_RUNNING;
536 if (i->state == state)
539 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);
541 update_n_corked(i, state);
544 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev) {
545 update_n_corked(ssync, state);
546 ssync->state = state;
548 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next) {
549 update_n_corked(ssync, state);
550 ssync->state = state;
553 if (state != PA_SINK_INPUT_UNLINKED) {
554 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], i);
556 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev)
557 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
559 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next)
560 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
562 if (PA_SINK_INPUT_IS_LINKED(state))
563 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
566 pa_sink_update_status(i->sink);
569 /* Called from main context */
570 void pa_sink_input_unlink(pa_sink_input *i) {
572 pa_source_output *o, *p = NULL;
575 pa_assert_ctl_context();
577 /* See pa_sink_unlink() for a couple of comments how this function
580 pa_sink_input_ref(i);
582 linked = PA_SINK_INPUT_IS_LINKED(i->state);
585 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], i);
588 i->sync_prev->sync_next = i->sync_next;
590 i->sync_next->sync_prev = i->sync_prev;
592 i->sync_prev = i->sync_next = NULL;
594 pa_idxset_remove_by_data(i->core->sink_inputs, i, NULL);
597 if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL))
598 pa_sink_input_unref(i);
601 pa_idxset_remove_by_data(i->client->sink_inputs, i, NULL);
603 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
605 pa_source_output_kill(o);
609 update_n_corked(i, PA_SINK_INPUT_UNLINKED);
610 i->state = PA_SINK_INPUT_UNLINKED;
612 if (linked && i->sink) {
613 /* We might need to update the sink's volume if we are in flat volume mode. */
614 if (pa_sink_flat_volume_enabled(i->sink))
615 pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
617 if (i->sink->asyncmsgq)
618 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_REMOVE_INPUT, i, 0, NULL) == 0);
620 /* We suspend the monitor if there was a passthrough sink, unsuspend now if required */
621 if (pa_sink_input_is_passthrough(i) && i->sink->monitor_source)
622 pa_source_suspend(i->sink->monitor_source, FALSE, PA_SUSPEND_PASSTHROUGH);
628 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_REMOVE, i->index);
629 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST], i);
633 pa_sink_update_status(i->sink);
637 pa_core_maybe_vacuum(i->core);
639 pa_sink_input_unref(i);
642 /* Called from main context */
643 static void sink_input_free(pa_object *o) {
644 pa_sink_input* i = PA_SINK_INPUT(o);
647 pa_assert_ctl_context();
648 pa_assert(pa_sink_input_refcnt(i) == 0);
650 if (PA_SINK_INPUT_IS_LINKED(i->state))
651 pa_sink_input_unlink(i);
653 pa_log_info("Freeing input %u \"%s\"", i->index, pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)));
655 /* Side note: this function must be able to destruct properly any
656 * kind of sink input in any state, even those which are
657 * "half-moved" or are connected to sinks that have no asyncmsgq
658 * and are hence half-destructed themselves! */
660 if (i->thread_info.render_memblockq)
661 pa_memblockq_free(i->thread_info.render_memblockq);
663 if (i->thread_info.resampler)
664 pa_resampler_free(i->thread_info.resampler);
667 pa_format_info_free(i->format);
670 pa_proplist_free(i->proplist);
672 if (i->direct_outputs)
673 pa_idxset_free(i->direct_outputs, NULL, NULL);
675 if (i->thread_info.direct_outputs)
676 pa_hashmap_free(i->thread_info.direct_outputs, NULL, NULL);
682 /* Called from main context */
683 void pa_sink_input_put(pa_sink_input *i) {
684 pa_sink_input_state_t state;
686 pa_sink_input_assert_ref(i);
687 pa_assert_ctl_context();
689 pa_assert(i->state == PA_SINK_INPUT_INIT);
691 /* The following fields must be initialized properly */
693 pa_assert(i->process_rewind);
696 state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING;
698 update_n_corked(i, state);
701 /* We might need to update the sink's volume if we are in flat volume mode. */
702 if (pa_sink_flat_volume_enabled(i->sink))
703 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
705 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
706 pa_assert(pa_cvolume_is_norm(&i->volume));
707 pa_assert(pa_cvolume_is_norm(&i->reference_ratio));
710 set_real_ratio(i, &i->volume);
713 /* If we're entering passthrough mode, disable the monitor */
714 if (pa_sink_input_is_passthrough(i) && i->sink->monitor_source)
715 pa_source_suspend(i->sink->monitor_source, TRUE, PA_SUSPEND_PASSTHROUGH);
717 i->thread_info.soft_volume = i->soft_volume;
718 i->thread_info.muted = i->muted;
720 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_ADD_INPUT, i, 0, NULL) == 0);
722 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, i->index);
723 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], i);
725 pa_sink_update_status(i->sink);
728 /* Called from main context */
729 void pa_sink_input_kill(pa_sink_input*i) {
730 pa_sink_input_assert_ref(i);
731 pa_assert_ctl_context();
732 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
737 /* Called from main context */
738 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency) {
739 pa_usec_t r[2] = { 0, 0 };
741 pa_sink_input_assert_ref(i);
742 pa_assert_ctl_context();
743 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
745 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_LATENCY, r, 0, NULL) == 0);
748 r[0] += i->get_latency(i);
751 *sink_latency = r[1];
756 /* Called from thread context */
757 void pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink frames */, pa_memchunk *chunk, pa_cvolume *volume) {
758 pa_bool_t do_volume_adj_here, need_volume_factor_sink;
759 pa_bool_t volume_is_norm;
760 size_t block_size_max_sink, block_size_max_sink_input;
763 pa_sink_input_assert_ref(i);
764 pa_sink_input_assert_io_context(i);
765 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
766 pa_assert(pa_frame_aligned(slength, &i->sink->sample_spec));
770 /* pa_log_debug("peek"); */
772 block_size_max_sink_input = i->thread_info.resampler ?
773 pa_resampler_max_block_size(i->thread_info.resampler) :
774 pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sample_spec);
776 block_size_max_sink = pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sink->sample_spec);
778 /* Default buffer size */
780 slength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sink->sample_spec);
782 if (slength > block_size_max_sink)
783 slength = block_size_max_sink;
785 if (i->thread_info.resampler) {
786 ilength = pa_resampler_request(i->thread_info.resampler, slength);
789 ilength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sample_spec);
793 if (ilength > block_size_max_sink_input)
794 ilength = block_size_max_sink_input;
796 /* If the channel maps of the sink and this stream differ, we need
797 * to adjust the volume *before* we resample. Otherwise we can do
798 * it after and leave it for the sink code */
800 do_volume_adj_here = !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map);
801 volume_is_norm = pa_cvolume_is_norm(&i->thread_info.soft_volume) && !i->thread_info.muted;
802 need_volume_factor_sink = !pa_cvolume_is_norm(&i->volume_factor_sink);
804 while (!pa_memblockq_is_readable(i->thread_info.render_memblockq)) {
807 /* There's nothing in our render queue. We need to fill it up
808 * with data from the implementor. */
810 if (i->thread_info.state == PA_SINK_INPUT_CORKED ||
811 i->pop(i, ilength, &tchunk) < 0) {
813 /* OK, we're corked or the implementor didn't give us any
814 * data, so let's just hand out silence */
815 pa_atomic_store(&i->thread_info.drained, 1);
817 pa_memblockq_seek(i->thread_info.render_memblockq, (int64_t) slength, PA_SEEK_RELATIVE, TRUE);
818 i->thread_info.playing_for = 0;
819 if (i->thread_info.underrun_for != (uint64_t) -1)
820 i->thread_info.underrun_for += ilength;
824 pa_atomic_store(&i->thread_info.drained, 0);
826 pa_assert(tchunk.length > 0);
827 pa_assert(tchunk.memblock);
829 i->thread_info.underrun_for = 0;
830 i->thread_info.playing_for += tchunk.length;
832 while (tchunk.length > 0) {
834 pa_bool_t nvfs = need_volume_factor_sink;
837 pa_memblock_ref(wchunk.memblock);
839 if (wchunk.length > block_size_max_sink_input)
840 wchunk.length = block_size_max_sink_input;
842 /* It might be necessary to adjust the volume here */
843 if (do_volume_adj_here && !volume_is_norm) {
844 pa_memchunk_make_writable(&wchunk, 0);
846 if (i->thread_info.muted) {
847 pa_silence_memchunk(&wchunk, &i->thread_info.sample_spec);
850 } else if (!i->thread_info.resampler && nvfs) {
853 /* If we don't need a resampler we can merge the
854 * post and the pre volume adjustment into one */
856 pa_sw_cvolume_multiply(&v, &i->thread_info.soft_volume, &i->volume_factor_sink);
857 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &v);
861 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.soft_volume);
864 if (!i->thread_info.resampler) {
867 pa_memchunk_make_writable(&wchunk, 0);
868 pa_volume_memchunk(&wchunk, &i->sink->sample_spec, &i->volume_factor_sink);
871 pa_memblockq_push_align(i->thread_info.render_memblockq, &wchunk);
874 pa_resampler_run(i->thread_info.resampler, &wchunk, &rchunk);
876 /* pa_log_debug("pushing %lu", (unsigned long) rchunk.length); */
878 if (rchunk.memblock) {
881 pa_memchunk_make_writable(&rchunk, 0);
882 pa_volume_memchunk(&rchunk, &i->sink->sample_spec, &i->volume_factor_sink);
885 pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk);
886 pa_memblock_unref(rchunk.memblock);
890 pa_memblock_unref(wchunk.memblock);
892 tchunk.index += wchunk.length;
893 tchunk.length -= wchunk.length;
896 pa_memblock_unref(tchunk.memblock);
899 pa_assert_se(pa_memblockq_peek(i->thread_info.render_memblockq, chunk) >= 0);
901 pa_assert(chunk->length > 0);
902 pa_assert(chunk->memblock);
904 /* pa_log_debug("peeking %lu", (unsigned long) chunk->length); */
906 if (chunk->length > block_size_max_sink)
907 chunk->length = block_size_max_sink;
909 /* Let's see if we had to apply the volume adjustment ourselves,
910 * or if this can be done by the sink for us */
912 if (do_volume_adj_here)
913 /* We had different channel maps, so we already did the adjustment */
914 pa_cvolume_reset(volume, i->sink->sample_spec.channels);
915 else if (i->thread_info.muted)
916 /* We've both the same channel map, so let's have the sink do the adjustment for us*/
917 pa_cvolume_mute(volume, i->sink->sample_spec.channels);
919 *volume = i->thread_info.soft_volume;
922 /* Called from thread context */
923 void pa_sink_input_drop(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
925 pa_sink_input_assert_ref(i);
926 pa_sink_input_assert_io_context(i);
927 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
928 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
929 pa_assert(nbytes > 0);
931 /* pa_log_debug("dropping %lu", (unsigned long) nbytes); */
933 pa_memblockq_drop(i->thread_info.render_memblockq, nbytes);
936 /* Called from thread context */
937 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
939 pa_bool_t called = FALSE;
941 pa_sink_input_assert_ref(i);
942 pa_sink_input_assert_io_context(i);
943 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
944 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
946 /* pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes); */
948 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
950 if (nbytes > 0 && !i->thread_info.dont_rewind_render) {
951 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes);
952 pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes);
955 if (i->thread_info.rewrite_nbytes == (size_t) -1) {
957 /* We were asked to drop all buffered data, and rerequest new
958 * data from implementor the next time push() is called */
960 pa_memblockq_flush_write(i->thread_info.render_memblockq, TRUE);
962 } else if (i->thread_info.rewrite_nbytes > 0) {
963 size_t max_rewrite, amount;
965 /* Calculate how much make sense to rewrite at most */
966 max_rewrite = nbytes + lbq;
968 /* Transform into local domain */
969 if (i->thread_info.resampler)
970 max_rewrite = pa_resampler_request(i->thread_info.resampler, max_rewrite);
972 /* Calculate how much of the rewinded data should actually be rewritten */
973 amount = PA_MIN(i->thread_info.rewrite_nbytes, max_rewrite);
976 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount);
978 /* Tell the implementor */
979 if (i->process_rewind)
980 i->process_rewind(i, amount);
983 /* Convert back to to sink domain */
984 if (i->thread_info.resampler)
985 amount = pa_resampler_result(i->thread_info.resampler, amount);
988 /* Ok, now update the write pointer */
989 pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) amount), PA_SEEK_RELATIVE, TRUE);
991 if (i->thread_info.rewrite_flush)
992 pa_memblockq_silence(i->thread_info.render_memblockq);
994 /* And reset the resampler */
995 if (i->thread_info.resampler)
996 pa_resampler_reset(i->thread_info.resampler);
1001 if (i->process_rewind)
1002 i->process_rewind(i, 0);
1004 i->thread_info.rewrite_nbytes = 0;
1005 i->thread_info.rewrite_flush = FALSE;
1006 i->thread_info.dont_rewind_render = FALSE;
1009 /* Called from thread context */
1010 size_t pa_sink_input_get_max_rewind(pa_sink_input *i) {
1011 pa_sink_input_assert_ref(i);
1012 pa_sink_input_assert_io_context(i);
1014 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_rewind) : i->sink->thread_info.max_rewind;
1017 /* Called from thread context */
1018 size_t pa_sink_input_get_max_request(pa_sink_input *i) {
1019 pa_sink_input_assert_ref(i);
1020 pa_sink_input_assert_io_context(i);
1022 /* We're not verifying the status here, to allow this to be called
1023 * in the state change handler between _INIT and _RUNNING */
1025 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_request) : i->sink->thread_info.max_request;
1028 /* Called from thread context */
1029 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1030 pa_sink_input_assert_ref(i);
1031 pa_sink_input_assert_io_context(i);
1032 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1033 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1035 pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes);
1037 if (i->update_max_rewind)
1038 i->update_max_rewind(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1041 /* Called from thread context */
1042 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1043 pa_sink_input_assert_ref(i);
1044 pa_sink_input_assert_io_context(i);
1045 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1046 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1048 if (i->update_max_request)
1049 i->update_max_request(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1052 /* Called from thread context */
1053 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) {
1054 pa_sink_input_assert_ref(i);
1055 pa_sink_input_assert_io_context(i);
1057 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1058 usec = i->sink->thread_info.fixed_latency;
1060 if (usec != (pa_usec_t) -1)
1061 usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
1063 i->thread_info.requested_sink_latency = usec;
1064 pa_sink_invalidate_requested_latency(i->sink, TRUE);
1069 /* Called from main context */
1070 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) {
1071 pa_sink_input_assert_ref(i);
1072 pa_assert_ctl_context();
1074 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1075 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1079 /* If this sink input is not realized yet or we are being moved,
1080 * we have to touch the thread info data directly */
1083 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1084 usec = pa_sink_get_fixed_latency(i->sink);
1086 if (usec != (pa_usec_t) -1) {
1087 pa_usec_t min_latency, max_latency;
1088 pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
1089 usec = PA_CLAMP(usec, min_latency, max_latency);
1093 i->thread_info.requested_sink_latency = usec;
1098 /* Called from main context */
1099 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
1100 pa_sink_input_assert_ref(i);
1101 pa_assert_ctl_context();
1103 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1105 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1109 /* If this sink input is not realized yet or we are being moved,
1110 * we have to touch the thread info data directly */
1112 return i->thread_info.requested_sink_latency;
1115 /* Called from main context */
1116 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, pa_bool_t save, pa_bool_t absolute) {
1119 pa_sink_input_assert_ref(i);
1120 pa_assert_ctl_context();
1121 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1123 pa_assert(pa_cvolume_valid(volume));
1124 pa_assert(volume->channels == 1 || pa_cvolume_compatible(volume, &i->sample_spec));
1125 pa_assert(i->volume_writable);
1127 if (!absolute && pa_sink_flat_volume_enabled(i->sink)) {
1128 v = i->sink->reference_volume;
1129 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
1131 if (pa_cvolume_compatible(volume, &i->sample_spec))
1132 volume = pa_sw_cvolume_multiply(&v, &v, volume);
1134 volume = pa_sw_cvolume_multiply_scalar(&v, &v, pa_cvolume_max(volume));
1136 if (!pa_cvolume_compatible(volume, &i->sample_spec)) {
1138 volume = pa_cvolume_scale(&v, pa_cvolume_max(volume));
1142 if (pa_cvolume_equal(volume, &i->volume)) {
1143 i->save_volume = i->save_volume || save;
1147 i->volume = *volume;
1148 i->save_volume = save;
1150 if (pa_sink_flat_volume_enabled(i->sink)) {
1151 /* We are in flat volume mode, so let's update all sink input
1152 * volumes and update the flat volume of the sink */
1154 pa_sink_set_volume(i->sink, NULL, TRUE, save);
1157 /* OK, we are in normal volume mode. The volume only affects
1159 set_real_ratio(i, volume);
1161 /* Copy the new soft_volume to the thread_info struct */
1162 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1165 /* The volume changed, let's tell people so */
1166 if (i->volume_changed)
1167 i->volume_changed(i);
1169 /* The virtual volume changed, let's tell people so */
1170 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1173 /* Called from main context */
1174 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
1175 pa_sink_input_assert_ref(i);
1176 pa_assert_ctl_context();
1177 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1178 pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
1180 /* This basically calculates:
1182 * i->real_ratio := v
1183 * i->soft_volume := i->real_ratio * i->volume_factor */
1188 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
1190 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1191 /* We don't copy the data to the thread_info data. That's left for someone else to do */
1194 /* Called from main or I/O context */
1195 pa_bool_t pa_sink_input_is_passthrough(pa_sink_input *i) {
1196 pa_sink_input_assert_ref(i);
1198 if (PA_UNLIKELY(!pa_format_info_is_pcm(i->format)))
1201 if (PA_UNLIKELY(i->flags & PA_SINK_INPUT_PASSTHROUGH))
1207 /* Called from main context */
1208 pa_bool_t pa_sink_input_is_volume_readable(pa_sink_input *i) {
1209 pa_sink_input_assert_ref(i);
1210 pa_assert_ctl_context();
1212 return !pa_sink_input_is_passthrough(i);
1215 /* Called from main context */
1216 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, pa_bool_t absolute) {
1217 pa_sink_input_assert_ref(i);
1218 pa_assert_ctl_context();
1219 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1220 pa_assert(pa_sink_input_is_volume_readable(i));
1222 if (absolute || !pa_sink_flat_volume_enabled(i->sink))
1223 *volume = i->volume;
1225 *volume = i->reference_ratio;
1230 /* Called from main context */
1231 void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute, pa_bool_t save) {
1232 pa_sink_input_assert_ref(i);
1233 pa_assert_ctl_context();
1234 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1236 if (!i->muted == !mute) {
1237 i->save_muted = i->save_muted || mute;
1242 i->save_muted = save;
1244 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1246 /* The mute status changed, let's tell people so */
1247 if (i->mute_changed)
1250 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1253 /* Called from main context */
1254 pa_bool_t pa_sink_input_get_mute(pa_sink_input *i) {
1255 pa_sink_input_assert_ref(i);
1256 pa_assert_ctl_context();
1257 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1262 /* Called from main thread */
1263 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1264 pa_sink_input_assert_ref(i);
1265 pa_assert_ctl_context();
1268 pa_proplist_update(i->proplist, mode, p);
1270 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1271 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1272 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1276 /* Called from main context */
1277 void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b) {
1278 pa_sink_input_assert_ref(i);
1279 pa_assert_ctl_context();
1280 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1282 sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1285 /* Called from main context */
1286 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1287 pa_sink_input_assert_ref(i);
1288 pa_assert_ctl_context();
1289 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1290 pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1292 if (i->sample_spec.rate == rate)
1295 i->sample_spec.rate = rate;
1297 pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1299 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1303 /* Called from main context */
1304 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1306 pa_sink_input_assert_ref(i);
1307 pa_assert_ctl_context();
1309 if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1312 old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1314 if (old && name && pa_streq(old, name))
1318 pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1320 pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1322 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1323 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1324 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1328 /* Called from main context */
1329 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1330 pa_sink_input_assert_ref(i);
1331 pa_assert_ctl_context();
1333 return i->actual_resample_method;
1336 /* Called from main context */
1337 pa_bool_t pa_sink_input_may_move(pa_sink_input *i) {
1338 pa_sink_input_assert_ref(i);
1339 pa_assert_ctl_context();
1340 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1342 if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1345 if (i->sync_next || i->sync_prev) {
1346 pa_log_warn("Moving synchronized streams not supported.");
1353 /* Called from main context */
1354 pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1355 pa_sink_input_assert_ref(i);
1356 pa_assert_ctl_context();
1357 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1358 pa_sink_assert_ref(dest);
1360 if (dest == i->sink)
1363 if (!pa_sink_input_may_move(i))
1366 if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1367 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1371 if (check_passthrough_connection(pa_sink_input_is_passthrough(i), dest) < 0)
1375 if (!i->may_move_to(i, dest))
1381 /* Called from main context */
1382 int pa_sink_input_start_move(pa_sink_input *i) {
1383 pa_source_output *o, *p = NULL;
1386 pa_sink_input_assert_ref(i);
1387 pa_assert_ctl_context();
1388 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1391 if (!pa_sink_input_may_move(i))
1392 return -PA_ERR_NOTSUPPORTED;
1394 if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1397 /* Kill directly connected outputs */
1398 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1400 pa_source_output_kill(o);
1403 pa_assert(pa_idxset_isempty(i->direct_outputs));
1405 pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1407 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1408 pa_assert_se(i->sink->n_corked-- >= 1);
1410 if (pa_sink_flat_volume_enabled(i->sink))
1411 /* We might need to update the sink's volume if we are in flat
1413 pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
1415 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1417 /* We suspend the monitor if there was a passthrough sink, unsuspend now if required */
1418 if (pa_sink_input_is_passthrough(i) && i->sink->monitor_source)
1419 pa_source_suspend(i->sink->monitor_source, FALSE, PA_SUSPEND_PASSTHROUGH);
1421 pa_sink_update_status(i->sink);
1422 pa_cvolume_remap(&i->volume_factor_sink, &i->sink->channel_map, &i->channel_map);
1425 pa_sink_input_unref(i);
1430 /* Called from main context. If i has an origin sink that uses volume sharing,
1431 * then also the origin sink and all streams connected to it need to update
1432 * their volume - this function does all that by using recursion. */
1433 static void update_volume_due_to_moving(pa_sink_input *i, pa_sink *dest) {
1434 pa_cvolume old_volume;
1438 pa_assert(i->sink); /* The destination sink should already be set. */
1440 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1441 pa_sink *root_sink = i->sink;
1442 pa_sink_input *origin_sink_input;
1445 while (root_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)
1446 root_sink = root_sink->input_to_master->sink;
1448 if (pa_sink_flat_volume_enabled(i->sink)) {
1449 /* Ok, so the origin sink uses volume sharing, and flat volume is
1450 * enabled. The volume will have to be updated as follows:
1452 * i->volume := i->sink->real_volume
1453 * (handled later by pa_sink_set_volume)
1454 * i->reference_ratio := i->volume / i->sink->reference_volume
1455 * (handled later by pa_sink_set_volume)
1456 * i->real_ratio stays unchanged
1457 * (streams whose origin sink uses volume sharing should
1458 * always have real_ratio of 0 dB)
1459 * i->soft_volume stays unchanged
1460 * (streams whose origin sink uses volume sharing should
1461 * always have volume_factor as soft_volume, so no change
1462 * should be needed) */
1464 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1465 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1467 /* Notifications will be sent by pa_sink_set_volume(). */
1470 /* Ok, so the origin sink uses volume sharing, and flat volume is
1471 * disabled. The volume will have to be updated as follows:
1474 * i->reference_ratio := 0 dB
1475 * i->real_ratio stays unchanged
1476 * (streams whose origin sink uses volume sharing should
1477 * always have real_ratio of 0 dB)
1478 * i->soft_volume stays unchanged
1479 * (streams whose origin sink uses volume sharing should
1480 * always have volume_factor as soft_volume, so no change
1481 * should be needed) */
1483 old_volume = i->volume;
1484 pa_cvolume_reset(&i->volume, i->volume.channels);
1485 pa_cvolume_reset(&i->reference_ratio, i->reference_ratio.channels);
1486 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1487 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1489 /* Notify others about the changed sink input volume. */
1490 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1491 if (i->volume_changed)
1492 i->volume_changed(i);
1494 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1498 /* Additionally, the origin sink volume needs updating:
1500 * i->origin_sink->reference_volume := root_sink->reference_volume
1501 * i->origin_sink->real_volume := root_sink->real_volume
1502 * i->origin_sink->soft_volume stays unchanged
1503 * (sinks that use volume sharing should always have
1504 * soft_volume of 0 dB) */
1506 old_volume = i->origin_sink->reference_volume;
1508 i->origin_sink->reference_volume = root_sink->reference_volume;
1509 pa_cvolume_remap(&i->origin_sink->reference_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1511 i->origin_sink->real_volume = root_sink->real_volume;
1512 pa_cvolume_remap(&i->origin_sink->real_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1514 pa_assert(pa_cvolume_is_norm(&i->origin_sink->soft_volume));
1516 /* Notify others about the changed sink volume. If you wonder whether
1517 * i->origin_sink->set_volume() should be called somewhere, that's not
1518 * the case, because sinks that use volume sharing shouldn't have any
1519 * internal volume that set_volume() would update. If you wonder
1520 * whether the thread_info variables should be synced, yes, they
1521 * should, and it's done by the PA_SINK_MESSAGE_FINISH_MOVE message
1523 if (!pa_cvolume_equal(&i->origin_sink->reference_volume, &old_volume))
1524 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, i->origin_sink->index);
1526 /* Recursively update origin sink inputs. */
1527 PA_IDXSET_FOREACH(origin_sink_input, i->origin_sink->inputs, idx)
1528 update_volume_due_to_moving(origin_sink_input, dest);
1531 old_volume = i->volume;
1533 if (pa_sink_flat_volume_enabled(i->sink)) {
1534 /* Ok, so this is a regular stream, and flat volume is enabled. The
1535 * volume will have to be updated as follows:
1537 * i->volume := i->reference_ratio * i->sink->reference_volume
1538 * i->reference_ratio stays unchanged
1539 * i->real_ratio := i->volume / i->sink->real_volume
1540 * (handled later by pa_sink_set_volume)
1541 * i->soft_volume := i->real_ratio * i->volume_factor
1542 * (handled later by pa_sink_set_volume) */
1544 i->volume = i->sink->reference_volume;
1545 pa_cvolume_remap(&i->volume, &i->sink->channel_map, &i->channel_map);
1546 pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1549 /* Ok, so this is a regular stream, and flat volume is disabled.
1550 * The volume will have to be updated as follows:
1552 * i->volume := i->reference_ratio
1553 * i->reference_ratio stays unchanged
1554 * i->real_ratio := i->reference_ratio
1555 * i->soft_volume := i->real_ratio * i->volume_factor */
1557 i->volume = i->reference_ratio;
1558 i->real_ratio = i->reference_ratio;
1559 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1562 /* Notify others about the changed sink input volume. */
1563 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1564 /* XXX: In case i->sink has flat volume enabled, then real_ratio
1565 * and soft_volume are not updated yet. Let's hope that the
1566 * callback implementation doesn't care about those variables... */
1567 if (i->volume_changed)
1568 i->volume_changed(i);
1570 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1574 /* If i->sink == dest, then recursion has finished, and we can finally call
1575 * pa_sink_set_volume(), which will do the rest of the updates. */
1576 if ((i->sink == dest) && pa_sink_flat_volume_enabled(i->sink))
1577 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
1580 /* Called from main context */
1581 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1582 pa_resampler *new_resampler;
1584 pa_sink_input_assert_ref(i);
1585 pa_assert_ctl_context();
1586 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1587 pa_assert(!i->sink);
1588 pa_sink_assert_ref(dest);
1590 if (!pa_sink_input_may_move_to(i, dest))
1591 return -PA_ERR_NOTSUPPORTED;
1593 if (pa_sink_input_is_passthrough(i) && !pa_sink_check_format(dest, i->format)) {
1594 pa_proplist *p = pa_proplist_new();
1595 pa_log_debug("New sink doesn't support stream format, sending format-changed and killing");
1596 /* Tell the client what device we want to be on if it is going to
1598 pa_proplist_sets(p, "device", dest->name);
1599 pa_sink_input_send_event(i, PA_STREAM_EVENT_FORMAT_LOST, p);
1600 pa_proplist_free(p);
1601 return -PA_ERR_NOTSUPPORTED;
1604 if (i->thread_info.resampler &&
1605 pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &dest->sample_spec) &&
1606 pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &dest->channel_map))
1608 /* Try to reuse the old resampler if possible */
1609 new_resampler = i->thread_info.resampler;
1611 else if ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
1612 !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec) ||
1613 !pa_channel_map_equal(&i->channel_map, &dest->channel_map)) {
1615 /* Okay, we need a new resampler for the new sink */
1617 if (!(new_resampler = pa_resampler_new(
1619 &i->sample_spec, &i->channel_map,
1620 &dest->sample_spec, &dest->channel_map,
1621 i->requested_resample_method,
1622 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
1623 ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
1624 (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0)))) {
1625 pa_log_warn("Unsupported resampling operation.");
1626 return -PA_ERR_NOTSUPPORTED;
1629 new_resampler = NULL;
1635 i->save_sink = save;
1636 pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1638 pa_cvolume_remap(&i->volume_factor_sink, &i->channel_map, &i->sink->channel_map);
1640 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1641 i->sink->n_corked++;
1643 /* Replace resampler and render queue */
1644 if (new_resampler != i->thread_info.resampler) {
1646 if (i->thread_info.resampler)
1647 pa_resampler_free(i->thread_info.resampler);
1648 i->thread_info.resampler = new_resampler;
1650 pa_memblockq_free(i->thread_info.render_memblockq);
1652 i->thread_info.render_memblockq = pa_memblockq_new(
1654 MEMBLOCKQ_MAXLENGTH,
1656 pa_frame_size(&i->sink->sample_spec),
1661 i->actual_resample_method = new_resampler ? pa_resampler_get_method(new_resampler) : PA_RESAMPLER_INVALID;
1664 pa_sink_update_status(dest);
1666 update_volume_due_to_moving(i, dest);
1668 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1670 /* If we're entering passthrough mode, disable the monitor */
1671 if (pa_sink_input_is_passthrough(i) && i->sink->monitor_source)
1672 pa_source_suspend(i->sink->monitor_source, TRUE, PA_SUSPEND_PASSTHROUGH);
1674 pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1676 /* Notify everyone */
1677 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1678 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1683 /* Called from main context */
1684 void pa_sink_input_fail_move(pa_sink_input *i) {
1686 pa_sink_input_assert_ref(i);
1687 pa_assert_ctl_context();
1688 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1689 pa_assert(!i->sink);
1691 /* Check if someone wants this sink input? */
1692 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1698 pa_sink_input_kill(i);
1701 /* Called from main context */
1702 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1705 pa_sink_input_assert_ref(i);
1706 pa_assert_ctl_context();
1707 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1709 pa_sink_assert_ref(dest);
1711 if (dest == i->sink)
1714 if (!pa_sink_input_may_move_to(i, dest))
1715 return -PA_ERR_NOTSUPPORTED;
1717 pa_sink_input_ref(i);
1719 if ((r = pa_sink_input_start_move(i)) < 0) {
1720 pa_sink_input_unref(i);
1724 if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1725 pa_sink_input_fail_move(i);
1726 pa_sink_input_unref(i);
1730 pa_sink_input_unref(i);
1735 /* Called from IO thread context */
1736 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1737 pa_bool_t corking, uncorking;
1739 pa_sink_input_assert_ref(i);
1740 pa_sink_input_assert_io_context(i);
1742 if (state == i->thread_info.state)
1745 if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1746 !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1747 pa_atomic_store(&i->thread_info.drained, 1);
1749 corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1750 uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1752 if (i->state_change)
1753 i->state_change(i, state);
1757 pa_log_debug("Requesting rewind due to corking");
1759 /* This will tell the implementing sink input driver to rewind
1760 * so that the unplayed already mixed data is not lost */
1761 pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1763 /* Set the corked state *after* requesting rewind */
1764 i->thread_info.state = state;
1766 } else if (uncorking) {
1768 pa_log_debug("Requesting rewind due to uncorking");
1770 i->thread_info.underrun_for = (uint64_t) -1;
1771 i->thread_info.playing_for = 0;
1773 /* Set the uncorked state *before* requesting rewind */
1774 i->thread_info.state = state;
1776 /* OK, we're being uncorked. Make sure we're not rewound when
1777 * the hw buffer is remixed and request a remix. */
1778 pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1780 /* We may not be corking or uncorking, but we still need to set the state. */
1781 i->thread_info.state = state;
1784 /* Called from thread context, except when it is not. */
1785 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1786 pa_sink_input *i = PA_SINK_INPUT(o);
1787 pa_sink_input_assert_ref(i);
1791 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1792 if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1793 i->thread_info.soft_volume = i->soft_volume;
1794 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1798 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1799 if (i->thread_info.muted != i->muted) {
1800 i->thread_info.muted = i->muted;
1801 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1805 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1806 pa_usec_t *r = userdata;
1808 r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1809 r[1] += pa_sink_get_latency_within_thread(i->sink);
1814 case PA_SINK_INPUT_MESSAGE_SET_RATE:
1816 i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1817 pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1821 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1822 pa_sink_input *ssync;
1824 pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
1826 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
1827 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1829 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
1830 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1835 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
1836 pa_usec_t *usec = userdata;
1838 *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
1842 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
1843 pa_usec_t *r = userdata;
1845 *r = i->thread_info.requested_sink_latency;
1850 return -PA_ERR_NOTIMPLEMENTED;
1853 /* Called from main thread */
1854 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
1855 pa_sink_input_assert_ref(i);
1856 pa_assert_ctl_context();
1858 if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
1859 return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
1864 /* Called from IO context */
1865 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
1866 pa_sink_input_assert_ref(i);
1867 pa_sink_input_assert_io_context(i);
1869 if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
1870 return pa_memblockq_is_empty(i->thread_info.render_memblockq);
1875 /* Called from IO context */
1876 void pa_sink_input_request_rewind(
1878 size_t nbytes /* in our sample spec */,
1881 pa_bool_t dont_rewind_render) {
1885 /* If 'rewrite' is TRUE the sink is rewound as far as requested
1886 * and possible and the exact value of this is passed back the
1887 * implementor via process_rewind(). If 'flush' is also TRUE all
1888 * already rendered data is also dropped.
1890 * If 'rewrite' is FALSE the sink is rewound as far as requested
1891 * and possible and the already rendered data is dropped so that
1892 * in the next iteration we read new data from the
1893 * implementor. This implies 'flush' is TRUE. If
1894 * dont_rewind_render is TRUE then the render memblockq is not
1897 /* nbytes = 0 means maximum rewind request */
1899 pa_sink_input_assert_ref(i);
1900 pa_sink_input_assert_io_context(i);
1901 pa_assert(rewrite || flush);
1902 pa_assert(!dont_rewind_render || !rewrite);
1904 /* We don't take rewind requests while we are corked */
1905 if (i->thread_info.state == PA_SINK_INPUT_CORKED)
1908 nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
1910 /* pa_log_debug("request rewrite %zu", nbytes); */
1912 /* Calculate how much we can rewind locally without having to
1915 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1919 /* Check if rewinding for the maximum is requested, and if so, fix up */
1922 /* Calculate maximum number of bytes that could be rewound in theory */
1923 nbytes = i->sink->thread_info.max_rewind + lbq;
1925 /* Transform from sink domain */
1926 if (i->thread_info.resampler)
1927 nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
1930 /* Remember how much we actually want to rewrite */
1931 if (i->thread_info.rewrite_nbytes != (size_t) -1) {
1933 /* Make sure to not overwrite over underruns */
1934 if (nbytes > i->thread_info.playing_for)
1935 nbytes = (size_t) i->thread_info.playing_for;
1937 i->thread_info.rewrite_nbytes = nbytes;
1939 i->thread_info.rewrite_nbytes = (size_t) -1;
1942 i->thread_info.rewrite_flush =
1943 i->thread_info.rewrite_flush ||
1944 (flush && i->thread_info.rewrite_nbytes != 0);
1946 i->thread_info.dont_rewind_render =
1947 i->thread_info.dont_rewind_render ||
1950 if (nbytes != (size_t) -1) {
1952 /* Transform to sink domain */
1953 if (i->thread_info.resampler)
1954 nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
1957 pa_sink_request_rewind(i->sink, nbytes - lbq);
1959 /* This call will make sure process_rewind() is called later */
1960 pa_sink_request_rewind(i->sink, 0);
1964 /* Called from main context */
1965 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
1966 pa_sink_input_assert_ref(i);
1967 pa_assert_ctl_context();
1970 /* FIXME: Shouldn't access resampler object from main context! */
1972 pa_silence_memchunk_get(
1973 &i->core->silence_cache,
1977 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
1982 /* Called from main context */
1983 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
1984 pa_proplist *pl = NULL;
1985 pa_sink_input_send_event_hook_data hook_data;
1987 pa_sink_input_assert_ref(i);
1988 pa_assert_ctl_context();
1995 data = pl = pa_proplist_new();
1997 hook_data.sink_input = i;
1998 hook_data.data = data;
1999 hook_data.event = event;
2001 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
2004 i->send_event(i, event, data);
2008 pa_proplist_free(pl);