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