]> code.delx.au - pulseaudio/blob - src/pulsecore/sink-input.c
delx.au / code / pulseaudio / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
core: Use after free in pa_sink_input_new_data_set_formats() and pa_source_output_new...
[pulseaudio] / src / pulsecore / sink-input.c
1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
6
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.
11
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.
16
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
20 USA.
21 ***/
22
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26
27 #include <stdio.h>
28 #include <stdlib.h>
29
30 #include <pulse/utf8.h>
31 #include <pulse/xmalloc.h>
32 #include <pulse/util.h>
33 #include <pulse/internal.h>
34
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>
41
42 #include "sink-input.h"
43
44 /* #define SINK_INPUT_DEBUG */
45
46 #define MEMBLOCKQ_MAXLENGTH (32*1024*1024)
47 #define CONVERT_BUFFER_LENGTH (PA_PAGE_SIZE)
48
49 PA_DEFINE_PUBLIC_CLASS(pa_sink_input, pa_msgobject);
50
51 struct volume_factor_entry {
52 char *key;
53 pa_cvolume volume;
54 };
55
56 static struct volume_factor_entry *volume_factor_entry_new(const char *key, const pa_cvolume *volume) {
57 struct volume_factor_entry *entry;
58
59 pa_assert(key);
60 pa_assert(volume);
61
62 entry = pa_xnew(struct volume_factor_entry, 1);
63 entry->key = pa_xstrdup(key);
64
65 entry->volume = *volume;
66
67 return entry;
68 }
69
70 static void volume_factor_entry_free(struct volume_factor_entry *volume_entry) {
71 pa_assert(volume_entry);
72
73 pa_xfree(volume_entry->key);
74 pa_xfree(volume_entry);
75 }
76
77 static void volume_factor_from_hashmap(pa_cvolume *v, pa_hashmap *items, uint8_t channels) {
78 struct volume_factor_entry *entry;
79 void *state = NULL;
80
81 pa_cvolume_reset(v, channels);
82 PA_HASHMAP_FOREACH(entry, items, state)
83 pa_sw_cvolume_multiply(v, v, &entry->volume);
84 }
85
86 static void sink_input_free(pa_object *o);
87 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v);
88
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");
92 return -PA_ERR_BUSY;
93 }
94
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");
98 return -PA_ERR_BUSY;
99 }
100
101 return PA_OK;
102 }
103
104 pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data) {
105 pa_assert(data);
106
107 pa_zero(*data);
108 data->resample_method = PA_RESAMPLER_INVALID;
109 data->proplist = pa_proplist_new();
110 data->volume_writable = true;
111
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);
116
117 return data;
118 }
119
120 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec) {
121 pa_assert(data);
122
123 if ((data->sample_spec_is_set = !!spec))
124 data->sample_spec = *spec;
125 }
126
127 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map) {
128 pa_assert(data);
129
130 if ((data->channel_map_is_set = !!map))
131 data->channel_map = *map;
132 }
133
134 bool pa_sink_input_new_data_is_passthrough(pa_sink_input_new_data *data) {
135 pa_assert(data);
136
137 if (PA_LIKELY(data->format) && PA_UNLIKELY(!pa_format_info_is_pcm(data->format)))
138 return true;
139
140 if (PA_UNLIKELY(data->flags & PA_SINK_INPUT_PASSTHROUGH))
141 return true;
142
143 return false;
144 }
145
146 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume) {
147 pa_assert(data);
148 pa_assert(data->volume_writable);
149
150 if ((data->volume_is_set = !!volume))
151 data->volume = *volume;
152 }
153
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;
156
157 pa_assert(data);
158 pa_assert(key);
159 pa_assert(volume_factor);
160
161 v = volume_factor_entry_new(key, volume_factor);
162 pa_assert_se(pa_hashmap_put(data->volume_factor_items, v->key, v) >= 0);
163 }
164
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;
167
168 pa_assert(data);
169 pa_assert(key);
170 pa_assert(volume_factor);
171
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);
174 }
175
176 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, bool mute) {
177 pa_assert(data);
178
179 data->muted_is_set = true;
180 data->muted = !!mute;
181 }
182
183 bool pa_sink_input_new_data_set_sink(pa_sink_input_new_data *data, pa_sink *s, bool save) {
184 bool ret = true;
185 pa_idxset *formats = NULL;
186
187 pa_assert(data);
188 pa_assert(s);
189
190 if (!data->req_formats) {
191 /* We're not working with the extended API */
192 data->sink = s;
193 data->save_sink = save;
194 } else {
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);
197
198 if (formats && !pa_idxset_isempty(formats)) {
199 /* Sink supports at least one of the requested formats */
200 data->sink = s;
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;
205 } else {
206 /* Sink doesn't support any of the formats requested by the client */
207 if (formats)
208 pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
209 ret = false;
210 }
211 }
212
213 return ret;
214 }
215
216 bool pa_sink_input_new_data_set_formats(pa_sink_input_new_data *data, pa_idxset *formats) {
217 pa_assert(data);
218 pa_assert(formats);
219
220 if (data->req_formats)
221 pa_idxset_free(data->req_formats, (pa_free_cb_t) pa_format_info_free);
222
223 data->req_formats = formats;
224
225 if (data->sink) {
226 /* Trigger format negotiation */
227 return pa_sink_input_new_data_set_sink(data, data->sink, data->save_sink);
228 }
229
230 return true;
231 }
232
233 void pa_sink_input_new_data_done(pa_sink_input_new_data *data) {
234 pa_assert(data);
235
236 if (data->req_formats)
237 pa_idxset_free(data->req_formats, (pa_free_cb_t) pa_format_info_free);
238
239 if (data->nego_formats)
240 pa_idxset_free(data->nego_formats, (pa_free_cb_t) pa_format_info_free);
241
242 if (data->format)
243 pa_format_info_free(data->format);
244
245 if (data->volume_factor_items)
246 pa_hashmap_free(data->volume_factor_items);
247
248 if (data->volume_factor_sink_items)
249 pa_hashmap_free(data->volume_factor_sink_items);
250
251 pa_proplist_free(data->proplist);
252 }
253
254 /* Called from main context */
255 static void reset_callbacks(pa_sink_input *i) {
256 pa_assert(i);
257
258 i->pop = NULL;
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;
266 i->attach = NULL;
267 i->detach = NULL;
268 i->suspend = NULL;
269 i->suspend_within_thread = NULL;
270 i->moving = NULL;
271 i->kill = 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;
278 }
279
280 /* Called from main context */
281 int pa_sink_input_new(
282 pa_sink_input **_i,
283 pa_core *core,
284 pa_sink_input_new_data *data) {
285
286 pa_sink_input *i;
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;
290 int r;
291 char *pt;
292 char *memblockq_name;
293 pa_sample_spec ss;
294 pa_channel_map map;
295
296 pa_assert(_i);
297 pa_assert(core);
298 pa_assert(data);
299 pa_assert_ctl_context();
300
301 if (data->client)
302 pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->client->proplist);
303
304 if (data->origin_sink && (data->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
305 data->volume_writable = false;
306
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);
316 }
317
318 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], data)) < 0)
319 return r;
320
321 pa_return_val_if_fail(!data->driver || pa_utf8_valid(data->driver), -PA_ERR_INVALID);
322
323 if (!data->sink) {
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);
327 }
328 /* Routing's done, we have a sink. Now let's fix the format and set up the
329 * sample spec */
330
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));
335
336 if (PA_LIKELY(data->format)) {
337 pa_log_debug("Negotiated format: %s", pa_format_info_snprint(fmt, sizeof(fmt), data->format));
338 } else {
339 pa_format_info *format;
340 uint32_t idx;
341
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));
345
346 return -PA_ERR_NOTSUPPORTED;
347 }
348
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);
355
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);
358
359 r = check_passthrough_connection(pa_sink_input_new_data_is_passthrough(data), data->sink);
360 if (r != PA_OK)
361 return r;
362
363 if (!data->sample_spec_is_set)
364 data->sample_spec = data->sink->sample_spec;
365
366 pa_return_val_if_fail(pa_sample_spec_valid(&data->sample_spec), -PA_ERR_INVALID);
367
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;
371 else
372 pa_channel_map_init_extend(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
373 }
374
375 pa_return_val_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec), -PA_ERR_INVALID);
376
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;
384 }
385
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;
390 }
391
392 if (!data->volume_writable)
393 data->save_volume = false;
394
395 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec), -PA_ERR_INVALID);
396
397 if (!data->muted_is_set)
398 data->muted = false;
399
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);
404 }
405
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);
410 }
411
412 original_cm = data->channel_map;
413
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);
420 }
421
422 pa_assert(pa_sample_spec_valid(&data->sample_spec));
423 pa_assert(pa_channel_map_valid(&data->channel_map));
424
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 */
429
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);
433 }
434
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 */
438
439 pa_log_debug("Could not update sink sample spec to match passthrough stream");
440 return -PA_ERR_NOTSUPPORTED;
441 }
442
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);
445
446 if (data->resample_method == PA_RESAMPLER_INVALID)
447 data->resample_method = core->resample_method;
448
449 pa_return_val_if_fail(data->resample_method < PA_RESAMPLER_MAX, -PA_ERR_INVALID);
450
451 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], data)) < 0)
452 return r;
453
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;
458 }
459
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;
463 }
464
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)) {
468
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(
472 core->mempool,
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;
482 }
483 }
484
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;
488
489 i->core = core;
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;
498
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);
504
505 if (!data->volume_is_absolute && pa_sink_flat_volume_enabled(i->sink)) {
506 pa_cvolume remapped;
507
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);
513 } else
514 i->volume = data->volume;
515
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);
519
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);
523
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;
531
532 i->muted = data->muted;
533
534 if (data->sync_base) {
535 i->sync_next = data->sync_base->sync_next;
536 i->sync_prev = data->sync_base;
537
538 if (data->sync_base->sync_next)
539 data->sync_base->sync_next->sync_prev = i;
540 data->sync_base->sync_next = i;
541 } else
542 i->sync_next = i->sync_prev = NULL;
543
544 i->direct_outputs = pa_idxset_new(NULL, NULL);
545
546 reset_callbacks(i);
547 i->userdata = NULL;
548
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);
564
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);
567
568 if (i->client)
569 pa_assert_se(pa_idxset_put(i->client->sink_inputs, i, NULL) >= 0);
570
571 memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
572 i->thread_info.render_memblockq = pa_memblockq_new(
573 memblockq_name,
574 0,
575 MEMBLOCKQ_MAXLENGTH,
576 0,
577 &i->sink->sample_spec,
578 0,
579 1,
580 0,
581 &i->sink->silence);
582 pa_xfree(memblockq_name);
583
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",
586 i->index,
587 pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)),
588 i->sink->name,
589 pa_sample_spec_snprint(st, sizeof(st), &i->sample_spec),
590 pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
591 pt);
592 pa_xfree(pt);
593
594 /* Don't forget to call pa_sink_input_put! */
595
596 *_i = i;
597 return 0;
598 }
599
600 /* Called from main context */
601 static void update_n_corked(pa_sink_input *i, pa_sink_input_state_t state) {
602 pa_assert(i);
603 pa_assert_ctl_context();
604
605 if (!i->sink)
606 return;
607
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)
611 i->sink->n_corked++;
612 }
613
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;
617 pa_assert(i);
618 pa_assert_ctl_context();
619
620 if (state == PA_SINK_INPUT_DRAINED)
621 state = PA_SINK_INPUT_RUNNING;
622
623 if (i->state == state)
624 return;
625
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));
631 }
632
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);
634
635 update_n_corked(i, state);
636 i->state = state;
637
638 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev) {
639 update_n_corked(ssync, state);
640 ssync->state = state;
641 }
642 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next) {
643 update_n_corked(ssync, state);
644 ssync->state = state;
645 }
646
647 if (state != PA_SINK_INPUT_UNLINKED) {
648 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], i);
649
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);
652
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);
655
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);
658 }
659
660 pa_sink_update_status(i->sink);
661 }
662
663 /* Called from main context */
664 void pa_sink_input_unlink(pa_sink_input *i) {
665 bool linked;
666 pa_source_output *o, *p = NULL;
667
668 pa_assert(i);
669 pa_assert_ctl_context();
670
671 /* See pa_sink_unlink() for a couple of comments how this function
672 * works */
673
674 pa_sink_input_ref(i);
675
676 linked = PA_SINK_INPUT_IS_LINKED(i->state);
677
678 if (linked)
679 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], i);
680
681 if (i->sync_prev)
682 i->sync_prev->sync_next = i->sync_next;
683 if (i->sync_next)
684 i->sync_next->sync_prev = i->sync_prev;
685
686 i->sync_prev = i->sync_next = NULL;
687
688 pa_idxset_remove_by_data(i->core->sink_inputs, i, NULL);
689
690 if (i->sink)
691 if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL))
692 pa_sink_input_unref(i);
693
694 if (i->client)
695 pa_idxset_remove_by_data(i->client->sink_inputs, i, NULL);
696
697 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
698 pa_assert(o != p);
699 pa_source_output_kill(o);
700 p = o;
701 }
702
703 update_n_corked(i, PA_SINK_INPUT_UNLINKED);
704 i->state = PA_SINK_INPUT_UNLINKED;
705
706 if (linked && i->sink) {
707 if (pa_sink_input_is_passthrough(i))
708 pa_sink_leave_passthrough(i->sink);
709
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);
713
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);
716 }
717
718 reset_callbacks(i);
719
720 if (linked) {
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);
723 }
724
725 if (i->sink) {
726 if (PA_SINK_IS_LINKED(pa_sink_get_state(i->sink)))
727 pa_sink_update_status(i->sink);
728
729 i->sink = NULL;
730 }
731
732 pa_core_maybe_vacuum(i->core);
733
734 pa_sink_input_unref(i);
735 }
736
737 /* Called from main context */
738 static void sink_input_free(pa_object *o) {
739 pa_sink_input* i = PA_SINK_INPUT(o);
740
741 pa_assert(i);
742 pa_assert_ctl_context();
743 pa_assert(pa_sink_input_refcnt(i) == 0);
744
745 if (PA_SINK_INPUT_IS_LINKED(i->state))
746 pa_sink_input_unlink(i);
747
748 pa_log_info("Freeing input %u \"%s\"", i->index,
749 i->proplist ? pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)) : "");
750
751 /* Side note: this function must be able to destruct properly any
752 * kind of sink input in any state, even those which are
753 * "half-moved" or are connected to sinks that have no asyncmsgq
754 * and are hence half-destructed themselves! */
755
756 if (i->thread_info.render_memblockq)
757 pa_memblockq_free(i->thread_info.render_memblockq);
758
759 if (i->thread_info.resampler)
760 pa_resampler_free(i->thread_info.resampler);
761
762 if (i->format)
763 pa_format_info_free(i->format);
764
765 if (i->proplist)
766 pa_proplist_free(i->proplist);
767
768 if (i->direct_outputs)
769 pa_idxset_free(i->direct_outputs, NULL);
770
771 if (i->thread_info.direct_outputs)
772 pa_hashmap_free(i->thread_info.direct_outputs);
773
774 if (i->volume_factor_items)
775 pa_hashmap_free(i->volume_factor_items);
776
777 if (i->volume_factor_sink_items)
778 pa_hashmap_free(i->volume_factor_sink_items);
779
780 pa_xfree(i->driver);
781 pa_xfree(i);
782 }
783
784 /* Called from main context */
785 void pa_sink_input_put(pa_sink_input *i) {
786 pa_sink_input_state_t state;
787
788 pa_sink_input_assert_ref(i);
789 pa_assert_ctl_context();
790
791 pa_assert(i->state == PA_SINK_INPUT_INIT);
792
793 /* The following fields must be initialized properly */
794 pa_assert(i->pop);
795 pa_assert(i->process_rewind);
796 pa_assert(i->kill);
797
798 state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING;
799
800 update_n_corked(i, state);
801 i->state = state;
802
803 /* We might need to update the sink's volume if we are in flat volume mode. */
804 if (pa_sink_flat_volume_enabled(i->sink))
805 pa_sink_set_volume(i->sink, NULL, false, i->save_volume);
806 else {
807 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
808 pa_assert(pa_cvolume_is_norm(&i->volume));
809 pa_assert(pa_cvolume_is_norm(&i->reference_ratio));
810 }
811
812 set_real_ratio(i, &i->volume);
813 }
814
815 if (pa_sink_input_is_passthrough(i))
816 pa_sink_enter_passthrough(i->sink);
817
818 i->thread_info.soft_volume = i->soft_volume;
819 i->thread_info.muted = i->muted;
820
821 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_ADD_INPUT, i, 0, NULL) == 0);
822
823 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, i->index);
824 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], i);
825
826 pa_sink_update_status(i->sink);
827 }
828
829 /* Called from main context */
830 void pa_sink_input_kill(pa_sink_input*i) {
831 pa_sink_input_assert_ref(i);
832 pa_assert_ctl_context();
833 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
834
835 i->kill(i);
836 }
837
838 /* Called from main context */
839 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency) {
840 pa_usec_t r[2] = { 0, 0 };
841
842 pa_sink_input_assert_ref(i);
843 pa_assert_ctl_context();
844 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
845
846 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_LATENCY, r, 0, NULL) == 0);
847
848 if (i->get_latency)
849 r[0] += i->get_latency(i);
850
851 if (sink_latency)
852 *sink_latency = r[1];
853
854 return r[0];
855 }
856
857 /* Called from thread context */
858 void pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink bytes */, pa_memchunk *chunk, pa_cvolume *volume) {
859 bool do_volume_adj_here, need_volume_factor_sink;
860 bool volume_is_norm;
861 size_t block_size_max_sink, block_size_max_sink_input;
862 size_t ilength;
863 size_t ilength_full;
864
865 pa_sink_input_assert_ref(i);
866 pa_sink_input_assert_io_context(i);
867 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
868 pa_assert(pa_frame_aligned(slength, &i->sink->sample_spec));
869 pa_assert(chunk);
870 pa_assert(volume);
871
872 #ifdef SINK_INPUT_DEBUG
873 pa_log_debug("peek");
874 #endif
875
876 block_size_max_sink_input = i->thread_info.resampler ?
877 pa_resampler_max_block_size(i->thread_info.resampler) :
878 pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sample_spec);
879
880 block_size_max_sink = pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sink->sample_spec);
881
882 /* Default buffer size */
883 if (slength <= 0)
884 slength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sink->sample_spec);
885
886 if (slength > block_size_max_sink)
887 slength = block_size_max_sink;
888
889 if (i->thread_info.resampler) {
890 ilength = pa_resampler_request(i->thread_info.resampler, slength);
891
892 if (ilength <= 0)
893 ilength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sample_spec);
894 } else
895 ilength = slength;
896
897 /* Length corresponding to slength (without limiting to
898 * block_size_max_sink_input). */
899 ilength_full = ilength;
900
901 if (ilength > block_size_max_sink_input)
902 ilength = block_size_max_sink_input;
903
904 /* If the channel maps of the sink and this stream differ, we need
905 * to adjust the volume *before* we resample. Otherwise we can do
906 * it after and leave it for the sink code */
907
908 do_volume_adj_here = !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map);
909 volume_is_norm = pa_cvolume_is_norm(&i->thread_info.soft_volume) && !i->thread_info.muted;
910 need_volume_factor_sink = !pa_cvolume_is_norm(&i->volume_factor_sink);
911
912 while (!pa_memblockq_is_readable(i->thread_info.render_memblockq)) {
913 pa_memchunk tchunk;
914
915 /* There's nothing in our render queue. We need to fill it up
916 * with data from the implementor. */
917
918 if (i->thread_info.state == PA_SINK_INPUT_CORKED ||
919 i->pop(i, ilength, &tchunk) < 0) {
920
921 /* OK, we're corked or the implementor didn't give us any
922 * data, so let's just hand out silence */
923 pa_atomic_store(&i->thread_info.drained, 1);
924
925 pa_memblockq_seek(i->thread_info.render_memblockq, (int64_t) slength, PA_SEEK_RELATIVE, true);
926 i->thread_info.playing_for = 0;
927 if (i->thread_info.underrun_for != (uint64_t) -1) {
928 i->thread_info.underrun_for += ilength_full;
929 i->thread_info.underrun_for_sink += slength;
930 }
931 break;
932 }
933
934 pa_atomic_store(&i->thread_info.drained, 0);
935
936 pa_assert(tchunk.length > 0);
937 pa_assert(tchunk.memblock);
938
939 i->thread_info.underrun_for = 0;
940 i->thread_info.underrun_for_sink = 0;
941 i->thread_info.playing_for += tchunk.length;
942
943 while (tchunk.length > 0) {
944 pa_memchunk wchunk;
945 bool nvfs = need_volume_factor_sink;
946
947 wchunk = tchunk;
948 pa_memblock_ref(wchunk.memblock);
949
950 if (wchunk.length > block_size_max_sink_input)
951 wchunk.length = block_size_max_sink_input;
952
953 /* It might be necessary to adjust the volume here */
954 if (do_volume_adj_here && !volume_is_norm) {
955 pa_memchunk_make_writable(&wchunk, 0);
956
957 if (i->thread_info.muted) {
958 pa_silence_memchunk(&wchunk, &i->thread_info.sample_spec);
959 nvfs = false;
960
961 } else if (!i->thread_info.resampler && nvfs) {
962 pa_cvolume v;
963
964 /* If we don't need a resampler we can merge the
965 * post and the pre volume adjustment into one */
966
967 pa_sw_cvolume_multiply(&v, &i->thread_info.soft_volume, &i->volume_factor_sink);
968 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &v);
969 nvfs = false;
970
971 } else
972 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.soft_volume);
973 }
974
975 if (!i->thread_info.resampler) {
976
977 if (nvfs) {
978 pa_memchunk_make_writable(&wchunk, 0);
979 pa_volume_memchunk(&wchunk, &i->sink->sample_spec, &i->volume_factor_sink);
980 }
981
982 pa_memblockq_push_align(i->thread_info.render_memblockq, &wchunk);
983 } else {
984 pa_memchunk rchunk;
985 pa_resampler_run(i->thread_info.resampler, &wchunk, &rchunk);
986
987 #ifdef SINK_INPUT_DEBUG
988 pa_log_debug("pushing %lu", (unsigned long) rchunk.length);
989 #endif
990
991 if (rchunk.memblock) {
992
993 if (nvfs) {
994 pa_memchunk_make_writable(&rchunk, 0);
995 pa_volume_memchunk(&rchunk, &i->sink->sample_spec, &i->volume_factor_sink);
996 }
997
998 pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk);
999 pa_memblock_unref(rchunk.memblock);
1000 }
1001 }
1002
1003 pa_memblock_unref(wchunk.memblock);
1004
1005 tchunk.index += wchunk.length;
1006 tchunk.length -= wchunk.length;
1007 }
1008
1009 pa_memblock_unref(tchunk.memblock);
1010 }
1011
1012 pa_assert_se(pa_memblockq_peek(i->thread_info.render_memblockq, chunk) >= 0);
1013
1014 pa_assert(chunk->length > 0);
1015 pa_assert(chunk->memblock);
1016
1017 #ifdef SINK_INPUT_DEBUG
1018 pa_log_debug("peeking %lu", (unsigned long) chunk->length);
1019 #endif
1020
1021 if (chunk->length > block_size_max_sink)
1022 chunk->length = block_size_max_sink;
1023
1024 /* Let's see if we had to apply the volume adjustment ourselves,
1025 * or if this can be done by the sink for us */
1026
1027 if (do_volume_adj_here)
1028 /* We had different channel maps, so we already did the adjustment */
1029 pa_cvolume_reset(volume, i->sink->sample_spec.channels);
1030 else if (i->thread_info.muted)
1031 /* We've both the same channel map, so let's have the sink do the adjustment for us*/
1032 pa_cvolume_mute(volume, i->sink->sample_spec.channels);
1033 else
1034 *volume = i->thread_info.soft_volume;
1035 }
1036
1037 /* Called from thread context */
1038 void pa_sink_input_drop(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
1039
1040 pa_sink_input_assert_ref(i);
1041 pa_sink_input_assert_io_context(i);
1042 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1043 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1044 pa_assert(nbytes > 0);
1045
1046 #ifdef SINK_INPUT_DEBUG
1047 pa_log_debug("dropping %lu", (unsigned long) nbytes);
1048 #endif
1049
1050 pa_memblockq_drop(i->thread_info.render_memblockq, nbytes);
1051 }
1052
1053 /* Called from thread context */
1054 bool pa_sink_input_process_underrun(pa_sink_input *i) {
1055 pa_sink_input_assert_ref(i);
1056 pa_sink_input_assert_io_context(i);
1057
1058 if (pa_memblockq_is_readable(i->thread_info.render_memblockq))
1059 return false;
1060
1061 if (i->process_underrun && i->process_underrun(i)) {
1062 /* All valid data has been played back, so we can empty this queue. */
1063 pa_memblockq_silence(i->thread_info.render_memblockq);
1064 return true;
1065 }
1066 return false;
1067 }
1068
1069 /* Called from thread context */
1070 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
1071 size_t lbq;
1072 bool called = false;
1073
1074 pa_sink_input_assert_ref(i);
1075 pa_sink_input_assert_io_context(i);
1076 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1077 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1078
1079 #ifdef SINK_INPUT_DEBUG
1080 pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes);
1081 #endif
1082
1083 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1084
1085 if (nbytes > 0 && !i->thread_info.dont_rewind_render) {
1086 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes);
1087 pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes);
1088 }
1089
1090 if (i->thread_info.rewrite_nbytes == (size_t) -1) {
1091
1092 /* We were asked to drop all buffered data, and rerequest new
1093 * data from implementor the next time peek() is called */
1094
1095 pa_memblockq_flush_write(i->thread_info.render_memblockq, true);
1096
1097 } else if (i->thread_info.rewrite_nbytes > 0) {
1098 size_t max_rewrite, amount;
1099
1100 /* Calculate how much make sense to rewrite at most */
1101 max_rewrite = nbytes + lbq;
1102
1103 /* Transform into local domain */
1104 if (i->thread_info.resampler)
1105 max_rewrite = pa_resampler_request(i->thread_info.resampler, max_rewrite);
1106
1107 /* Calculate how much of the rewinded data should actually be rewritten */
1108 amount = PA_MIN(i->thread_info.rewrite_nbytes, max_rewrite);
1109
1110 if (amount > 0) {
1111 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount);
1112
1113 /* Tell the implementor */
1114 if (i->process_rewind)
1115 i->process_rewind(i, amount);
1116 called = true;
1117
1118 /* Convert back to to sink domain */
1119 if (i->thread_info.resampler)
1120 amount = pa_resampler_result(i->thread_info.resampler, amount);
1121
1122 if (amount > 0)
1123 /* Ok, now update the write pointer */
1124 pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) amount), PA_SEEK_RELATIVE, true);
1125
1126 if (i->thread_info.rewrite_flush)
1127 pa_memblockq_silence(i->thread_info.render_memblockq);
1128
1129 /* And reset the resampler */
1130 if (i->thread_info.resampler)
1131 pa_resampler_reset(i->thread_info.resampler);
1132 }
1133 }
1134
1135 if (!called)
1136 if (i->process_rewind)
1137 i->process_rewind(i, 0);
1138
1139 i->thread_info.rewrite_nbytes = 0;
1140 i->thread_info.rewrite_flush = false;
1141 i->thread_info.dont_rewind_render = false;
1142 }
1143
1144 /* Called from thread context */
1145 size_t pa_sink_input_get_max_rewind(pa_sink_input *i) {
1146 pa_sink_input_assert_ref(i);
1147 pa_sink_input_assert_io_context(i);
1148
1149 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_rewind) : i->sink->thread_info.max_rewind;
1150 }
1151
1152 /* Called from thread context */
1153 size_t pa_sink_input_get_max_request(pa_sink_input *i) {
1154 pa_sink_input_assert_ref(i);
1155 pa_sink_input_assert_io_context(i);
1156
1157 /* We're not verifying the status here, to allow this to be called
1158 * in the state change handler between _INIT and _RUNNING */
1159
1160 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_request) : i->sink->thread_info.max_request;
1161 }
1162
1163 /* Called from thread context */
1164 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1165 pa_sink_input_assert_ref(i);
1166 pa_sink_input_assert_io_context(i);
1167 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1168 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1169
1170 pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes);
1171
1172 if (i->update_max_rewind)
1173 i->update_max_rewind(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1174 }
1175
1176 /* Called from thread context */
1177 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1178 pa_sink_input_assert_ref(i);
1179 pa_sink_input_assert_io_context(i);
1180 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1181 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1182
1183 if (i->update_max_request)
1184 i->update_max_request(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1185 }
1186
1187 /* Called from thread context */
1188 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) {
1189 pa_sink_input_assert_ref(i);
1190 pa_sink_input_assert_io_context(i);
1191
1192 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1193 usec = i->sink->thread_info.fixed_latency;
1194
1195 if (usec != (pa_usec_t) -1)
1196 usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
1197
1198 i->thread_info.requested_sink_latency = usec;
1199 pa_sink_invalidate_requested_latency(i->sink, true);
1200
1201 return usec;
1202 }
1203
1204 /* Called from main context */
1205 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) {
1206 pa_sink_input_assert_ref(i);
1207 pa_assert_ctl_context();
1208
1209 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1210 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1211 return usec;
1212 }
1213
1214 /* If this sink input is not realized yet or we are being moved,
1215 * we have to touch the thread info data directly */
1216
1217 if (i->sink) {
1218 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1219 usec = pa_sink_get_fixed_latency(i->sink);
1220
1221 if (usec != (pa_usec_t) -1) {
1222 pa_usec_t min_latency, max_latency;
1223 pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
1224 usec = PA_CLAMP(usec, min_latency, max_latency);
1225 }
1226 }
1227
1228 i->thread_info.requested_sink_latency = usec;
1229
1230 return usec;
1231 }
1232
1233 /* Called from main context */
1234 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
1235 pa_sink_input_assert_ref(i);
1236 pa_assert_ctl_context();
1237
1238 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1239 pa_usec_t usec = 0;
1240 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1241 return usec;
1242 }
1243
1244 /* If this sink input is not realized yet or we are being moved,
1245 * we have to touch the thread info data directly */
1246
1247 return i->thread_info.requested_sink_latency;
1248 }
1249
1250 /* Called from main context */
1251 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, bool save, bool absolute) {
1252 pa_cvolume v;
1253
1254 pa_sink_input_assert_ref(i);
1255 pa_assert_ctl_context();
1256 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1257 pa_assert(volume);
1258 pa_assert(pa_cvolume_valid(volume));
1259 pa_assert(volume->channels == 1 || pa_cvolume_compatible(volume, &i->sample_spec));
1260 pa_assert(i->volume_writable);
1261
1262 if (!absolute && pa_sink_flat_volume_enabled(i->sink)) {
1263 v = i->sink->reference_volume;
1264 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
1265
1266 if (pa_cvolume_compatible(volume, &i->sample_spec))
1267 volume = pa_sw_cvolume_multiply(&v, &v, volume);
1268 else
1269 volume = pa_sw_cvolume_multiply_scalar(&v, &v, pa_cvolume_max(volume));
1270 } else {
1271 if (!pa_cvolume_compatible(volume, &i->sample_spec)) {
1272 v = i->volume;
1273 volume = pa_cvolume_scale(&v, pa_cvolume_max(volume));
1274 }
1275 }
1276
1277 if (pa_cvolume_equal(volume, &i->volume)) {
1278 i->save_volume = i->save_volume || save;
1279 return;
1280 }
1281
1282 i->volume = *volume;
1283 i->save_volume = save;
1284
1285 if (pa_sink_flat_volume_enabled(i->sink)) {
1286 /* We are in flat volume mode, so let's update all sink input
1287 * volumes and update the flat volume of the sink */
1288
1289 pa_sink_set_volume(i->sink, NULL, true, save);
1290
1291 } else {
1292 /* OK, we are in normal volume mode. The volume only affects
1293 * ourselves */
1294 set_real_ratio(i, volume);
1295 i->reference_ratio = i->volume;
1296
1297 /* Copy the new soft_volume to the thread_info struct */
1298 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1299 }
1300
1301 /* The volume changed, let's tell people so */
1302 if (i->volume_changed)
1303 i->volume_changed(i);
1304
1305 /* The virtual volume changed, let's tell people so */
1306 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1307 }
1308
1309 void pa_sink_input_add_volume_factor(pa_sink_input *i, const char *key, const pa_cvolume *volume_factor) {
1310 struct volume_factor_entry *v;
1311
1312 pa_sink_input_assert_ref(i);
1313 pa_assert_ctl_context();
1314 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1315 pa_assert(volume_factor);
1316 pa_assert(key);
1317 pa_assert(pa_cvolume_valid(volume_factor));
1318 pa_assert(volume_factor->channels == 1 || pa_cvolume_compatible(volume_factor, &i->sample_spec));
1319
1320 v = volume_factor_entry_new(key, volume_factor);
1321 if (!pa_cvolume_compatible(volume_factor, &i->sample_spec))
1322 pa_cvolume_set(&v->volume, i->sample_spec.channels, volume_factor->values[0]);
1323
1324 pa_assert_se(pa_hashmap_put(i->volume_factor_items, v->key, v) >= 0);
1325 if (pa_hashmap_size(i->volume_factor_items) == 1)
1326 i->volume_factor = v->volume;
1327 else
1328 pa_sw_cvolume_multiply(&i->volume_factor, &i->volume_factor, &v->volume);
1329
1330 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1331
1332 /* Copy the new soft_volume to the thread_info struct */
1333 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1334 }
1335
1336 /* Returns 0 if an entry was removed and -1 if no entry for the given key was
1337 * found. */
1338 int pa_sink_input_remove_volume_factor(pa_sink_input *i, const char *key) {
1339 struct volume_factor_entry *v;
1340
1341 pa_sink_input_assert_ref(i);
1342 pa_assert(key);
1343 pa_assert_ctl_context();
1344 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1345
1346 v = pa_hashmap_remove(i->volume_factor_items, key);
1347
1348 if (!v)
1349 return -1;
1350
1351 volume_factor_entry_free(v);
1352
1353 switch (pa_hashmap_size(i->volume_factor_items)) {
1354 case 0:
1355 pa_cvolume_reset(&i->volume_factor, i->sample_spec.channels);
1356 break;
1357 case 1:
1358 v = pa_hashmap_first(i->volume_factor_items);
1359 i->volume_factor = v->volume;
1360 break;
1361 default:
1362 volume_factor_from_hashmap(&i->volume_factor, i->volume_factor_items, i->volume_factor.channels);
1363 }
1364
1365 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1366
1367 /* Copy the new soft_volume to the thread_info struct */
1368 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1369
1370 return 0;
1371 }
1372
1373 /* Called from main context */
1374 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
1375 pa_sink_input_assert_ref(i);
1376 pa_assert_ctl_context();
1377 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1378 pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
1379
1380 /* This basically calculates:
1381 *
1382 * i->real_ratio := v
1383 * i->soft_volume := i->real_ratio * i->volume_factor */
1384
1385 if (v)
1386 i->real_ratio = *v;
1387 else
1388 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
1389
1390 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1391 /* We don't copy the data to the thread_info data. That's left for someone else to do */
1392 }
1393
1394 /* Called from main or I/O context */
1395 bool pa_sink_input_is_passthrough(pa_sink_input *i) {
1396 pa_sink_input_assert_ref(i);
1397
1398 if (PA_UNLIKELY(!pa_format_info_is_pcm(i->format)))
1399 return true;
1400
1401 if (PA_UNLIKELY(i->flags & PA_SINK_INPUT_PASSTHROUGH))
1402 return true;
1403
1404 return false;
1405 }
1406
1407 /* Called from main context */
1408 bool pa_sink_input_is_volume_readable(pa_sink_input *i) {
1409 pa_sink_input_assert_ref(i);
1410 pa_assert_ctl_context();
1411
1412 return !pa_sink_input_is_passthrough(i);
1413 }
1414
1415 /* Called from main context */
1416 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, bool absolute) {
1417 pa_sink_input_assert_ref(i);
1418 pa_assert_ctl_context();
1419 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1420 pa_assert(pa_sink_input_is_volume_readable(i));
1421
1422 if (absolute || !pa_sink_flat_volume_enabled(i->sink))
1423 *volume = i->volume;
1424 else
1425 *volume = i->reference_ratio;
1426
1427 return volume;
1428 }
1429
1430 /* Called from main context */
1431 void pa_sink_input_set_mute(pa_sink_input *i, bool mute, bool save) {
1432 pa_sink_input_assert_ref(i);
1433 pa_assert_ctl_context();
1434 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1435
1436 if (!i->muted == !mute) {
1437 i->save_muted = i->save_muted || mute;
1438 return;
1439 }
1440
1441 i->muted = mute;
1442 i->save_muted = save;
1443
1444 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1445
1446 /* The mute status changed, let's tell people so */
1447 if (i->mute_changed)
1448 i->mute_changed(i);
1449
1450 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1451 }
1452
1453 /* Called from main context */
1454 bool pa_sink_input_get_mute(pa_sink_input *i) {
1455 pa_sink_input_assert_ref(i);
1456 pa_assert_ctl_context();
1457 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1458
1459 return i->muted;
1460 }
1461
1462 /* Called from main thread */
1463 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1464 pa_sink_input_assert_ref(i);
1465 pa_assert_ctl_context();
1466
1467 if (p)
1468 pa_proplist_update(i->proplist, mode, p);
1469
1470 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1471 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1472 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1473 }
1474 }
1475
1476 /* Called from main context */
1477 void pa_sink_input_cork(pa_sink_input *i, bool b) {
1478 pa_sink_input_assert_ref(i);
1479 pa_assert_ctl_context();
1480 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1481
1482 sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1483 }
1484
1485 /* Called from main context */
1486 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1487 pa_sink_input_assert_ref(i);
1488 pa_assert_ctl_context();
1489 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1490 pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1491
1492 if (i->sample_spec.rate == rate)
1493 return 0;
1494
1495 i->sample_spec.rate = rate;
1496
1497 pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1498
1499 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1500 return 0;
1501 }
1502
1503 /* Called from main context */
1504 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1505 const char *old;
1506 pa_sink_input_assert_ref(i);
1507 pa_assert_ctl_context();
1508
1509 if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1510 return;
1511
1512 old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1513
1514 if (old && name && pa_streq(old, name))
1515 return;
1516
1517 if (name)
1518 pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1519 else
1520 pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1521
1522 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1523 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1524 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1525 }
1526 }
1527
1528 /* Called from main context */
1529 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1530 pa_sink_input_assert_ref(i);
1531 pa_assert_ctl_context();
1532
1533 return i->actual_resample_method;
1534 }
1535
1536 /* Called from main context */
1537 bool pa_sink_input_may_move(pa_sink_input *i) {
1538 pa_sink_input_assert_ref(i);
1539 pa_assert_ctl_context();
1540 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1541
1542 if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1543 return false;
1544
1545 if (i->sync_next || i->sync_prev) {
1546 pa_log_warn("Moving synchronized streams not supported.");
1547 return false;
1548 }
1549
1550 return true;
1551 }
1552
1553 static bool find_filter_sink_input(pa_sink_input *target, pa_sink *s) {
1554 int i = 0;
1555 while (s && s->input_to_master) {
1556 if (s->input_to_master == target)
1557 return true;
1558 s = s->input_to_master->sink;
1559 pa_assert(i++ < 100);
1560 }
1561 return false;
1562 }
1563
1564 /* Called from main context */
1565 bool pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1566 pa_sink_input_assert_ref(i);
1567 pa_assert_ctl_context();
1568 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1569 pa_sink_assert_ref(dest);
1570
1571 if (dest == i->sink)
1572 return true;
1573
1574 if (!pa_sink_input_may_move(i))
1575 return false;
1576
1577 /* Make sure we're not creating a filter sink cycle */
1578 if (find_filter_sink_input(i, dest)) {
1579 pa_log_debug("Can't connect input to %s, as that would create a cycle.", dest->name);
1580 return false;
1581 }
1582
1583 if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1584 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1585 return false;
1586 }
1587
1588 if (check_passthrough_connection(pa_sink_input_is_passthrough(i), dest) < 0)
1589 return false;
1590
1591 if (i->may_move_to)
1592 if (!i->may_move_to(i, dest))
1593 return false;
1594
1595 return true;
1596 }
1597
1598 /* Called from main context */
1599 int pa_sink_input_start_move(pa_sink_input *i) {
1600 pa_source_output *o, *p = NULL;
1601 struct volume_factor_entry *v;
1602 void *state = NULL;
1603 int r;
1604
1605 pa_sink_input_assert_ref(i);
1606 pa_assert_ctl_context();
1607 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1608 pa_assert(i->sink);
1609
1610 if (!pa_sink_input_may_move(i))
1611 return -PA_ERR_NOTSUPPORTED;
1612
1613 if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1614 return r;
1615
1616 /* Kill directly connected outputs */
1617 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1618 pa_assert(o != p);
1619 pa_source_output_kill(o);
1620 p = o;
1621 }
1622 pa_assert(pa_idxset_isempty(i->direct_outputs));
1623
1624 pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1625
1626 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1627 pa_assert_se(i->sink->n_corked-- >= 1);
1628
1629 if (pa_sink_input_is_passthrough(i))
1630 pa_sink_leave_passthrough(i->sink);
1631
1632 if (pa_sink_flat_volume_enabled(i->sink))
1633 /* We might need to update the sink's volume if we are in flat
1634 * volume mode. */
1635 pa_sink_set_volume(i->sink, NULL, false, false);
1636
1637 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1638
1639 pa_sink_update_status(i->sink);
1640
1641 PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state)
1642 pa_cvolume_remap(&v->volume, &i->sink->channel_map, &i->channel_map);
1643
1644 pa_cvolume_remap(&i->volume_factor_sink, &i->sink->channel_map, &i->channel_map);
1645
1646 i->sink = NULL;
1647
1648 pa_sink_input_unref(i);
1649
1650 return 0;
1651 }
1652
1653 /* Called from main context. If i has an origin sink that uses volume sharing,
1654 * then also the origin sink and all streams connected to it need to update
1655 * their volume - this function does all that by using recursion. */
1656 static void update_volume_due_to_moving(pa_sink_input *i, pa_sink *dest) {
1657 pa_cvolume old_volume;
1658
1659 pa_assert(i);
1660 pa_assert(dest);
1661 pa_assert(i->sink); /* The destination sink should already be set. */
1662
1663 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1664 pa_sink *root_sink = pa_sink_get_master(i->sink);
1665 pa_sink_input *origin_sink_input;
1666 uint32_t idx;
1667
1668 if (PA_UNLIKELY(!root_sink))
1669 return;
1670
1671 if (pa_sink_flat_volume_enabled(i->sink)) {
1672 /* Ok, so the origin sink uses volume sharing, and flat volume is
1673 * enabled. The volume will have to be updated as follows:
1674 *
1675 * i->volume := i->sink->real_volume
1676 * (handled later by pa_sink_set_volume)
1677 * i->reference_ratio := i->volume / i->sink->reference_volume
1678 * (handled later by pa_sink_set_volume)
1679 * i->real_ratio stays unchanged
1680 * (streams whose origin sink uses volume sharing should
1681 * always have real_ratio of 0 dB)
1682 * i->soft_volume stays unchanged
1683 * (streams whose origin sink uses volume sharing should
1684 * always have volume_factor as soft_volume, so no change
1685 * should be needed) */
1686
1687 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1688 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1689
1690 /* Notifications will be sent by pa_sink_set_volume(). */
1691
1692 } else {
1693 /* Ok, so the origin sink uses volume sharing, and flat volume is
1694 * disabled. The volume will have to be updated as follows:
1695 *
1696 * i->volume := 0 dB
1697 * i->reference_ratio := 0 dB
1698 * i->real_ratio stays unchanged
1699 * (streams whose origin sink uses volume sharing should
1700 * always have real_ratio of 0 dB)
1701 * i->soft_volume stays unchanged
1702 * (streams whose origin sink uses volume sharing should
1703 * always have volume_factor as soft_volume, so no change
1704 * should be needed) */
1705
1706 old_volume = i->volume;
1707 pa_cvolume_reset(&i->volume, i->volume.channels);
1708 pa_cvolume_reset(&i->reference_ratio, i->reference_ratio.channels);
1709 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1710 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1711
1712 /* Notify others about the changed sink input volume. */
1713 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1714 if (i->volume_changed)
1715 i->volume_changed(i);
1716
1717 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1718 }
1719 }
1720
1721 /* Additionally, the origin sink volume needs updating:
1722 *
1723 * i->origin_sink->reference_volume := root_sink->reference_volume
1724 * i->origin_sink->real_volume := root_sink->real_volume
1725 * i->origin_sink->soft_volume stays unchanged
1726 * (sinks that use volume sharing should always have
1727 * soft_volume of 0 dB) */
1728
1729 old_volume = i->origin_sink->reference_volume;
1730
1731 i->origin_sink->reference_volume = root_sink->reference_volume;
1732 pa_cvolume_remap(&i->origin_sink->reference_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1733
1734 i->origin_sink->real_volume = root_sink->real_volume;
1735 pa_cvolume_remap(&i->origin_sink->real_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1736
1737 pa_assert(pa_cvolume_is_norm(&i->origin_sink->soft_volume));
1738
1739 /* Notify others about the changed sink volume. If you wonder whether
1740 * i->origin_sink->set_volume() should be called somewhere, that's not
1741 * the case, because sinks that use volume sharing shouldn't have any
1742 * internal volume that set_volume() would update. If you wonder
1743 * whether the thread_info variables should be synced, yes, they
1744 * should, and it's done by the PA_SINK_MESSAGE_FINISH_MOVE message
1745 * handler. */
1746 if (!pa_cvolume_equal(&i->origin_sink->reference_volume, &old_volume))
1747 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, i->origin_sink->index);
1748
1749 /* Recursively update origin sink inputs. */
1750 PA_IDXSET_FOREACH(origin_sink_input, i->origin_sink->inputs, idx)
1751 update_volume_due_to_moving(origin_sink_input, dest);
1752
1753 } else {
1754 old_volume = i->volume;
1755
1756 if (pa_sink_flat_volume_enabled(i->sink)) {
1757 /* Ok, so this is a regular stream, and flat volume is enabled. The
1758 * volume will have to be updated as follows:
1759 *
1760 * i->volume := i->reference_ratio * i->sink->reference_volume
1761 * i->reference_ratio stays unchanged
1762 * i->real_ratio := i->volume / i->sink->real_volume
1763 * (handled later by pa_sink_set_volume)
1764 * i->soft_volume := i->real_ratio * i->volume_factor
1765 * (handled later by pa_sink_set_volume) */
1766
1767 i->volume = i->sink->reference_volume;
1768 pa_cvolume_remap(&i->volume, &i->sink->channel_map, &i->channel_map);
1769 pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1770
1771 } else {
1772 /* Ok, so this is a regular stream, and flat volume is disabled.
1773 * The volume will have to be updated as follows:
1774 *
1775 * i->volume := i->reference_ratio
1776 * i->reference_ratio stays unchanged
1777 * i->real_ratio := i->reference_ratio
1778 * i->soft_volume := i->real_ratio * i->volume_factor */
1779
1780 i->volume = i->reference_ratio;
1781 i->real_ratio = i->reference_ratio;
1782 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1783 }
1784
1785 /* Notify others about the changed sink input volume. */
1786 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1787 /* XXX: In case i->sink has flat volume enabled, then real_ratio
1788 * and soft_volume are not updated yet. Let's hope that the
1789 * callback implementation doesn't care about those variables... */
1790 if (i->volume_changed)
1791 i->volume_changed(i);
1792
1793 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1794 }
1795 }
1796
1797 /* If i->sink == dest, then recursion has finished, and we can finally call
1798 * pa_sink_set_volume(), which will do the rest of the updates. */
1799 if ((i->sink == dest) && pa_sink_flat_volume_enabled(i->sink))
1800 pa_sink_set_volume(i->sink, NULL, false, i->save_volume);
1801 }
1802
1803 /* Called from main context */
1804 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, bool save) {
1805 struct volume_factor_entry *v;
1806 void *state = NULL;
1807
1808 pa_sink_input_assert_ref(i);
1809 pa_assert_ctl_context();
1810 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1811 pa_assert(!i->sink);
1812 pa_sink_assert_ref(dest);
1813
1814 if (!pa_sink_input_may_move_to(i, dest))
1815 return -PA_ERR_NOTSUPPORTED;
1816
1817 if (pa_sink_input_is_passthrough(i) && !pa_sink_check_format(dest, i->format)) {
1818 pa_proplist *p = pa_proplist_new();
1819 pa_log_debug("New sink doesn't support stream format, sending format-changed and killing");
1820 /* Tell the client what device we want to be on if it is going to
1821 * reconnect */
1822 pa_proplist_sets(p, "device", dest->name);
1823 pa_sink_input_send_event(i, PA_STREAM_EVENT_FORMAT_LOST, p);
1824 pa_proplist_free(p);
1825 return -PA_ERR_NOTSUPPORTED;
1826 }
1827
1828 if (!(i->flags & PA_SINK_INPUT_VARIABLE_RATE) &&
1829 !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec)) {
1830 /* try to change dest sink rate if possible without glitches.
1831 module-suspend-on-idle resumes destination sink with
1832 SINK_INPUT_MOVE_FINISH hook */
1833
1834 pa_log_info("Trying to change sample rate");
1835 if (pa_sink_update_rate(dest, i->sample_spec.rate, pa_sink_input_is_passthrough(i)) >= 0)
1836 pa_log_info("Rate changed to %u Hz", dest->sample_spec.rate);
1837 }
1838
1839 if (i->moving)
1840 i->moving(i, dest);
1841
1842 i->sink = dest;
1843 i->save_sink = save;
1844 pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1845
1846 PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state)
1847 pa_cvolume_remap(&v->volume, &i->channel_map, &i->sink->channel_map);
1848
1849 pa_cvolume_remap(&i->volume_factor_sink, &i->channel_map, &i->sink->channel_map);
1850
1851 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1852 i->sink->n_corked++;
1853
1854 pa_sink_input_update_rate(i);
1855
1856 pa_sink_update_status(dest);
1857
1858 update_volume_due_to_moving(i, dest);
1859
1860 if (pa_sink_input_is_passthrough(i))
1861 pa_sink_enter_passthrough(i->sink);
1862
1863 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1864
1865 pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1866
1867 /* Notify everyone */
1868 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1869 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1870
1871 return 0;
1872 }
1873
1874 /* Called from main context */
1875 void pa_sink_input_fail_move(pa_sink_input *i) {
1876
1877 pa_sink_input_assert_ref(i);
1878 pa_assert_ctl_context();
1879 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1880 pa_assert(!i->sink);
1881
1882 /* Check if someone wants this sink input? */
1883 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1884 return;
1885
1886 if (i->moving)
1887 i->moving(i, NULL);
1888
1889 pa_sink_input_kill(i);
1890 }
1891
1892 /* Called from main context */
1893 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, bool save) {
1894 int r;
1895
1896 pa_sink_input_assert_ref(i);
1897 pa_assert_ctl_context();
1898 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1899 pa_assert(i->sink);
1900 pa_sink_assert_ref(dest);
1901
1902 if (dest == i->sink)
1903 return 0;
1904
1905 if (!pa_sink_input_may_move_to(i, dest))
1906 return -PA_ERR_NOTSUPPORTED;
1907
1908 pa_sink_input_ref(i);
1909
1910 if ((r = pa_sink_input_start_move(i)) < 0) {
1911 pa_sink_input_unref(i);
1912 return r;
1913 }
1914
1915 if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1916 pa_sink_input_fail_move(i);
1917 pa_sink_input_unref(i);
1918 return r;
1919 }
1920
1921 pa_sink_input_unref(i);
1922
1923 return 0;
1924 }
1925
1926 /* Called from IO thread context */
1927 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1928 bool corking, uncorking;
1929
1930 pa_sink_input_assert_ref(i);
1931 pa_sink_input_assert_io_context(i);
1932
1933 if (state == i->thread_info.state)
1934 return;
1935
1936 if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1937 !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1938 pa_atomic_store(&i->thread_info.drained, 1);
1939
1940 corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1941 uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1942
1943 if (i->state_change)
1944 i->state_change(i, state);
1945
1946 if (corking) {
1947
1948 pa_log_debug("Requesting rewind due to corking");
1949
1950 /* This will tell the implementing sink input driver to rewind
1951 * so that the unplayed already mixed data is not lost */
1952 pa_sink_input_request_rewind(i, 0, true, true, false);
1953
1954 /* Set the corked state *after* requesting rewind */
1955 i->thread_info.state = state;
1956
1957 } else if (uncorking) {
1958
1959 pa_log_debug("Requesting rewind due to uncorking");
1960
1961 i->thread_info.underrun_for = (uint64_t) -1;
1962 i->thread_info.underrun_for_sink = 0;
1963 i->thread_info.playing_for = 0;
1964
1965 /* Set the uncorked state *before* requesting rewind */
1966 i->thread_info.state = state;
1967
1968 /* OK, we're being uncorked. Make sure we're not rewound when
1969 * the hw buffer is remixed and request a remix. */
1970 pa_sink_input_request_rewind(i, 0, false, true, true);
1971 } else
1972 /* We may not be corking or uncorking, but we still need to set the state. */
1973 i->thread_info.state = state;
1974 }
1975
1976 /* Called from thread context, except when it is not. */
1977 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1978 pa_sink_input *i = PA_SINK_INPUT(o);
1979 pa_sink_input_assert_ref(i);
1980
1981 switch (code) {
1982
1983 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1984 if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1985 i->thread_info.soft_volume = i->soft_volume;
1986 pa_sink_input_request_rewind(i, 0, true, false, false);
1987 }
1988 return 0;
1989
1990 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1991 if (i->thread_info.muted != i->muted) {
1992 i->thread_info.muted = i->muted;
1993 pa_sink_input_request_rewind(i, 0, true, false, false);
1994 }
1995 return 0;
1996
1997 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1998 pa_usec_t *r = userdata;
1999
2000 r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
2001 r[1] += pa_sink_get_latency_within_thread(i->sink);
2002
2003 return 0;
2004 }
2005
2006 case PA_SINK_INPUT_MESSAGE_SET_RATE:
2007
2008 i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
2009 pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
2010
2011 return 0;
2012
2013 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
2014 pa_sink_input *ssync;
2015
2016 pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
2017
2018 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
2019 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
2020
2021 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
2022 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
2023
2024 return 0;
2025 }
2026
2027 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
2028 pa_usec_t *usec = userdata;
2029
2030 *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
2031 return 0;
2032 }
2033
2034 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
2035 pa_usec_t *r = userdata;
2036
2037 *r = i->thread_info.requested_sink_latency;
2038 return 0;
2039 }
2040 }
2041
2042 return -PA_ERR_NOTIMPLEMENTED;
2043 }
2044
2045 /* Called from main thread */
2046 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
2047 pa_sink_input_assert_ref(i);
2048 pa_assert_ctl_context();
2049
2050 if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
2051 return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
2052
2053 return i->state;
2054 }
2055
2056 /* Called from IO context */
2057 bool pa_sink_input_safe_to_remove(pa_sink_input *i) {
2058 pa_sink_input_assert_ref(i);
2059 pa_sink_input_assert_io_context(i);
2060
2061 if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
2062 return pa_memblockq_is_empty(i->thread_info.render_memblockq);
2063
2064 return true;
2065 }
2066
2067 /* Called from IO context */
2068 void pa_sink_input_request_rewind(
2069 pa_sink_input *i,
2070 size_t nbytes /* in our sample spec */,
2071 bool rewrite,
2072 bool flush,
2073 bool dont_rewind_render) {
2074
2075 size_t lbq;
2076
2077 /* If 'rewrite' is true the sink is rewound as far as requested
2078 * and possible and the exact value of this is passed back the
2079 * implementor via process_rewind(). If 'flush' is also true all
2080 * already rendered data is also dropped.
2081 *
2082 * If 'rewrite' is false the sink is rewound as far as requested
2083 * and possible and the already rendered data is dropped so that
2084 * in the next iteration we read new data from the
2085 * implementor. This implies 'flush' is true. If
2086 * dont_rewind_render is true then the render memblockq is not
2087 * rewound. */
2088
2089 /* nbytes = 0 means maximum rewind request */
2090
2091 pa_sink_input_assert_ref(i);
2092 pa_sink_input_assert_io_context(i);
2093 pa_assert(rewrite || flush);
2094 pa_assert(!dont_rewind_render || !rewrite);
2095
2096 /* We don't take rewind requests while we are corked */
2097 if (i->thread_info.state == PA_SINK_INPUT_CORKED)
2098 return;
2099
2100 nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
2101
2102 #ifdef SINK_INPUT_DEBUG
2103 pa_log_debug("request rewrite %zu", nbytes);
2104 #endif
2105
2106 /* Calculate how much we can rewind locally without having to
2107 * touch the sink */
2108 if (rewrite)
2109 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
2110 else
2111 lbq = 0;
2112
2113 /* Check if rewinding for the maximum is requested, and if so, fix up */
2114 if (nbytes <= 0) {
2115
2116 /* Calculate maximum number of bytes that could be rewound in theory */
2117 nbytes = i->sink->thread_info.max_rewind + lbq;
2118
2119 /* Transform from sink domain */
2120 if (i->thread_info.resampler)
2121 nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
2122 }
2123
2124 /* Remember how much we actually want to rewrite */
2125 if (i->thread_info.rewrite_nbytes != (size_t) -1) {
2126 if (rewrite) {
2127 /* Make sure to not overwrite over underruns */
2128 if (nbytes > i->thread_info.playing_for)
2129 nbytes = (size_t) i->thread_info.playing_for;
2130
2131 i->thread_info.rewrite_nbytes = nbytes;
2132 } else
2133 i->thread_info.rewrite_nbytes = (size_t) -1;
2134 }
2135
2136 i->thread_info.rewrite_flush =
2137 i->thread_info.rewrite_flush || flush;
2138
2139 i->thread_info.dont_rewind_render =
2140 i->thread_info.dont_rewind_render ||
2141 dont_rewind_render;
2142
2143 /* nbytes is -1 if some earlier rewind request had rewrite == false. */
2144 if (nbytes != (size_t) -1) {
2145
2146 /* Transform to sink domain */
2147 if (i->thread_info.resampler)
2148 nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
2149
2150 if (nbytes > lbq)
2151 pa_sink_request_rewind(i->sink, nbytes - lbq);
2152 else
2153 /* This call will make sure process_rewind() is called later */
2154 pa_sink_request_rewind(i->sink, 0);
2155 }
2156 }
2157
2158 /* Called from main context */
2159 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
2160 pa_sink_input_assert_ref(i);
2161 pa_assert_ctl_context();
2162 pa_assert(ret);
2163
2164 /* FIXME: Shouldn't access resampler object from main context! */
2165
2166 pa_silence_memchunk_get(
2167 &i->core->silence_cache,
2168 i->core->mempool,
2169 ret,
2170 &i->sample_spec,
2171 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
2172
2173 return ret;
2174 }
2175
2176 /* Called from main context */
2177 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
2178 pa_proplist *pl = NULL;
2179 pa_sink_input_send_event_hook_data hook_data;
2180
2181 pa_sink_input_assert_ref(i);
2182 pa_assert_ctl_context();
2183 pa_assert(event);
2184
2185 if (!i->send_event)
2186 return;
2187
2188 if (!data)
2189 data = pl = pa_proplist_new();
2190
2191 hook_data.sink_input = i;
2192 hook_data.data = data;
2193 hook_data.event = event;
2194
2195 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
2196 goto finish;
2197
2198 i->send_event(i, event, data);
2199
2200 finish:
2201 if (pl)
2202 pa_proplist_free(pl);
2203 }
2204
2205 /* Called from main context */
2206 /* Updates the sink input's resampler with whatever the current sink requires
2207 * -- useful when the underlying sink's rate might have changed */
2208 int pa_sink_input_update_rate(pa_sink_input *i) {
2209 pa_resampler *new_resampler;
2210 char *memblockq_name;
2211
2212 pa_sink_input_assert_ref(i);
2213 pa_assert_ctl_context();
2214
2215 if (i->thread_info.resampler &&
2216 pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &i->sink->sample_spec) &&
2217 pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &i->sink->channel_map))
2218
2219 new_resampler = i->thread_info.resampler;
2220
2221 else if (!pa_sink_input_is_passthrough(i) &&
2222 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
2223 !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec) ||
2224 !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map))) {
2225
2226 new_resampler = pa_resampler_new(i->core->mempool,
2227 &i->sample_spec, &i->channel_map,
2228 &i->sink->sample_spec, &i->sink->channel_map,
2229 i->requested_resample_method,
2230 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
2231 ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
2232 (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0));
2233
2234 if (!new_resampler) {
2235 pa_log_warn("Unsupported resampling operation.");
2236 return -PA_ERR_NOTSUPPORTED;
2237 }
2238 } else
2239 new_resampler = NULL;
2240
2241 if (new_resampler == i->thread_info.resampler)
2242 return 0;
2243
2244 if (i->thread_info.resampler)
2245 pa_resampler_free(i->thread_info.resampler);
2246
2247 i->thread_info.resampler = new_resampler;
2248
2249 pa_memblockq_free(i->thread_info.render_memblockq);
2250
2251 memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
2252 i->thread_info.render_memblockq = pa_memblockq_new(
2253 memblockq_name,
2254 0,
2255 MEMBLOCKQ_MAXLENGTH,
2256 0,
2257 &i->sink->sample_spec,
2258 0,
2259 1,
2260 0,
2261 &i->sink->silence);
2262 pa_xfree(memblockq_name);
2263
2264 i->actual_resample_method = new_resampler ? pa_resampler_get_method(new_resampler) : PA_RESAMPLER_INVALID;
2265
2266 pa_log_debug("Updated resampler for sink input %d", i->index);
2267
2268 return 0;
2269 }