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