?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pdispatch: add missing commands to command table
[pulseaudio-mirror.git] / src / pulsecore / sink-input.c
blob0ad95e6fb37899c534bb34b5bc65d4ce921480bf
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 /* Side note: this function must be able to destruct properly any
491 * kind of sink input in any state, even those which are
492 * "half-moved" or are connected to sinks that have no asyncmsgq
493 * and are hence half-destructed themselves! */
494
495 if (i->thread_info.render_memblockq)
496 pa_memblockq_free(i->thread_info.render_memblockq);
497
498 if (i->thread_info.resampler)
499 pa_resampler_free(i->thread_info.resampler);
500
501 if (i->proplist)
502 pa_proplist_free(i->proplist);
503
504 if (i->direct_outputs)
505 pa_idxset_free(i->direct_outputs, NULL, NULL);
506
507 if (i->thread_info.direct_outputs)
508 pa_hashmap_free(i->thread_info.direct_outputs, NULL, NULL);
509
510 pa_xfree(i->driver);
511 pa_xfree(i);
512 }
513
514 /* Called from main context */
515 void pa_sink_input_put(pa_sink_input *i) {
516 pa_sink_input_state_t state;
517
518 pa_sink_input_assert_ref(i);
519 pa_assert_ctl_context();
520
521 pa_assert(i->state == PA_SINK_INPUT_INIT);
522
523 /* The following fields must be initialized properly */
524 pa_assert(i->pop);
525 pa_assert(i->process_rewind);
526 pa_assert(i->kill);
527
528 state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING;
529
530 update_n_corked(i, state);
531 i->state = state;
532
533 /* We might need to update the sink's volume if we are in flat volume mode. */
534 if (i->sink->flags & PA_SINK_FLAT_VOLUME)
535 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
536 else
537 set_real_ratio(i, &i->volume);
538
539 i->thread_info.soft_volume = i->soft_volume;
540 i->thread_info.muted = i->muted;
541
542 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_ADD_INPUT, i, 0, NULL) == 0);
543
544 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, i->index);
545 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], i);
546
547 pa_sink_update_status(i->sink);
548 }
549
550 /* Called from main context */
551 void pa_sink_input_kill(pa_sink_input*i) {
552 pa_sink_input_assert_ref(i);
553 pa_assert_ctl_context();
554 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
555
556 i->kill(i);
557 }
558
559 /* Called from main context */
560 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency) {
561 pa_usec_t r[2] = { 0, 0 };
562
563 pa_sink_input_assert_ref(i);
564 pa_assert_ctl_context();
565 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
566
567 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_LATENCY, r, 0, NULL) == 0);
568
569 if (i->get_latency)
570 r[0] += i->get_latency(i);
571
572 if (sink_latency)
573 *sink_latency = r[1];
574
575 return r[0];
576 }
577
578 /* Called from thread context */
579 void pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink frames */, pa_memchunk *chunk, pa_cvolume *volume) {
580 pa_bool_t do_volume_adj_here;
581 pa_bool_t volume_is_norm;
582 size_t block_size_max_sink, block_size_max_sink_input;
583 size_t ilength;
584
585 pa_sink_input_assert_ref(i);
586 pa_sink_input_assert_io_context(i);
587 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
588 pa_assert(pa_frame_aligned(slength, &i->sink->sample_spec));
589 pa_assert(chunk);
590 pa_assert(volume);
591
592 /* pa_log_debug("peek"); */
593
594 pa_assert(i->thread_info.state == PA_SINK_INPUT_RUNNING ||
595 i->thread_info.state == PA_SINK_INPUT_CORKED ||
596 i->thread_info.state == PA_SINK_INPUT_DRAINED);
597
598 block_size_max_sink_input = i->thread_info.resampler ?
599 pa_resampler_max_block_size(i->thread_info.resampler) :
600 pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sample_spec);
601
602 block_size_max_sink = pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sink->sample_spec);
603
604 /* Default buffer size */
605 if (slength <= 0)
606 slength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sink->sample_spec);
607
608 if (slength > block_size_max_sink)
609 slength = block_size_max_sink;
610
611 if (i->thread_info.resampler) {
612 ilength = pa_resampler_request(i->thread_info.resampler, slength);
613
614 if (ilength <= 0)
615 ilength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sample_spec);
616 } else
617 ilength = slength;
618
619 if (ilength > block_size_max_sink_input)
620 ilength = block_size_max_sink_input;
621
622 /* If the channel maps of the sink and this stream differ, we need
623 * to adjust the volume *before* we resample. Otherwise we can do
624 * it after and leave it for the sink code */
625
626 do_volume_adj_here = !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map);
627 volume_is_norm = pa_cvolume_is_norm(&i->thread_info.soft_volume) && !i->thread_info.muted;
628
629 while (!pa_memblockq_is_readable(i->thread_info.render_memblockq)) {
630 pa_memchunk tchunk;
631
632 /* There's nothing in our render queue. We need to fill it up
633 * with data from the implementor. */
634
635 if (i->thread_info.state == PA_SINK_INPUT_CORKED ||
636 i->pop(i, ilength, &tchunk) < 0) {
637
638 /* OK, we're corked or the implementor didn't give us any
639 * data, so let's just hand out silence */
640 pa_atomic_store(&i->thread_info.drained, 1);
641
642 pa_memblockq_seek(i->thread_info.render_memblockq, (int64_t) slength, PA_SEEK_RELATIVE, TRUE);
643 i->thread_info.playing_for = 0;
644 if (i->thread_info.underrun_for != (uint64_t) -1)
645 i->thread_info.underrun_for += ilength;
646 break;
647 }
648
649 pa_atomic_store(&i->thread_info.drained, 0);
650
651 pa_assert(tchunk.length > 0);
652 pa_assert(tchunk.memblock);
653
654 i->thread_info.underrun_for = 0;
655 i->thread_info.playing_for += tchunk.length;
656
657 while (tchunk.length > 0) {
658 pa_memchunk wchunk;
659
660 wchunk = tchunk;
661 pa_memblock_ref(wchunk.memblock);
662
663 if (wchunk.length > block_size_max_sink_input)
664 wchunk.length = block_size_max_sink_input;
665
666 /* It might be necessary to adjust the volume here */
667 if (do_volume_adj_here && !volume_is_norm) {
668 pa_memchunk_make_writable(&wchunk, 0);
669
670 if (i->thread_info.muted)
671 pa_silence_memchunk(&wchunk, &i->thread_info.sample_spec);
672 else
673 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.soft_volume);
674 }
675
676 if (!i->thread_info.resampler)
677 pa_memblockq_push_align(i->thread_info.render_memblockq, &wchunk);
678 else {
679 pa_memchunk rchunk;
680 pa_resampler_run(i->thread_info.resampler, &wchunk, &rchunk);
681
682 /* pa_log_debug("pushing %lu", (unsigned long) rchunk.length); */
683
684 if (rchunk.memblock) {
685 pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk);
686 pa_memblock_unref(rchunk.memblock);
687 }
688 }
689
690 pa_memblock_unref(wchunk.memblock);
691
692 tchunk.index += wchunk.length;
693 tchunk.length -= wchunk.length;
694 }
695
696 pa_memblock_unref(tchunk.memblock);
697 }
698
699 pa_assert_se(pa_memblockq_peek(i->thread_info.render_memblockq, chunk) >= 0);
700
701 pa_assert(chunk->length > 0);
702 pa_assert(chunk->memblock);
703
704 /* pa_log_debug("peeking %lu", (unsigned long) chunk->length); */
705
706 if (chunk->length > block_size_max_sink)
707 chunk->length = block_size_max_sink;
708
709 /* Let's see if we had to apply the volume adjustment ourselves,
710 * or if this can be done by the sink for us */
711
712 if (do_volume_adj_here)
713 /* We had different channel maps, so we already did the adjustment */
714 pa_cvolume_reset(volume, i->sink->sample_spec.channels);
715 else if (i->thread_info.muted)
716 /* We've both the same channel map, so let's have the sink do the adjustment for us*/
717 pa_cvolume_mute(volume, i->sink->sample_spec.channels);
718 else
719 *volume = i->thread_info.soft_volume;
720 }
721
722 /* Called from thread context */
723 void pa_sink_input_drop(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
724
725 pa_sink_input_assert_ref(i);
726 pa_sink_input_assert_io_context(i);
727 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
728 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
729 pa_assert(nbytes > 0);
730
731 /* pa_log_debug("dropping %lu", (unsigned long) nbytes); */
732
733 pa_memblockq_drop(i->thread_info.render_memblockq, nbytes);
734 }
735
736 /* Called from thread context */
737 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
738 size_t lbq;
739 pa_bool_t called = FALSE;
740
741 pa_sink_input_assert_ref(i);
742 pa_sink_input_assert_io_context(i);
743 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
744 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
745
746 /* pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes); */
747
748 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
749
750 if (nbytes > 0 && !i->thread_info.dont_rewind_render) {
751 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes);
752 pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes);
753 }
754
755 if (i->thread_info.rewrite_nbytes == (size_t) -1) {
756
757 /* We were asked to drop all buffered data, and rerequest new
758 * data from implementor the next time push() is called */
759
760 pa_memblockq_flush_write(i->thread_info.render_memblockq);
761
762 } else if (i->thread_info.rewrite_nbytes > 0) {
763 size_t max_rewrite, amount;
764
765 /* Calculate how much make sense to rewrite at most */
766 max_rewrite = nbytes + lbq;
767
768 /* Transform into local domain */
769 if (i->thread_info.resampler)
770 max_rewrite = pa_resampler_request(i->thread_info.resampler, max_rewrite);
771
772 /* Calculate how much of the rewinded data should actually be rewritten */
773 amount = PA_MIN(i->thread_info.rewrite_nbytes, max_rewrite);
774
775 if (amount > 0) {
776 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount);
777
778 /* Tell the implementor */
779 if (i->process_rewind)
780 i->process_rewind(i, amount);
781 called = TRUE;
782
783 /* Convert back to to sink domain */
784 if (i->thread_info.resampler)
785 amount = pa_resampler_result(i->thread_info.resampler, amount);
786
787 if (amount > 0)
788 /* Ok, now update the write pointer */
789 pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) amount), PA_SEEK_RELATIVE, TRUE);
790
791 if (i->thread_info.rewrite_flush)
792 pa_memblockq_silence(i->thread_info.render_memblockq);
793
794 /* And reset the resampler */
795 if (i->thread_info.resampler)
796 pa_resampler_reset(i->thread_info.resampler);
797 }
798 }
799
800 if (!called)
801 if (i->process_rewind)
802 i->process_rewind(i, 0);
803
804 i->thread_info.rewrite_nbytes = 0;
805 i->thread_info.rewrite_flush = FALSE;
806 i->thread_info.dont_rewind_render = FALSE;
807 }
808
809 /* Called from thread context */
810 size_t pa_sink_input_get_max_rewind(pa_sink_input *i) {
811 pa_sink_input_assert_ref(i);
812 pa_sink_input_assert_io_context(i);
813
814 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_rewind) : i->sink->thread_info.max_rewind;
815 }
816
817 /* Called from thread context */
818 size_t pa_sink_input_get_max_request(pa_sink_input *i) {
819 pa_sink_input_assert_ref(i);
820 pa_sink_input_assert_io_context(i);
821
822 /* We're not verifying the status here, to allow this to be called
823 * in the state change handler between _INIT and _RUNNING */
824
825 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_request) : i->sink->thread_info.max_request;
826 }
827
828 /* Called from thread context */
829 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
830 pa_sink_input_assert_ref(i);
831 pa_sink_input_assert_io_context(i);
832 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
833 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
834
835 pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes);
836
837 if (i->update_max_rewind)
838 i->update_max_rewind(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
839 }
840
841 /* Called from thread context */
842 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
843 pa_sink_input_assert_ref(i);
844 pa_sink_input_assert_io_context(i);
845 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
846 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
847
848 if (i->update_max_request)
849 i->update_max_request(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
850 }
851
852 /* Called from thread context */
853 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) {
854 pa_sink_input_assert_ref(i);
855 pa_sink_input_assert_io_context(i);
856
857 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
858 usec = i->sink->thread_info.fixed_latency;
859
860 if (usec != (pa_usec_t) -1)
861 usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
862
863 i->thread_info.requested_sink_latency = usec;
864 pa_sink_invalidate_requested_latency(i->sink, TRUE);
865
866 return usec;
867 }
868
869 /* Called from main context */
870 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) {
871 pa_sink_input_assert_ref(i);
872 pa_assert_ctl_context();
873
874 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
875 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
876 return usec;
877 }
878
879 /* If this sink input is not realized yet or we are being moved,
880 * we have to touch the thread info data directly */
881
882 if (i->sink) {
883 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
884 usec = pa_sink_get_fixed_latency(i->sink);
885
886 if (usec != (pa_usec_t) -1) {
887 pa_usec_t min_latency, max_latency;
888 pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
889 usec = PA_CLAMP(usec, min_latency, max_latency);
890 }
891 }
892
893 i->thread_info.requested_sink_latency = usec;
894
895 return usec;
896 }
897
898 /* Called from main context */
899 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
900 pa_sink_input_assert_ref(i);
901 pa_assert_ctl_context();
902
903 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
904 pa_usec_t usec = 0;
905 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
906 return usec;
907 }
908
909 /* If this sink input is not realized yet or we are being moved,
910 * we have to touch the thread info data directly */
911
912 return i->thread_info.requested_sink_latency;
913 }
914
915 /* Called from main context */
916 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
917 pa_sink_input_assert_ref(i);
918 pa_assert_ctl_context();
919 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
920 pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
921
922 /* This basically calculates:
923 *
924 * i->real_ratio := v
925 * i->soft_volume := i->real_ratio * i->volume_factor */
926
927 if (v)
928 i->real_ratio = *v;
929 else
930 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
931
932 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
933 /* We don't copy the data to the thread_info data. That's left for someone else to do */
934 }
935
936 /* Called from main context */
937 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, pa_bool_t save, pa_bool_t absolute) {
938 pa_cvolume v;
939
940 pa_sink_input_assert_ref(i);
941 pa_assert_ctl_context();
942 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
943 pa_assert(volume);
944 pa_assert(pa_cvolume_valid(volume));
945 pa_assert(pa_cvolume_compatible(volume, &i->sample_spec));
946
947 if ((i->sink->flags & PA_SINK_FLAT_VOLUME) && !absolute) {
948 v = i->sink->reference_volume;
949 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
950 volume = pa_sw_cvolume_multiply(&v, &v, volume);
951 }
952
953 if (pa_cvolume_equal(volume, &i->volume)) {
954 i->save_volume = i->save_volume || save;
955 return;
956 }
957
958 i->volume = *volume;
959 i->save_volume = save;
960
961 if (i->sink->flags & PA_SINK_FLAT_VOLUME)
962 /* We are in flat volume mode, so let's update all sink input
963 * volumes and update the flat volume of the sink */
964
965 pa_sink_set_volume(i->sink, NULL, TRUE, save);
966
967 else {
968 /* OK, we are in normal volume mode. The volume only affects
969 * ourselves */
970 set_real_ratio(i, volume);
971
972 /* Copy the new soft_volume to the thread_info struct */
973 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
974 }
975
976 /* The volume changed, let's tell people so */
977 if (i->volume_changed)
978 i->volume_changed(i);
979
980 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
981 }
982
983 /* Called from main context */
984 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, pa_bool_t absolute) {
985 pa_sink_input_assert_ref(i);
986 pa_assert_ctl_context();
987 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
988
989 if (absolute || !(i->sink->flags & PA_SINK_FLAT_VOLUME))
990 *volume = i->volume;
991 else
992 *volume = i->reference_ratio;
993
994 return volume;
995 }
996
997 /* Called from main context */
998 void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute, pa_bool_t save) {
999 pa_sink_input_assert_ref(i);
1000 pa_assert_ctl_context();
1001 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1002
1003 if (!i->muted == !mute)
1004 return;
1005
1006 i->muted = mute;
1007 i->save_muted = save;
1008
1009 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1010
1011 /* The mute status changed, let's tell people so */
1012 if (i->mute_changed)
1013 i->mute_changed(i);
1014
1015 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1016 }
1017
1018 /* Called from main context */
1019 pa_bool_t pa_sink_input_get_mute(pa_sink_input *i) {
1020 pa_sink_input_assert_ref(i);
1021 pa_assert_ctl_context();
1022 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1023
1024 return i->muted;
1025 }
1026
1027 /* Called from main thread */
1028 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1029 pa_sink_input_assert_ref(i);
1030 pa_assert_ctl_context();
1031
1032 if (p)
1033 pa_proplist_update(i->proplist, mode, p);
1034
1035 if (PA_SINK_IS_LINKED(i->state)) {
1036 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1037 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1038 }
1039 }
1040
1041 /* Called from main context */
1042 void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b) {
1043 pa_sink_input_assert_ref(i);
1044 pa_assert_ctl_context();
1045 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1046
1047 sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1048 }
1049
1050 /* Called from main context */
1051 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1052 pa_sink_input_assert_ref(i);
1053 pa_assert_ctl_context();
1054 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1055 pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1056
1057 if (i->sample_spec.rate == rate)
1058 return 0;
1059
1060 i->sample_spec.rate = rate;
1061
1062 pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1063
1064 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1065 return 0;
1066 }
1067
1068 /* Called from main context */
1069 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1070 const char *old;
1071 pa_sink_input_assert_ref(i);
1072 pa_assert_ctl_context();
1073
1074 if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1075 return;
1076
1077 old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1078
1079 if (old && name && pa_streq(old, name))
1080 return;
1081
1082 if (name)
1083 pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1084 else
1085 pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1086
1087 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1088 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1089 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1090 }
1091 }
1092
1093 /* Called from main context */
1094 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1095 pa_sink_input_assert_ref(i);
1096 pa_assert_ctl_context();
1097
1098 return i->actual_resample_method;
1099 }
1100
1101 /* Called from main context */
1102 pa_bool_t pa_sink_input_may_move(pa_sink_input *i) {
1103 pa_sink_input_assert_ref(i);
1104 pa_assert_ctl_context();
1105 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1106
1107 if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1108 return FALSE;
1109
1110 if (i->sync_next || i->sync_prev) {
1111 pa_log_warn("Moving synchronised streams not supported.");
1112 return FALSE;
1113 }
1114
1115 return TRUE;
1116 }
1117
1118 /* Called from main context */
1119 pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1120 pa_sink_input_assert_ref(i);
1121 pa_assert_ctl_context();
1122 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1123 pa_sink_assert_ref(dest);
1124
1125 if (dest == i->sink)
1126 return TRUE;
1127
1128 if (!pa_sink_input_may_move(i))
1129 return FALSE;
1130
1131 if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1132 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1133 return FALSE;
1134 }
1135
1136 if (i->may_move_to)
1137 if (!i->may_move_to(i, dest))
1138 return FALSE;
1139
1140 return TRUE;
1141 }
1142
1143 /* Called from main context */
1144 int pa_sink_input_start_move(pa_sink_input *i) {
1145 pa_source_output *o, *p = NULL;
1146 pa_sink *origin;
1147 int r;
1148
1149 pa_sink_input_assert_ref(i);
1150 pa_assert_ctl_context();
1151 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1152 pa_assert(i->sink);
1153
1154 if (!pa_sink_input_may_move(i))
1155 return -PA_ERR_NOTSUPPORTED;
1156
1157 if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1158 return r;
1159
1160 origin = i->sink;
1161
1162 /* Kill directly connected outputs */
1163 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1164 pa_assert(o != p);
1165 pa_source_output_kill(o);
1166 p = o;
1167 }
1168 pa_assert(pa_idxset_isempty(i->direct_outputs));
1169
1170 pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1171
1172 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1173 pa_assert_se(i->sink->n_corked-- >= 1);
1174
1175 if (i->sink->flags & PA_SINK_FLAT_VOLUME)
1176 /* We might need to update the sink's volume if we are in flat
1177 * volume mode. */
1178 pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
1179
1180 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1181
1182 pa_sink_update_status(i->sink);
1183 i->sink = NULL;
1184
1185 pa_sink_input_unref(i);
1186
1187 return 0;
1188 }
1189
1190 /* Called from main context */
1191 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1192 pa_resampler *new_resampler;
1193
1194 pa_sink_input_assert_ref(i);
1195 pa_assert_ctl_context();
1196 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1197 pa_assert(!i->sink);
1198 pa_sink_assert_ref(dest);
1199
1200 if (!pa_sink_input_may_move_to(i, dest))
1201 return -PA_ERR_NOTSUPPORTED;
1202
1203 if (i->thread_info.resampler &&
1204 pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &dest->sample_spec) &&
1205 pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &dest->channel_map))
1206
1207 /* Try to reuse the old resampler if possible */
1208 new_resampler = i->thread_info.resampler;
1209
1210 else if ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
1211 !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec) ||
1212 !pa_channel_map_equal(&i->channel_map, &dest->channel_map)) {
1213
1214 /* Okey, we need a new resampler for the new sink */
1215
1216 if (!(new_resampler = pa_resampler_new(
1217 i->core->mempool,
1218 &i->sample_spec, &i->channel_map,
1219 &dest->sample_spec, &dest->channel_map,
1220 i->requested_resample_method,
1221 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
1222 ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
1223 (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0)))) {
1224 pa_log_warn("Unsupported resampling operation.");
1225 return -PA_ERR_NOTSUPPORTED;
1226 }
1227 } else
1228 new_resampler = NULL;
1229
1230 if (i->moving)
1231 i->moving(i, dest);
1232
1233 i->sink = dest;
1234 i->save_sink = save;
1235 pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1236
1237 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1238 i->sink->n_corked++;
1239
1240 /* Replace resampler and render queue */
1241 if (new_resampler != i->thread_info.resampler) {
1242
1243 if (i->thread_info.resampler)
1244 pa_resampler_free(i->thread_info.resampler);
1245 i->thread_info.resampler = new_resampler;
1246
1247 pa_memblockq_free(i->thread_info.render_memblockq);
1248
1249 i->thread_info.render_memblockq = pa_memblockq_new(
1250 0,
1251 MEMBLOCKQ_MAXLENGTH,
1252 0,
1253 pa_frame_size(&i->sink->sample_spec),
1254 0,
1255 1,
1256 0,
1257 &i->sink->silence);
1258 }
1259 pa_sink_update_status(dest);
1260
1261 if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
1262 pa_cvolume remapped;
1263
1264 /* Make relative volumes absolute */
1265 remapped = dest->reference_volume;
1266 pa_cvolume_remap(&remapped, &dest->channel_map, &i->channel_map);
1267 pa_sw_cvolume_multiply(&i->volume, &i->reference_ratio, &remapped);
1268
1269 /* We might need to update the sink's volume if we are in flat volume mode. */
1270 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
1271 }
1272
1273 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1274
1275 pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1276
1277 /* Notify everyone */
1278 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1279
1280 if (i->volume_changed)
1281 i->volume_changed(i);
1282
1283 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1284
1285 return 0;
1286 }
1287
1288 /* Called from main context */
1289 void pa_sink_input_fail_move(pa_sink_input *i) {
1290
1291 pa_sink_input_assert_ref(i);
1292 pa_assert_ctl_context();
1293 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1294 pa_assert(!i->sink);
1295
1296 /* Check if someone wants this sink input? */
1297 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1298 return;
1299
1300 if (i->moving)
1301 i->moving(i, NULL);
1302
1303 pa_sink_input_kill(i);
1304 }
1305
1306 /* Called from main context */
1307 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1308 int r;
1309
1310 pa_sink_input_assert_ref(i);
1311 pa_assert_ctl_context();
1312 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1313 pa_assert(i->sink);
1314 pa_sink_assert_ref(dest);
1315
1316 if (dest == i->sink)
1317 return 0;
1318
1319 if (!pa_sink_input_may_move_to(i, dest))
1320 return -PA_ERR_NOTSUPPORTED;
1321
1322 pa_sink_input_ref(i);
1323
1324 if ((r = pa_sink_input_start_move(i)) < 0) {
1325 pa_sink_input_unref(i);
1326 return r;
1327 }
1328
1329 if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1330 pa_sink_input_fail_move(i);
1331 pa_sink_input_unref(i);
1332 return r;
1333 }
1334
1335 pa_sink_input_unref(i);
1336
1337 return 0;
1338 }
1339
1340 /* Called from IO thread context */
1341 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1342 pa_bool_t corking, uncorking;
1343
1344 pa_sink_input_assert_ref(i);
1345 pa_sink_input_assert_io_context(i);
1346
1347 if (state == i->thread_info.state)
1348 return;
1349
1350 if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1351 !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1352 pa_atomic_store(&i->thread_info.drained, 1);
1353
1354 corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1355 uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1356
1357 if (i->state_change)
1358 i->state_change(i, state);
1359
1360 i->thread_info.state = state;
1361
1362 if (corking) {
1363
1364 pa_log_debug("Requesting rewind due to corking");
1365
1366 /* This will tell the implementing sink input driver to rewind
1367 * so that the unplayed already mixed data is not lost */
1368 pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1369
1370 } else if (uncorking) {
1371
1372 i->thread_info.underrun_for = (uint64_t) -1;
1373 i->thread_info.playing_for = 0;
1374
1375 pa_log_debug("Requesting rewind due to uncorking");
1376
1377 /* OK, we're being uncorked. Make sure we're not rewound when
1378 * the hw buffer is remixed and request a remix. */
1379 pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1380 }
1381 }
1382
1383 /* Called from thread context, except when it is not. */
1384 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1385 pa_sink_input *i = PA_SINK_INPUT(o);
1386 pa_sink_input_assert_ref(i);
1387
1388 switch (code) {
1389
1390 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1391 if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1392 i->thread_info.soft_volume = i->soft_volume;
1393 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1394 }
1395 return 0;
1396
1397 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1398 if (i->thread_info.muted != i->muted) {
1399 i->thread_info.muted = i->muted;
1400 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1401 }
1402 return 0;
1403
1404 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1405 pa_usec_t *r = userdata;
1406
1407 r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1408 r[1] += pa_sink_get_latency_within_thread(i->sink);
1409
1410 return 0;
1411 }
1412
1413 case PA_SINK_INPUT_MESSAGE_SET_RATE:
1414
1415 i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1416 pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1417
1418 return 0;
1419
1420 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1421 pa_sink_input *ssync;
1422
1423 pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
1424
1425 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
1426 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1427
1428 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
1429 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1430
1431 return 0;
1432 }
1433
1434 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
1435 pa_usec_t *usec = userdata;
1436
1437 *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
1438 return 0;
1439 }
1440
1441 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
1442 pa_usec_t *r = userdata;
1443
1444 *r = i->thread_info.requested_sink_latency;
1445 return 0;
1446 }
1447 }
1448
1449 return -PA_ERR_NOTIMPLEMENTED;
1450 }
1451
1452 /* Called from main thread */
1453 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
1454 pa_sink_input_assert_ref(i);
1455 pa_assert_ctl_context();
1456
1457 if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
1458 return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
1459
1460 return i->state;
1461 }
1462
1463 /* Called from IO context */
1464 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
1465 pa_sink_input_assert_ref(i);
1466 pa_sink_input_assert_io_context(i);
1467
1468 if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
1469 return pa_memblockq_is_empty(i->thread_info.render_memblockq);
1470
1471 return TRUE;
1472 }
1473
1474 /* Called from IO context */
1475 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) {
1476 size_t lbq;
1477
1478 /* If 'rewrite' is TRUE the sink is rewound as far as requested
1479 * and possible and the exact value of this is passed back the
1480 * implementor via process_rewind(). If 'flush' is also TRUE all
1481 * already rendered data is also dropped.
1482 *
1483 * If 'rewrite' is FALSE the sink is rewound as far as requested
1484 * and possible and the already rendered data is dropped so that
1485 * in the next iteration we read new data from the
1486 * implementor. This implies 'flush' is TRUE. If
1487 * dont_rewind_render is TRUE then the render memblockq is not
1488 * rewound. */
1489
1490 pa_sink_input_assert_ref(i);
1491 pa_sink_input_assert_io_context(i);
1492
1493 nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
1494
1495 /* pa_log_debug("request rewrite %lu", (unsigned long) nbytes); */
1496
1497 /* We don't take rewind requests while we are corked */
1498 if (i->thread_info.state == PA_SINK_INPUT_CORKED)
1499 return;
1500
1501 pa_assert(rewrite || flush);
1502 pa_assert(!dont_rewind_render || !rewrite);
1503
1504 /* Calculate how much we can rewind locally without having to
1505 * touch the sink */
1506 if (rewrite)
1507 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1508 else
1509 lbq = 0;
1510
1511 /* Check if rewinding for the maximum is requested, and if so, fix up */
1512 if (nbytes <= 0) {
1513
1514 /* Calculate maximum number of bytes that could be rewound in theory */
1515 nbytes = i->sink->thread_info.max_rewind + lbq;
1516
1517 /* Transform from sink domain */
1518 if (i->thread_info.resampler)
1519 nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
1520 }
1521
1522 if (i->thread_info.rewrite_nbytes != (size_t) -1) {
1523 if (rewrite) {
1524 /* Make sure to not overwrite over underruns */
1525 if (nbytes > i->thread_info.playing_for)
1526 nbytes = (size_t) i->thread_info.playing_for;
1527
1528 i->thread_info.rewrite_nbytes = nbytes;
1529 } else
1530 i->thread_info.rewrite_nbytes = (size_t) -1;
1531 }
1532
1533 i->thread_info.rewrite_flush =
1534 i->thread_info.rewrite_flush ||
1535 (flush && i->thread_info.rewrite_nbytes != 0);
1536
1537 i->thread_info.dont_rewind_render =
1538 i->thread_info.dont_rewind_render ||
1539 dont_rewind_render;
1540
1541 if (nbytes != (size_t) -1) {
1542
1543 /* Transform to sink domain */
1544 if (i->thread_info.resampler)
1545 nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
1546
1547 if (nbytes > lbq)
1548 pa_sink_request_rewind(i->sink, nbytes - lbq);
1549 else
1550 /* This call will make sure process_rewind() is called later */
1551 pa_sink_request_rewind(i->sink, 0);
1552 }
1553 }
1554
1555 /* Called from main context */
1556 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
1557 pa_sink_input_assert_ref(i);
1558 pa_assert_ctl_context();
1559 pa_assert(ret);
1560
1561 /* FIXME: Shouldn't access resampler object from main context! */
1562
1563 pa_silence_memchunk_get(
1564 &i->core->silence_cache,
1565 i->core->mempool,
1566 ret,
1567 &i->sample_spec,
1568 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
1569
1570 return ret;
1571 }
1572
1573 /* Called from main context */
1574 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
1575 pa_proplist *pl = NULL;
1576 pa_sink_input_send_event_hook_data hook_data;
1577
1578 pa_sink_input_assert_ref(i);
1579 pa_assert_ctl_context();
1580 pa_assert(event);
1581
1582 if (!i->send_event)
1583 return;
1584
1585 if (!data)
1586 data = pl = pa_proplist_new();
1587
1588 hook_data.sink_input = i;
1589 hook_data.data = data;
1590 hook_data.event = event;
1591
1592 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
1593 goto finish;
1594
1595 i->send_event(i, event, data);
1596
1597 finish:
1598 if (pl)
1599 pa_proplist_free(pl);
1600 }
A mirror of the PulseAudio repo