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