]> code.delx.au - pulseaudio/blob - src/pulsecore/sink-input.c
delx.au / code / pulseaudio / blob


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