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