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