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