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