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