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