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