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