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