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