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