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