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