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