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