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