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