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