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