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