]> code.delx.au - pulseaudio/blob - src/pulsecore/sink-input.c
delx.au / code / pulseaudio / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
sink-input: Log format negotiation better
[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(pa_bool_t 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 pa_bool_t 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, pa_bool_t mute) {
175 pa_assert(data);
176
177 data->muted_is_set = TRUE;
178 data->muted = !!mute;
179 }
180
181 pa_bool_t pa_sink_input_new_data_set_sink(pa_sink_input_new_data *data, pa_sink *s, pa_bool_t save) {
182 pa_bool_t 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 pa_bool_t 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)) == TRUE)
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 pa_bool_t 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 pa_bool_t do_volume_adj_here, need_volume_factor_sink;
857 pa_bool_t 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 pa_bool_t 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
1067 /* Called from thread context */
1068 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
1069 size_t lbq;
1070 pa_bool_t called = FALSE;
1071
1072 pa_sink_input_assert_ref(i);
1073 pa_sink_input_assert_io_context(i);
1074 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1075 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1076
1077 #ifdef SINK_INPUT_DEBUG
1078 pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes);
1079 #endif
1080
1081 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1082
1083 if (nbytes > 0 && !i->thread_info.dont_rewind_render) {
1084 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes);
1085 pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes);
1086 }
1087
1088 if (i->thread_info.rewrite_nbytes == (size_t) -1) {
1089
1090 /* We were asked to drop all buffered data, and rerequest new
1091 * data from implementor the next time peek() is called */
1092
1093 pa_memblockq_flush_write(i->thread_info.render_memblockq, TRUE);
1094
1095 } else if (i->thread_info.rewrite_nbytes > 0) {
1096 size_t max_rewrite, amount;
1097
1098 /* Calculate how much make sense to rewrite at most */
1099 max_rewrite = nbytes + lbq;
1100
1101 /* Transform into local domain */
1102 if (i->thread_info.resampler)
1103 max_rewrite = pa_resampler_request(i->thread_info.resampler, max_rewrite);
1104
1105 /* Calculate how much of the rewinded data should actually be rewritten */
1106 amount = PA_MIN(i->thread_info.rewrite_nbytes, max_rewrite);
1107
1108 if (amount > 0) {
1109 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount);
1110
1111 /* Tell the implementor */
1112 if (i->process_rewind)
1113 i->process_rewind(i, amount);
1114 called = TRUE;
1115
1116 /* Convert back to to sink domain */
1117 if (i->thread_info.resampler)
1118 amount = pa_resampler_result(i->thread_info.resampler, amount);
1119
1120 if (amount > 0)
1121 /* Ok, now update the write pointer */
1122 pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) amount), PA_SEEK_RELATIVE, TRUE);
1123
1124 if (i->thread_info.rewrite_flush)
1125 pa_memblockq_silence(i->thread_info.render_memblockq);
1126
1127 /* And reset the resampler */
1128 if (i->thread_info.resampler)
1129 pa_resampler_reset(i->thread_info.resampler);
1130 }
1131 }
1132
1133 if (!called)
1134 if (i->process_rewind)
1135 i->process_rewind(i, 0);
1136
1137 i->thread_info.rewrite_nbytes = 0;
1138 i->thread_info.rewrite_flush = FALSE;
1139 i->thread_info.dont_rewind_render = FALSE;
1140 }
1141
1142 /* Called from thread context */
1143 size_t pa_sink_input_get_max_rewind(pa_sink_input *i) {
1144 pa_sink_input_assert_ref(i);
1145 pa_sink_input_assert_io_context(i);
1146
1147 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_rewind) : i->sink->thread_info.max_rewind;
1148 }
1149
1150 /* Called from thread context */
1151 size_t pa_sink_input_get_max_request(pa_sink_input *i) {
1152 pa_sink_input_assert_ref(i);
1153 pa_sink_input_assert_io_context(i);
1154
1155 /* We're not verifying the status here, to allow this to be called
1156 * in the state change handler between _INIT and _RUNNING */
1157
1158 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_request) : i->sink->thread_info.max_request;
1159 }
1160
1161 /* Called from thread context */
1162 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1163 pa_sink_input_assert_ref(i);
1164 pa_sink_input_assert_io_context(i);
1165 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1166 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1167
1168 pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes);
1169
1170 if (i->update_max_rewind)
1171 i->update_max_rewind(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1172 }
1173
1174 /* Called from thread context */
1175 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1176 pa_sink_input_assert_ref(i);
1177 pa_sink_input_assert_io_context(i);
1178 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1179 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1180
1181 if (i->update_max_request)
1182 i->update_max_request(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1183 }
1184
1185 /* Called from thread context */
1186 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) {
1187 pa_sink_input_assert_ref(i);
1188 pa_sink_input_assert_io_context(i);
1189
1190 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1191 usec = i->sink->thread_info.fixed_latency;
1192
1193 if (usec != (pa_usec_t) -1)
1194 usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
1195
1196 i->thread_info.requested_sink_latency = usec;
1197 pa_sink_invalidate_requested_latency(i->sink, TRUE);
1198
1199 return usec;
1200 }
1201
1202 /* Called from main context */
1203 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) {
1204 pa_sink_input_assert_ref(i);
1205 pa_assert_ctl_context();
1206
1207 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1208 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1209 return usec;
1210 }
1211
1212 /* If this sink input is not realized yet or we are being moved,
1213 * we have to touch the thread info data directly */
1214
1215 if (i->sink) {
1216 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1217 usec = pa_sink_get_fixed_latency(i->sink);
1218
1219 if (usec != (pa_usec_t) -1) {
1220 pa_usec_t min_latency, max_latency;
1221 pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
1222 usec = PA_CLAMP(usec, min_latency, max_latency);
1223 }
1224 }
1225
1226 i->thread_info.requested_sink_latency = usec;
1227
1228 return usec;
1229 }
1230
1231 /* Called from main context */
1232 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
1233 pa_sink_input_assert_ref(i);
1234 pa_assert_ctl_context();
1235
1236 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1237 pa_usec_t usec = 0;
1238 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1239 return usec;
1240 }
1241
1242 /* If this sink input is not realized yet or we are being moved,
1243 * we have to touch the thread info data directly */
1244
1245 return i->thread_info.requested_sink_latency;
1246 }
1247
1248 /* Called from main context */
1249 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, pa_bool_t save, pa_bool_t absolute) {
1250 pa_cvolume v;
1251
1252 pa_sink_input_assert_ref(i);
1253 pa_assert_ctl_context();
1254 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1255 pa_assert(volume);
1256 pa_assert(pa_cvolume_valid(volume));
1257 pa_assert(volume->channels == 1 || pa_cvolume_compatible(volume, &i->sample_spec));
1258 pa_assert(i->volume_writable);
1259
1260 if (!absolute && pa_sink_flat_volume_enabled(i->sink)) {
1261 v = i->sink->reference_volume;
1262 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
1263
1264 if (pa_cvolume_compatible(volume, &i->sample_spec))
1265 volume = pa_sw_cvolume_multiply(&v, &v, volume);
1266 else
1267 volume = pa_sw_cvolume_multiply_scalar(&v, &v, pa_cvolume_max(volume));
1268 } else {
1269 if (!pa_cvolume_compatible(volume, &i->sample_spec)) {
1270 v = i->volume;
1271 volume = pa_cvolume_scale(&v, pa_cvolume_max(volume));
1272 }
1273 }
1274
1275 if (pa_cvolume_equal(volume, &i->volume)) {
1276 i->save_volume = i->save_volume || save;
1277 return;
1278 }
1279
1280 i->volume = *volume;
1281 i->save_volume = save;
1282
1283 if (pa_sink_flat_volume_enabled(i->sink)) {
1284 /* We are in flat volume mode, so let's update all sink input
1285 * volumes and update the flat volume of the sink */
1286
1287 pa_sink_set_volume(i->sink, NULL, TRUE, save);
1288
1289 } else {
1290 /* OK, we are in normal volume mode. The volume only affects
1291 * ourselves */
1292 set_real_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 void pa_sink_input_remove_volume_factor(pa_sink_input *i, const char *key) {
1334 struct volume_factor_entry *v;
1335
1336 pa_sink_input_assert_ref(i);
1337 pa_assert(key);
1338 pa_assert_ctl_context();
1339 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1340
1341 pa_assert_se(v = pa_hashmap_remove(i->volume_factor_items, key));
1342 volume_factor_entry_free(v);
1343
1344 switch (pa_hashmap_size(i->volume_factor_items)) {
1345 case 0:
1346 pa_cvolume_reset(&i->volume_factor, i->sample_spec.channels);
1347 break;
1348 case 1:
1349 v = pa_hashmap_first(i->volume_factor_items);
1350 i->volume_factor = v->volume;
1351 break;
1352 default:
1353 volume_factor_from_hashmap(&i->volume_factor, i->volume_factor_items, i->volume_factor.channels);
1354 }
1355
1356 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1357
1358 /* Copy the new soft_volume to the thread_info struct */
1359 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1360 }
1361
1362 /* Called from main context */
1363 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
1364 pa_sink_input_assert_ref(i);
1365 pa_assert_ctl_context();
1366 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1367 pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
1368
1369 /* This basically calculates:
1370 *
1371 * i->real_ratio := v
1372 * i->soft_volume := i->real_ratio * i->volume_factor */
1373
1374 if (v)
1375 i->real_ratio = *v;
1376 else
1377 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
1378
1379 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1380 /* We don't copy the data to the thread_info data. That's left for someone else to do */
1381 }
1382
1383 /* Called from main or I/O context */
1384 pa_bool_t pa_sink_input_is_passthrough(pa_sink_input *i) {
1385 pa_sink_input_assert_ref(i);
1386
1387 if (PA_UNLIKELY(!pa_format_info_is_pcm(i->format)))
1388 return TRUE;
1389
1390 if (PA_UNLIKELY(i->flags & PA_SINK_INPUT_PASSTHROUGH))
1391 return TRUE;
1392
1393 return FALSE;
1394 }
1395
1396 /* Called from main context */
1397 pa_bool_t pa_sink_input_is_volume_readable(pa_sink_input *i) {
1398 pa_sink_input_assert_ref(i);
1399 pa_assert_ctl_context();
1400
1401 return !pa_sink_input_is_passthrough(i);
1402 }
1403
1404 /* Called from main context */
1405 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, pa_bool_t absolute) {
1406 pa_sink_input_assert_ref(i);
1407 pa_assert_ctl_context();
1408 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1409 pa_assert(pa_sink_input_is_volume_readable(i));
1410
1411 if (absolute || !pa_sink_flat_volume_enabled(i->sink))
1412 *volume = i->volume;
1413 else
1414 *volume = i->reference_ratio;
1415
1416 return volume;
1417 }
1418
1419 /* Called from main context */
1420 void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute, pa_bool_t save) {
1421 pa_sink_input_assert_ref(i);
1422 pa_assert_ctl_context();
1423 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1424
1425 if (!i->muted == !mute) {
1426 i->save_muted = i->save_muted || mute;
1427 return;
1428 }
1429
1430 i->muted = mute;
1431 i->save_muted = save;
1432
1433 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1434
1435 /* The mute status changed, let's tell people so */
1436 if (i->mute_changed)
1437 i->mute_changed(i);
1438
1439 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1440 }
1441
1442 /* Called from main context */
1443 pa_bool_t pa_sink_input_get_mute(pa_sink_input *i) {
1444 pa_sink_input_assert_ref(i);
1445 pa_assert_ctl_context();
1446 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1447
1448 return i->muted;
1449 }
1450
1451 /* Called from main thread */
1452 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1453 pa_sink_input_assert_ref(i);
1454 pa_assert_ctl_context();
1455
1456 if (p)
1457 pa_proplist_update(i->proplist, mode, p);
1458
1459 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1460 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1461 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1462 }
1463 }
1464
1465 /* Called from main context */
1466 void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b) {
1467 pa_sink_input_assert_ref(i);
1468 pa_assert_ctl_context();
1469 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1470
1471 sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1472 }
1473
1474 /* Called from main context */
1475 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1476 pa_sink_input_assert_ref(i);
1477 pa_assert_ctl_context();
1478 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1479 pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1480
1481 if (i->sample_spec.rate == rate)
1482 return 0;
1483
1484 i->sample_spec.rate = rate;
1485
1486 pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1487
1488 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1489 return 0;
1490 }
1491
1492 /* Called from main context */
1493 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1494 const char *old;
1495 pa_sink_input_assert_ref(i);
1496 pa_assert_ctl_context();
1497
1498 if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1499 return;
1500
1501 old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1502
1503 if (old && name && pa_streq(old, name))
1504 return;
1505
1506 if (name)
1507 pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1508 else
1509 pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1510
1511 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1512 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1513 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1514 }
1515 }
1516
1517 /* Called from main context */
1518 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1519 pa_sink_input_assert_ref(i);
1520 pa_assert_ctl_context();
1521
1522 return i->actual_resample_method;
1523 }
1524
1525 /* Called from main context */
1526 pa_bool_t pa_sink_input_may_move(pa_sink_input *i) {
1527 pa_sink_input_assert_ref(i);
1528 pa_assert_ctl_context();
1529 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1530
1531 if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1532 return FALSE;
1533
1534 if (i->sync_next || i->sync_prev) {
1535 pa_log_warn("Moving synchronized streams not supported.");
1536 return FALSE;
1537 }
1538
1539 return TRUE;
1540 }
1541
1542 static pa_bool_t find_filter_sink_input(pa_sink_input *target, pa_sink *s) {
1543 int i = 0;
1544 while (s && s->input_to_master) {
1545 if (s->input_to_master == target)
1546 return TRUE;
1547 s = s->input_to_master->sink;
1548 pa_assert(i++ < 100);
1549 }
1550 return FALSE;
1551 }
1552
1553 /* Called from main context */
1554 pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1555 pa_sink_input_assert_ref(i);
1556 pa_assert_ctl_context();
1557 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1558 pa_sink_assert_ref(dest);
1559
1560 if (dest == i->sink)
1561 return TRUE;
1562
1563 if (!pa_sink_input_may_move(i))
1564 return FALSE;
1565
1566 /* Make sure we're not creating a filter sink cycle */
1567 if (find_filter_sink_input(i, dest)) {
1568 pa_log_debug("Can't connect input to %s, as that would create a cycle.", dest->name);
1569 return FALSE;
1570 }
1571
1572 if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1573 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1574 return FALSE;
1575 }
1576
1577 if (check_passthrough_connection(pa_sink_input_is_passthrough(i), dest) < 0)
1578 return FALSE;
1579
1580 if (i->may_move_to)
1581 if (!i->may_move_to(i, dest))
1582 return FALSE;
1583
1584 return TRUE;
1585 }
1586
1587 /* Called from main context */
1588 int pa_sink_input_start_move(pa_sink_input *i) {
1589 pa_source_output *o, *p = NULL;
1590 struct volume_factor_entry *v;
1591 void *state = NULL;
1592 int r;
1593
1594 pa_sink_input_assert_ref(i);
1595 pa_assert_ctl_context();
1596 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1597 pa_assert(i->sink);
1598
1599 if (!pa_sink_input_may_move(i))
1600 return -PA_ERR_NOTSUPPORTED;
1601
1602 if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1603 return r;
1604
1605 /* Kill directly connected outputs */
1606 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1607 pa_assert(o != p);
1608 pa_source_output_kill(o);
1609 p = o;
1610 }
1611 pa_assert(pa_idxset_isempty(i->direct_outputs));
1612
1613 pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1614
1615 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1616 pa_assert_se(i->sink->n_corked-- >= 1);
1617
1618 if (pa_sink_input_is_passthrough(i))
1619 pa_sink_leave_passthrough(i->sink);
1620
1621 if (pa_sink_flat_volume_enabled(i->sink))
1622 /* We might need to update the sink's volume if we are in flat
1623 * volume mode. */
1624 pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
1625
1626 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1627
1628 pa_sink_update_status(i->sink);
1629
1630 PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state)
1631 pa_cvolume_remap(&v->volume, &i->sink->channel_map, &i->channel_map);
1632
1633 pa_cvolume_remap(&i->volume_factor_sink, &i->sink->channel_map, &i->channel_map);
1634
1635 i->sink = NULL;
1636
1637 pa_sink_input_unref(i);
1638
1639 return 0;
1640 }
1641
1642 /* Called from main context. If i has an origin sink that uses volume sharing,
1643 * then also the origin sink and all streams connected to it need to update
1644 * their volume - this function does all that by using recursion. */
1645 static void update_volume_due_to_moving(pa_sink_input *i, pa_sink *dest) {
1646 pa_cvolume old_volume;
1647
1648 pa_assert(i);
1649 pa_assert(dest);
1650 pa_assert(i->sink); /* The destination sink should already be set. */
1651
1652 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1653 pa_sink *root_sink = pa_sink_get_master(i->sink);
1654 pa_sink_input *origin_sink_input;
1655 uint32_t idx;
1656
1657 if (PA_UNLIKELY(!root_sink))
1658 return;
1659
1660 if (pa_sink_flat_volume_enabled(i->sink)) {
1661 /* Ok, so the origin sink uses volume sharing, and flat volume is
1662 * enabled. The volume will have to be updated as follows:
1663 *
1664 * i->volume := i->sink->real_volume
1665 * (handled later by pa_sink_set_volume)
1666 * i->reference_ratio := i->volume / i->sink->reference_volume
1667 * (handled later by pa_sink_set_volume)
1668 * i->real_ratio stays unchanged
1669 * (streams whose origin sink uses volume sharing should
1670 * always have real_ratio of 0 dB)
1671 * i->soft_volume stays unchanged
1672 * (streams whose origin sink uses volume sharing should
1673 * always have volume_factor as soft_volume, so no change
1674 * should be needed) */
1675
1676 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1677 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1678
1679 /* Notifications will be sent by pa_sink_set_volume(). */
1680
1681 } else {
1682 /* Ok, so the origin sink uses volume sharing, and flat volume is
1683 * disabled. The volume will have to be updated as follows:
1684 *
1685 * i->volume := 0 dB
1686 * i->reference_ratio := 0 dB
1687 * i->real_ratio stays unchanged
1688 * (streams whose origin sink uses volume sharing should
1689 * always have real_ratio of 0 dB)
1690 * i->soft_volume stays unchanged
1691 * (streams whose origin sink uses volume sharing should
1692 * always have volume_factor as soft_volume, so no change
1693 * should be needed) */
1694
1695 old_volume = i->volume;
1696 pa_cvolume_reset(&i->volume, i->volume.channels);
1697 pa_cvolume_reset(&i->reference_ratio, i->reference_ratio.channels);
1698 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1699 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1700
1701 /* Notify others about the changed sink input volume. */
1702 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1703 if (i->volume_changed)
1704 i->volume_changed(i);
1705
1706 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1707 }
1708 }
1709
1710 /* Additionally, the origin sink volume needs updating:
1711 *
1712 * i->origin_sink->reference_volume := root_sink->reference_volume
1713 * i->origin_sink->real_volume := root_sink->real_volume
1714 * i->origin_sink->soft_volume stays unchanged
1715 * (sinks that use volume sharing should always have
1716 * soft_volume of 0 dB) */
1717
1718 old_volume = i->origin_sink->reference_volume;
1719
1720 i->origin_sink->reference_volume = root_sink->reference_volume;
1721 pa_cvolume_remap(&i->origin_sink->reference_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1722
1723 i->origin_sink->real_volume = root_sink->real_volume;
1724 pa_cvolume_remap(&i->origin_sink->real_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1725
1726 pa_assert(pa_cvolume_is_norm(&i->origin_sink->soft_volume));
1727
1728 /* Notify others about the changed sink volume. If you wonder whether
1729 * i->origin_sink->set_volume() should be called somewhere, that's not
1730 * the case, because sinks that use volume sharing shouldn't have any
1731 * internal volume that set_volume() would update. If you wonder
1732 * whether the thread_info variables should be synced, yes, they
1733 * should, and it's done by the PA_SINK_MESSAGE_FINISH_MOVE message
1734 * handler. */
1735 if (!pa_cvolume_equal(&i->origin_sink->reference_volume, &old_volume))
1736 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, i->origin_sink->index);
1737
1738 /* Recursively update origin sink inputs. */
1739 PA_IDXSET_FOREACH(origin_sink_input, i->origin_sink->inputs, idx)
1740 update_volume_due_to_moving(origin_sink_input, dest);
1741
1742 } else {
1743 old_volume = i->volume;
1744
1745 if (pa_sink_flat_volume_enabled(i->sink)) {
1746 /* Ok, so this is a regular stream, and flat volume is enabled. The
1747 * volume will have to be updated as follows:
1748 *
1749 * i->volume := i->reference_ratio * i->sink->reference_volume
1750 * i->reference_ratio stays unchanged
1751 * i->real_ratio := i->volume / i->sink->real_volume
1752 * (handled later by pa_sink_set_volume)
1753 * i->soft_volume := i->real_ratio * i->volume_factor
1754 * (handled later by pa_sink_set_volume) */
1755
1756 i->volume = i->sink->reference_volume;
1757 pa_cvolume_remap(&i->volume, &i->sink->channel_map, &i->channel_map);
1758 pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1759
1760 } else {
1761 /* Ok, so this is a regular stream, and flat volume is disabled.
1762 * The volume will have to be updated as follows:
1763 *
1764 * i->volume := i->reference_ratio
1765 * i->reference_ratio stays unchanged
1766 * i->real_ratio := i->reference_ratio
1767 * i->soft_volume := i->real_ratio * i->volume_factor */
1768
1769 i->volume = i->reference_ratio;
1770 i->real_ratio = i->reference_ratio;
1771 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1772 }
1773
1774 /* Notify others about the changed sink input volume. */
1775 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1776 /* XXX: In case i->sink has flat volume enabled, then real_ratio
1777 * and soft_volume are not updated yet. Let's hope that the
1778 * callback implementation doesn't care about those variables... */
1779 if (i->volume_changed)
1780 i->volume_changed(i);
1781
1782 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1783 }
1784 }
1785
1786 /* If i->sink == dest, then recursion has finished, and we can finally call
1787 * pa_sink_set_volume(), which will do the rest of the updates. */
1788 if ((i->sink == dest) && pa_sink_flat_volume_enabled(i->sink))
1789 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
1790 }
1791
1792 /* Called from main context */
1793 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1794 struct volume_factor_entry *v;
1795 void *state = NULL;
1796
1797 pa_sink_input_assert_ref(i);
1798 pa_assert_ctl_context();
1799 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1800 pa_assert(!i->sink);
1801 pa_sink_assert_ref(dest);
1802
1803 if (!pa_sink_input_may_move_to(i, dest))
1804 return -PA_ERR_NOTSUPPORTED;
1805
1806 if (pa_sink_input_is_passthrough(i) && !pa_sink_check_format(dest, i->format)) {
1807 pa_proplist *p = pa_proplist_new();
1808 pa_log_debug("New sink doesn't support stream format, sending format-changed and killing");
1809 /* Tell the client what device we want to be on if it is going to
1810 * reconnect */
1811 pa_proplist_sets(p, "device", dest->name);
1812 pa_sink_input_send_event(i, PA_STREAM_EVENT_FORMAT_LOST, p);
1813 pa_proplist_free(p);
1814 return -PA_ERR_NOTSUPPORTED;
1815 }
1816
1817 if (!(i->flags & PA_SINK_INPUT_VARIABLE_RATE) &&
1818 !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec)) {
1819 /* try to change dest sink rate if possible without glitches.
1820 module-suspend-on-idle resumes destination sink with
1821 SINK_INPUT_MOVE_FINISH hook */
1822
1823 pa_log_info("Trying to change sample rate");
1824 if (pa_sink_update_rate(dest, i->sample_spec.rate, pa_sink_input_is_passthrough(i)) == TRUE)
1825 pa_log_info("Rate changed to %u Hz", dest->sample_spec.rate);
1826 }
1827
1828 if (i->moving)
1829 i->moving(i, dest);
1830
1831 i->sink = dest;
1832 i->save_sink = save;
1833 pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1834
1835 PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state)
1836 pa_cvolume_remap(&v->volume, &i->channel_map, &i->sink->channel_map);
1837
1838 pa_cvolume_remap(&i->volume_factor_sink, &i->channel_map, &i->sink->channel_map);
1839
1840 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1841 i->sink->n_corked++;
1842
1843 pa_sink_input_update_rate(i);
1844
1845 pa_sink_update_status(dest);
1846
1847 update_volume_due_to_moving(i, dest);
1848
1849 if (pa_sink_input_is_passthrough(i))
1850 pa_sink_enter_passthrough(i->sink);
1851
1852 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1853
1854 pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1855
1856 /* Notify everyone */
1857 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1858 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1859
1860 return 0;
1861 }
1862
1863 /* Called from main context */
1864 void pa_sink_input_fail_move(pa_sink_input *i) {
1865
1866 pa_sink_input_assert_ref(i);
1867 pa_assert_ctl_context();
1868 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1869 pa_assert(!i->sink);
1870
1871 /* Check if someone wants this sink input? */
1872 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1873 return;
1874
1875 if (i->moving)
1876 i->moving(i, NULL);
1877
1878 pa_sink_input_kill(i);
1879 }
1880
1881 /* Called from main context */
1882 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1883 int r;
1884
1885 pa_sink_input_assert_ref(i);
1886 pa_assert_ctl_context();
1887 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1888 pa_assert(i->sink);
1889 pa_sink_assert_ref(dest);
1890
1891 if (dest == i->sink)
1892 return 0;
1893
1894 if (!pa_sink_input_may_move_to(i, dest))
1895 return -PA_ERR_NOTSUPPORTED;
1896
1897 pa_sink_input_ref(i);
1898
1899 if ((r = pa_sink_input_start_move(i)) < 0) {
1900 pa_sink_input_unref(i);
1901 return r;
1902 }
1903
1904 if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1905 pa_sink_input_fail_move(i);
1906 pa_sink_input_unref(i);
1907 return r;
1908 }
1909
1910 pa_sink_input_unref(i);
1911
1912 return 0;
1913 }
1914
1915 /* Called from IO thread context */
1916 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1917 pa_bool_t corking, uncorking;
1918
1919 pa_sink_input_assert_ref(i);
1920 pa_sink_input_assert_io_context(i);
1921
1922 if (state == i->thread_info.state)
1923 return;
1924
1925 if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1926 !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1927 pa_atomic_store(&i->thread_info.drained, 1);
1928
1929 corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1930 uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1931
1932 if (i->state_change)
1933 i->state_change(i, state);
1934
1935 if (corking) {
1936
1937 pa_log_debug("Requesting rewind due to corking");
1938
1939 /* This will tell the implementing sink input driver to rewind
1940 * so that the unplayed already mixed data is not lost */
1941 pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1942
1943 /* Set the corked state *after* requesting rewind */
1944 i->thread_info.state = state;
1945
1946 } else if (uncorking) {
1947
1948 pa_log_debug("Requesting rewind due to uncorking");
1949
1950 i->thread_info.underrun_for = (uint64_t) -1;
1951 i->thread_info.underrun_for_sink = 0;
1952 i->thread_info.playing_for = 0;
1953
1954 /* Set the uncorked state *before* requesting rewind */
1955 i->thread_info.state = state;
1956
1957 /* OK, we're being uncorked. Make sure we're not rewound when
1958 * the hw buffer is remixed and request a remix. */
1959 pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1960 } else
1961 /* We may not be corking or uncorking, but we still need to set the state. */
1962 i->thread_info.state = state;
1963 }
1964
1965 /* Called from thread context, except when it is not. */
1966 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1967 pa_sink_input *i = PA_SINK_INPUT(o);
1968 pa_sink_input_assert_ref(i);
1969
1970 switch (code) {
1971
1972 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1973 if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1974 i->thread_info.soft_volume = i->soft_volume;
1975 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1976 }
1977 return 0;
1978
1979 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1980 if (i->thread_info.muted != i->muted) {
1981 i->thread_info.muted = i->muted;
1982 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1983 }
1984 return 0;
1985
1986 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1987 pa_usec_t *r = userdata;
1988
1989 r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1990 r[1] += pa_sink_get_latency_within_thread(i->sink);
1991
1992 return 0;
1993 }
1994
1995 case PA_SINK_INPUT_MESSAGE_SET_RATE:
1996
1997 i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1998 pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1999
2000 return 0;
2001
2002 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
2003 pa_sink_input *ssync;
2004
2005 pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
2006
2007 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
2008 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
2009
2010 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
2011 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
2012
2013 return 0;
2014 }
2015
2016 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
2017 pa_usec_t *usec = userdata;
2018
2019 *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
2020 return 0;
2021 }
2022
2023 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
2024 pa_usec_t *r = userdata;
2025
2026 *r = i->thread_info.requested_sink_latency;
2027 return 0;
2028 }
2029 }
2030
2031 return -PA_ERR_NOTIMPLEMENTED;
2032 }
2033
2034 /* Called from main thread */
2035 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
2036 pa_sink_input_assert_ref(i);
2037 pa_assert_ctl_context();
2038
2039 if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
2040 return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
2041
2042 return i->state;
2043 }
2044
2045 /* Called from IO context */
2046 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
2047 pa_sink_input_assert_ref(i);
2048 pa_sink_input_assert_io_context(i);
2049
2050 if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
2051 return pa_memblockq_is_empty(i->thread_info.render_memblockq);
2052
2053 return TRUE;
2054 }
2055
2056 /* Called from IO context */
2057 void pa_sink_input_request_rewind(
2058 pa_sink_input *i,
2059 size_t nbytes /* in our sample spec */,
2060 pa_bool_t rewrite,
2061 pa_bool_t flush,
2062 pa_bool_t dont_rewind_render) {
2063
2064 size_t lbq;
2065
2066 /* If 'rewrite' is TRUE the sink is rewound as far as requested
2067 * and possible and the exact value of this is passed back the
2068 * implementor via process_rewind(). If 'flush' is also TRUE all
2069 * already rendered data is also dropped.
2070 *
2071 * If 'rewrite' is FALSE the sink is rewound as far as requested
2072 * and possible and the already rendered data is dropped so that
2073 * in the next iteration we read new data from the
2074 * implementor. This implies 'flush' is TRUE. If
2075 * dont_rewind_render is TRUE then the render memblockq is not
2076 * rewound. */
2077
2078 /* nbytes = 0 means maximum rewind request */
2079
2080 pa_sink_input_assert_ref(i);
2081 pa_sink_input_assert_io_context(i);
2082 pa_assert(rewrite || flush);
2083 pa_assert(!dont_rewind_render || !rewrite);
2084
2085 /* We don't take rewind requests while we are corked */
2086 if (i->thread_info.state == PA_SINK_INPUT_CORKED)
2087 return;
2088
2089 nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
2090
2091 #ifdef SINK_INPUT_DEBUG
2092 pa_log_debug("request rewrite %zu", nbytes);
2093 #endif
2094
2095 /* Calculate how much we can rewind locally without having to
2096 * touch the sink */
2097 if (rewrite)
2098 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
2099 else
2100 lbq = 0;
2101
2102 /* Check if rewinding for the maximum is requested, and if so, fix up */
2103 if (nbytes <= 0) {
2104
2105 /* Calculate maximum number of bytes that could be rewound in theory */
2106 nbytes = i->sink->thread_info.max_rewind + lbq;
2107
2108 /* Transform from sink domain */
2109 if (i->thread_info.resampler)
2110 nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
2111 }
2112
2113 /* Remember how much we actually want to rewrite */
2114 if (i->thread_info.rewrite_nbytes != (size_t) -1) {
2115 if (rewrite) {
2116 /* Make sure to not overwrite over underruns */
2117 if (nbytes > i->thread_info.playing_for)
2118 nbytes = (size_t) i->thread_info.playing_for;
2119
2120 i->thread_info.rewrite_nbytes = nbytes;
2121 } else
2122 i->thread_info.rewrite_nbytes = (size_t) -1;
2123 }
2124
2125 i->thread_info.rewrite_flush =
2126 i->thread_info.rewrite_flush || flush;
2127
2128 i->thread_info.dont_rewind_render =
2129 i->thread_info.dont_rewind_render ||
2130 dont_rewind_render;
2131
2132 /* nbytes is -1 if some earlier rewind request had rewrite == false. */
2133 if (nbytes != (size_t) -1) {
2134
2135 /* Transform to sink domain */
2136 if (i->thread_info.resampler)
2137 nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
2138
2139 if (nbytes > lbq)
2140 pa_sink_request_rewind(i->sink, nbytes - lbq);
2141 else
2142 /* This call will make sure process_rewind() is called later */
2143 pa_sink_request_rewind(i->sink, 0);
2144 }
2145 }
2146
2147 /* Called from main context */
2148 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
2149 pa_sink_input_assert_ref(i);
2150 pa_assert_ctl_context();
2151 pa_assert(ret);
2152
2153 /* FIXME: Shouldn't access resampler object from main context! */
2154
2155 pa_silence_memchunk_get(
2156 &i->core->silence_cache,
2157 i->core->mempool,
2158 ret,
2159 &i->sample_spec,
2160 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
2161
2162 return ret;
2163 }
2164
2165 /* Called from main context */
2166 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
2167 pa_proplist *pl = NULL;
2168 pa_sink_input_send_event_hook_data hook_data;
2169
2170 pa_sink_input_assert_ref(i);
2171 pa_assert_ctl_context();
2172 pa_assert(event);
2173
2174 if (!i->send_event)
2175 return;
2176
2177 if (!data)
2178 data = pl = pa_proplist_new();
2179
2180 hook_data.sink_input = i;
2181 hook_data.data = data;
2182 hook_data.event = event;
2183
2184 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
2185 goto finish;
2186
2187 i->send_event(i, event, data);
2188
2189 finish:
2190 if (pl)
2191 pa_proplist_free(pl);
2192 }
2193
2194 /* Called from main context */
2195 /* Updates the sink input's resampler with whatever the current sink requires
2196 * -- useful when the underlying sink's rate might have changed */
2197 int pa_sink_input_update_rate(pa_sink_input *i) {
2198 pa_resampler *new_resampler;
2199 char *memblockq_name;
2200
2201 pa_sink_input_assert_ref(i);
2202 pa_assert_ctl_context();
2203
2204 if (i->thread_info.resampler &&
2205 pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &i->sink->sample_spec) &&
2206 pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &i->sink->channel_map))
2207
2208 new_resampler = i->thread_info.resampler;
2209
2210 else if (!pa_sink_input_is_passthrough(i) &&
2211 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
2212 !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec) ||
2213 !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map))) {
2214
2215 new_resampler = pa_resampler_new(i->core->mempool,
2216 &i->sample_spec, &i->channel_map,
2217 &i->sink->sample_spec, &i->sink->channel_map,
2218 i->requested_resample_method,
2219 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
2220 ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
2221 (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0));
2222
2223 if (!new_resampler) {
2224 pa_log_warn("Unsupported resampling operation.");
2225 return -PA_ERR_NOTSUPPORTED;
2226 }
2227 } else
2228 new_resampler = NULL;
2229
2230 if (new_resampler == i->thread_info.resampler)
2231 return 0;
2232
2233 if (i->thread_info.resampler)
2234 pa_resampler_free(i->thread_info.resampler);
2235
2236 i->thread_info.resampler = new_resampler;
2237
2238 pa_memblockq_free(i->thread_info.render_memblockq);
2239
2240 memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
2241 i->thread_info.render_memblockq = pa_memblockq_new(
2242 memblockq_name,
2243 0,
2244 MEMBLOCKQ_MAXLENGTH,
2245 0,
2246 &i->sink->sample_spec,
2247 0,
2248 1,
2249 0,
2250 &i->sink->silence);
2251 pa_xfree(memblockq_name);
2252
2253 i->actual_resample_method = new_resampler ? pa_resampler_get_method(new_resampler) : PA_RESAMPLER_INVALID;
2254
2255 pa_log_debug("Updated resampler for sink input %d", i->index);
2256
2257 return 0;
2258 }