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