]> 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 if (nvfs) {
721 pa_memchunk_make_writable(&rchunk, 0);
722 pa_volume_memchunk(&rchunk, &i->sink->sample_spec, &i->volume_factor_sink);
723 }
724
725 /* pa_log_debug("pushing %lu", (unsigned long) rchunk.length); */
726
727 if (rchunk.memblock) {
728 pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk);
729 pa_memblock_unref(rchunk.memblock);
730 }
731 }
732
733 pa_memblock_unref(wchunk.memblock);
734
735 tchunk.index += wchunk.length;
736 tchunk.length -= wchunk.length;
737 }
738
739 pa_memblock_unref(tchunk.memblock);
740 }
741
742 pa_assert_se(pa_memblockq_peek(i->thread_info.render_memblockq, chunk) >= 0);
743
744 pa_assert(chunk->length > 0);
745 pa_assert(chunk->memblock);
746
747 /* pa_log_debug("peeking %lu", (unsigned long) chunk->length); */
748
749 if (chunk->length > block_size_max_sink)
750 chunk->length = block_size_max_sink;
751
752 /* Let's see if we had to apply the volume adjustment ourselves,
753 * or if this can be done by the sink for us */
754
755 if (do_volume_adj_here)
756 /* We had different channel maps, so we already did the adjustment */
757 pa_cvolume_reset(volume, i->sink->sample_spec.channels);
758 else if (i->thread_info.muted)
759 /* We've both the same channel map, so let's have the sink do the adjustment for us*/
760 pa_cvolume_mute(volume, i->sink->sample_spec.channels);
761 else
762 *volume = i->thread_info.soft_volume;
763 }
764
765 /* Called from thread context */
766 void pa_sink_input_drop(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
767
768 pa_sink_input_assert_ref(i);
769 pa_sink_input_assert_io_context(i);
770 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
771 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
772 pa_assert(nbytes > 0);
773
774 /* pa_log_debug("dropping %lu", (unsigned long) nbytes); */
775
776 pa_memblockq_drop(i->thread_info.render_memblockq, nbytes);
777 }
778
779 /* Called from thread context */
780 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
781 size_t lbq;
782 pa_bool_t called = FALSE;
783
784 pa_sink_input_assert_ref(i);
785 pa_sink_input_assert_io_context(i);
786 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
787 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
788
789 /* pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes); */
790
791 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
792
793 if (nbytes > 0 && !i->thread_info.dont_rewind_render) {
794 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes);
795 pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes);
796 }
797
798 if (i->thread_info.rewrite_nbytes == (size_t) -1) {
799
800 /* We were asked to drop all buffered data, and rerequest new
801 * data from implementor the next time push() is called */
802
803 pa_memblockq_flush_write(i->thread_info.render_memblockq);
804
805 } else if (i->thread_info.rewrite_nbytes > 0) {
806 size_t max_rewrite, amount;
807
808 /* Calculate how much make sense to rewrite at most */
809 max_rewrite = nbytes + lbq;
810
811 /* Transform into local domain */
812 if (i->thread_info.resampler)
813 max_rewrite = pa_resampler_request(i->thread_info.resampler, max_rewrite);
814
815 /* Calculate how much of the rewinded data should actually be rewritten */
816 amount = PA_MIN(i->thread_info.rewrite_nbytes, max_rewrite);
817
818 if (amount > 0) {
819 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount);
820
821 /* Tell the implementor */
822 if (i->process_rewind)
823 i->process_rewind(i, amount);
824 called = TRUE;
825
826 /* Convert back to to sink domain */
827 if (i->thread_info.resampler)
828 amount = pa_resampler_result(i->thread_info.resampler, amount);
829
830 if (amount > 0)
831 /* Ok, now update the write pointer */
832 pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) amount), PA_SEEK_RELATIVE, TRUE);
833
834 if (i->thread_info.rewrite_flush)
835 pa_memblockq_silence(i->thread_info.render_memblockq);
836
837 /* And reset the resampler */
838 if (i->thread_info.resampler)
839 pa_resampler_reset(i->thread_info.resampler);
840 }
841 }
842
843 if (!called)
844 if (i->process_rewind)
845 i->process_rewind(i, 0);
846
847 i->thread_info.rewrite_nbytes = 0;
848 i->thread_info.rewrite_flush = FALSE;
849 i->thread_info.dont_rewind_render = FALSE;
850 }
851
852 /* Called from thread context */
853 size_t pa_sink_input_get_max_rewind(pa_sink_input *i) {
854 pa_sink_input_assert_ref(i);
855 pa_sink_input_assert_io_context(i);
856
857 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_rewind) : i->sink->thread_info.max_rewind;
858 }
859
860 /* Called from thread context */
861 size_t pa_sink_input_get_max_request(pa_sink_input *i) {
862 pa_sink_input_assert_ref(i);
863 pa_sink_input_assert_io_context(i);
864
865 /* We're not verifying the status here, to allow this to be called
866 * in the state change handler between _INIT and _RUNNING */
867
868 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_request) : i->sink->thread_info.max_request;
869 }
870
871 /* Called from thread context */
872 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
873 pa_sink_input_assert_ref(i);
874 pa_sink_input_assert_io_context(i);
875 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
876 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
877
878 pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes);
879
880 if (i->update_max_rewind)
881 i->update_max_rewind(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
882 }
883
884 /* Called from thread context */
885 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
886 pa_sink_input_assert_ref(i);
887 pa_sink_input_assert_io_context(i);
888 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
889 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
890
891 if (i->update_max_request)
892 i->update_max_request(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
893 }
894
895 /* Called from thread context */
896 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) {
897 pa_sink_input_assert_ref(i);
898 pa_sink_input_assert_io_context(i);
899
900 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
901 usec = i->sink->thread_info.fixed_latency;
902
903 if (usec != (pa_usec_t) -1)
904 usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
905
906 i->thread_info.requested_sink_latency = usec;
907 pa_sink_invalidate_requested_latency(i->sink, TRUE);
908
909 return usec;
910 }
911
912 /* Called from main context */
913 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) {
914 pa_sink_input_assert_ref(i);
915 pa_assert_ctl_context();
916
917 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
918 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
919 return usec;
920 }
921
922 /* If this sink input is not realized yet or we are being moved,
923 * we have to touch the thread info data directly */
924
925 if (i->sink) {
926 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
927 usec = pa_sink_get_fixed_latency(i->sink);
928
929 if (usec != (pa_usec_t) -1) {
930 pa_usec_t min_latency, max_latency;
931 pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
932 usec = PA_CLAMP(usec, min_latency, max_latency);
933 }
934 }
935
936 i->thread_info.requested_sink_latency = usec;
937
938 return usec;
939 }
940
941 /* Called from main context */
942 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
943 pa_sink_input_assert_ref(i);
944 pa_assert_ctl_context();
945
946 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
947 pa_usec_t usec = 0;
948 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
949 return usec;
950 }
951
952 /* If this sink input is not realized yet or we are being moved,
953 * we have to touch the thread info data directly */
954
955 return i->thread_info.requested_sink_latency;
956 }
957
958 /* Called from main context */
959 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
960 pa_sink_input_assert_ref(i);
961 pa_assert_ctl_context();
962 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
963 pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
964
965 /* This basically calculates:
966 *
967 * i->real_ratio := v
968 * i->soft_volume := i->real_ratio * i->volume_factor */
969
970 if (v)
971 i->real_ratio = *v;
972 else
973 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
974
975 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
976 /* We don't copy the data to the thread_info data. That's left for someone else to do */
977 }
978
979 /* Called from main context */
980 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, pa_bool_t save, pa_bool_t absolute) {
981 pa_cvolume v;
982
983 pa_sink_input_assert_ref(i);
984 pa_assert_ctl_context();
985 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
986 pa_assert(volume);
987 pa_assert(pa_cvolume_valid(volume));
988 pa_assert(volume->channels == 1 || pa_cvolume_compatible(volume, &i->sample_spec));
989
990 if ((i->sink->flags & PA_SINK_FLAT_VOLUME) && !absolute) {
991 v = i->sink->reference_volume;
992 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
993
994 if (pa_cvolume_compatible(volume, &i->sample_spec))
995 volume = pa_sw_cvolume_multiply(&v, &v, volume);
996 else
997 volume = pa_sw_cvolume_multiply_scalar(&v, &v, pa_cvolume_max(volume));
998 } else {
999
1000 if (!pa_cvolume_compatible(volume, &i->sample_spec)) {
1001 v = i->volume;
1002 volume = pa_cvolume_scale(&v, pa_cvolume_max(volume));
1003 }
1004 }
1005
1006 if (pa_cvolume_equal(volume, &i->volume)) {
1007 i->save_volume = i->save_volume || save;
1008 return;
1009 }
1010
1011 i->volume = *volume;
1012 i->save_volume = save;
1013
1014 if (i->sink->flags & PA_SINK_FLAT_VOLUME)
1015 /* We are in flat volume mode, so let's update all sink input
1016 * volumes and update the flat volume of the sink */
1017
1018 pa_sink_set_volume(i->sink, NULL, TRUE, save);
1019
1020 else {
1021 /* OK, we are in normal volume mode. The volume only affects
1022 * ourselves */
1023 set_real_ratio(i, volume);
1024
1025 /* Copy the new soft_volume to the thread_info struct */
1026 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1027 }
1028
1029 /* The volume changed, let's tell people so */
1030 if (i->volume_changed)
1031 i->volume_changed(i);
1032
1033 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1034 }
1035
1036 /* Called from main context */
1037 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, pa_bool_t absolute) {
1038 pa_sink_input_assert_ref(i);
1039 pa_assert_ctl_context();
1040 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1041
1042 if (absolute || !(i->sink->flags & PA_SINK_FLAT_VOLUME))
1043 *volume = i->volume;
1044 else
1045 *volume = i->reference_ratio;
1046
1047 return volume;
1048 }
1049
1050 /* Called from main context */
1051 void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute, pa_bool_t save) {
1052 pa_sink_input_assert_ref(i);
1053 pa_assert_ctl_context();
1054 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1055
1056 if (!i->muted == !mute)
1057 return;
1058
1059 i->muted = mute;
1060 i->save_muted = save;
1061
1062 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1063
1064 /* The mute status changed, let's tell people so */
1065 if (i->mute_changed)
1066 i->mute_changed(i);
1067
1068 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1069 }
1070
1071 /* Called from main context */
1072 pa_bool_t pa_sink_input_get_mute(pa_sink_input *i) {
1073 pa_sink_input_assert_ref(i);
1074 pa_assert_ctl_context();
1075 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1076
1077 return i->muted;
1078 }
1079
1080 /* Called from main thread */
1081 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1082 pa_sink_input_assert_ref(i);
1083 pa_assert_ctl_context();
1084
1085 if (p)
1086 pa_proplist_update(i->proplist, mode, p);
1087
1088 if (PA_SINK_IS_LINKED(i->state)) {
1089 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1090 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1091 }
1092 }
1093
1094 /* Called from main context */
1095 void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b) {
1096 pa_sink_input_assert_ref(i);
1097 pa_assert_ctl_context();
1098 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1099
1100 sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1101 }
1102
1103 /* Called from main context */
1104 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1105 pa_sink_input_assert_ref(i);
1106 pa_assert_ctl_context();
1107 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1108 pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1109
1110 if (i->sample_spec.rate == rate)
1111 return 0;
1112
1113 i->sample_spec.rate = rate;
1114
1115 pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1116
1117 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1118 return 0;
1119 }
1120
1121 /* Called from main context */
1122 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1123 const char *old;
1124 pa_sink_input_assert_ref(i);
1125 pa_assert_ctl_context();
1126
1127 if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1128 return;
1129
1130 old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1131
1132 if (old && name && pa_streq(old, name))
1133 return;
1134
1135 if (name)
1136 pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1137 else
1138 pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1139
1140 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1141 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1142 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1143 }
1144 }
1145
1146 /* Called from main context */
1147 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1148 pa_sink_input_assert_ref(i);
1149 pa_assert_ctl_context();
1150
1151 return i->actual_resample_method;
1152 }
1153
1154 /* Called from main context */
1155 pa_bool_t pa_sink_input_may_move(pa_sink_input *i) {
1156 pa_sink_input_assert_ref(i);
1157 pa_assert_ctl_context();
1158 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1159
1160 if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1161 return FALSE;
1162
1163 if (i->sync_next || i->sync_prev) {
1164 pa_log_warn("Moving synchronised streams not supported.");
1165 return FALSE;
1166 }
1167
1168 return TRUE;
1169 }
1170
1171 /* Called from main context */
1172 pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1173 pa_sink_input_assert_ref(i);
1174 pa_assert_ctl_context();
1175 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1176 pa_sink_assert_ref(dest);
1177
1178 if (dest == i->sink)
1179 return TRUE;
1180
1181 if (!pa_sink_input_may_move(i))
1182 return FALSE;
1183
1184 if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1185 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1186 return FALSE;
1187 }
1188
1189 if (i->may_move_to)
1190 if (!i->may_move_to(i, dest))
1191 return FALSE;
1192
1193 return TRUE;
1194 }
1195
1196 /* Called from main context */
1197 int pa_sink_input_start_move(pa_sink_input *i) {
1198 pa_source_output *o, *p = NULL;
1199 int r;
1200
1201 pa_sink_input_assert_ref(i);
1202 pa_assert_ctl_context();
1203 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1204 pa_assert(i->sink);
1205
1206 if (!pa_sink_input_may_move(i))
1207 return -PA_ERR_NOTSUPPORTED;
1208
1209 if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1210 return r;
1211
1212 /* Kill directly connected outputs */
1213 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1214 pa_assert(o != p);
1215 pa_source_output_kill(o);
1216 p = o;
1217 }
1218 pa_assert(pa_idxset_isempty(i->direct_outputs));
1219
1220 pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1221
1222 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1223 pa_assert_se(i->sink->n_corked-- >= 1);
1224
1225 if (i->sink->flags & PA_SINK_FLAT_VOLUME)
1226 /* We might need to update the sink's volume if we are in flat
1227 * volume mode. */
1228 pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
1229
1230 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1231
1232 pa_sink_update_status(i->sink);
1233 pa_cvolume_remap(&i->volume_factor_sink, &i->sink->channel_map, &i->channel_map);
1234 i->sink = NULL;
1235
1236 pa_sink_input_unref(i);
1237
1238 return 0;
1239 }
1240
1241 /* Called from main context */
1242 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1243 pa_resampler *new_resampler;
1244
1245 pa_sink_input_assert_ref(i);
1246 pa_assert_ctl_context();
1247 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1248 pa_assert(!i->sink);
1249 pa_sink_assert_ref(dest);
1250
1251 if (!pa_sink_input_may_move_to(i, dest))
1252 return -PA_ERR_NOTSUPPORTED;
1253
1254 if (i->thread_info.resampler &&
1255 pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &dest->sample_spec) &&
1256 pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &dest->channel_map))
1257
1258 /* Try to reuse the old resampler if possible */
1259 new_resampler = i->thread_info.resampler;
1260
1261 else if ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
1262 !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec) ||
1263 !pa_channel_map_equal(&i->channel_map, &dest->channel_map)) {
1264
1265 /* Okey, we need a new resampler for the new sink */
1266
1267 if (!(new_resampler = pa_resampler_new(
1268 i->core->mempool,
1269 &i->sample_spec, &i->channel_map,
1270 &dest->sample_spec, &dest->channel_map,
1271 i->requested_resample_method,
1272 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
1273 ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
1274 (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0)))) {
1275 pa_log_warn("Unsupported resampling operation.");
1276 return -PA_ERR_NOTSUPPORTED;
1277 }
1278 } else
1279 new_resampler = NULL;
1280
1281 if (i->moving)
1282 i->moving(i, dest);
1283
1284 i->sink = dest;
1285 i->save_sink = save;
1286 pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1287
1288 pa_cvolume_remap(&i->volume_factor_sink, &i->channel_map, &i->sink->channel_map);
1289
1290 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1291 i->sink->n_corked++;
1292
1293 /* Replace resampler and render queue */
1294 if (new_resampler != i->thread_info.resampler) {
1295
1296 if (i->thread_info.resampler)
1297 pa_resampler_free(i->thread_info.resampler);
1298 i->thread_info.resampler = new_resampler;
1299
1300 pa_memblockq_free(i->thread_info.render_memblockq);
1301
1302 i->thread_info.render_memblockq = pa_memblockq_new(
1303 0,
1304 MEMBLOCKQ_MAXLENGTH,
1305 0,
1306 pa_frame_size(&i->sink->sample_spec),
1307 0,
1308 1,
1309 0,
1310 &i->sink->silence);
1311 }
1312 pa_sink_update_status(dest);
1313
1314 if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
1315 pa_cvolume remapped;
1316
1317 /* Make relative volumes absolute */
1318 remapped = dest->reference_volume;
1319 pa_cvolume_remap(&remapped, &dest->channel_map, &i->channel_map);
1320 pa_sw_cvolume_multiply(&i->volume, &i->reference_ratio, &remapped);
1321
1322 /* We might need to update the sink's volume if we are in flat volume mode. */
1323 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
1324 }
1325
1326 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1327
1328 pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1329
1330 /* Notify everyone */
1331 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1332
1333 if (i->volume_changed)
1334 i->volume_changed(i);
1335
1336 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1337
1338 return 0;
1339 }
1340
1341 /* Called from main context */
1342 void pa_sink_input_fail_move(pa_sink_input *i) {
1343
1344 pa_sink_input_assert_ref(i);
1345 pa_assert_ctl_context();
1346 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1347 pa_assert(!i->sink);
1348
1349 /* Check if someone wants this sink input? */
1350 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1351 return;
1352
1353 if (i->moving)
1354 i->moving(i, NULL);
1355
1356 pa_sink_input_kill(i);
1357 }
1358
1359 /* Called from main context */
1360 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1361 int r;
1362
1363 pa_sink_input_assert_ref(i);
1364 pa_assert_ctl_context();
1365 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1366 pa_assert(i->sink);
1367 pa_sink_assert_ref(dest);
1368
1369 if (dest == i->sink)
1370 return 0;
1371
1372 if (!pa_sink_input_may_move_to(i, dest))
1373 return -PA_ERR_NOTSUPPORTED;
1374
1375 pa_sink_input_ref(i);
1376
1377 if ((r = pa_sink_input_start_move(i)) < 0) {
1378 pa_sink_input_unref(i);
1379 return r;
1380 }
1381
1382 if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1383 pa_sink_input_fail_move(i);
1384 pa_sink_input_unref(i);
1385 return r;
1386 }
1387
1388 pa_sink_input_unref(i);
1389
1390 return 0;
1391 }
1392
1393 /* Called from IO thread context */
1394 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1395 pa_bool_t corking, uncorking;
1396
1397 pa_sink_input_assert_ref(i);
1398 pa_sink_input_assert_io_context(i);
1399
1400 if (state == i->thread_info.state)
1401 return;
1402
1403 if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1404 !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1405 pa_atomic_store(&i->thread_info.drained, 1);
1406
1407 corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1408 uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1409
1410 if (i->state_change)
1411 i->state_change(i, state);
1412
1413 i->thread_info.state = state;
1414
1415 if (corking) {
1416
1417 pa_log_debug("Requesting rewind due to corking");
1418
1419 /* This will tell the implementing sink input driver to rewind
1420 * so that the unplayed already mixed data is not lost */
1421 pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1422
1423 } else if (uncorking) {
1424
1425 i->thread_info.underrun_for = (uint64_t) -1;
1426 i->thread_info.playing_for = 0;
1427
1428 pa_log_debug("Requesting rewind due to uncorking");
1429
1430 /* OK, we're being uncorked. Make sure we're not rewound when
1431 * the hw buffer is remixed and request a remix. */
1432 pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1433 }
1434 }
1435
1436 /* Called from thread context, except when it is not. */
1437 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1438 pa_sink_input *i = PA_SINK_INPUT(o);
1439 pa_sink_input_assert_ref(i);
1440
1441 switch (code) {
1442
1443 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1444 if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1445 i->thread_info.soft_volume = i->soft_volume;
1446 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1447 }
1448 return 0;
1449
1450 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1451 if (i->thread_info.muted != i->muted) {
1452 i->thread_info.muted = i->muted;
1453 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1454 }
1455 return 0;
1456
1457 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1458 pa_usec_t *r = userdata;
1459
1460 r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1461 r[1] += pa_sink_get_latency_within_thread(i->sink);
1462
1463 return 0;
1464 }
1465
1466 case PA_SINK_INPUT_MESSAGE_SET_RATE:
1467
1468 i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1469 pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1470
1471 return 0;
1472
1473 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1474 pa_sink_input *ssync;
1475
1476 pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
1477
1478 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
1479 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1480
1481 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
1482 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1483
1484 return 0;
1485 }
1486
1487 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
1488 pa_usec_t *usec = userdata;
1489
1490 *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
1491 return 0;
1492 }
1493
1494 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
1495 pa_usec_t *r = userdata;
1496
1497 *r = i->thread_info.requested_sink_latency;
1498 return 0;
1499 }
1500 }
1501
1502 return -PA_ERR_NOTIMPLEMENTED;
1503 }
1504
1505 /* Called from main thread */
1506 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
1507 pa_sink_input_assert_ref(i);
1508 pa_assert_ctl_context();
1509
1510 if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
1511 return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
1512
1513 return i->state;
1514 }
1515
1516 /* Called from IO context */
1517 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
1518 pa_sink_input_assert_ref(i);
1519 pa_sink_input_assert_io_context(i);
1520
1521 if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
1522 return pa_memblockq_is_empty(i->thread_info.render_memblockq);
1523
1524 return TRUE;
1525 }
1526
1527 /* Called from IO context */
1528 void pa_sink_input_request_rewind(
1529 pa_sink_input *i,
1530 size_t nbytes /* in our sample spec */,
1531 pa_bool_t rewrite,
1532 pa_bool_t flush,
1533 pa_bool_t dont_rewind_render) {
1534
1535 size_t lbq;
1536
1537 /* If 'rewrite' is TRUE the sink is rewound as far as requested
1538 * and possible and the exact value of this is passed back the
1539 * implementor via process_rewind(). If 'flush' is also TRUE all
1540 * already rendered data is also dropped.
1541 *
1542 * If 'rewrite' is FALSE the sink is rewound as far as requested
1543 * and possible and the already rendered data is dropped so that
1544 * in the next iteration we read new data from the
1545 * implementor. This implies 'flush' is TRUE. If
1546 * dont_rewind_render is TRUE then the render memblockq is not
1547 * rewound. */
1548
1549 /* nbytes = 0 means maximum rewind request */
1550
1551 pa_sink_input_assert_ref(i);
1552 pa_sink_input_assert_io_context(i);
1553 pa_assert(rewrite || flush);
1554 pa_assert(!dont_rewind_render || !rewrite);
1555
1556 /* We don't take rewind requests while we are corked */
1557 if (i->thread_info.state == PA_SINK_INPUT_CORKED)
1558 return;
1559
1560 nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
1561
1562 /* pa_log_debug("request rewrite %zu", nbytes); */
1563
1564 /* Calculate how much we can rewind locally without having to
1565 * touch the sink */
1566 if (rewrite)
1567 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1568 else
1569 lbq = 0;
1570
1571 /* Check if rewinding for the maximum is requested, and if so, fix up */
1572 if (nbytes <= 0) {
1573
1574 /* Calculate maximum number of bytes that could be rewound in theory */
1575 nbytes = i->sink->thread_info.max_rewind + lbq;
1576
1577 /* Transform from sink domain */
1578 if (i->thread_info.resampler)
1579 nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
1580 }
1581
1582 /* Remember how much we actually want to rewrite */
1583 if (i->thread_info.rewrite_nbytes != (size_t) -1) {
1584 if (rewrite) {
1585 /* Make sure to not overwrite over underruns */
1586 if (nbytes > i->thread_info.playing_for)
1587 nbytes = (size_t) i->thread_info.playing_for;
1588
1589 i->thread_info.rewrite_nbytes = nbytes;
1590 } else
1591 i->thread_info.rewrite_nbytes = (size_t) -1;
1592 }
1593
1594 i->thread_info.rewrite_flush =
1595 i->thread_info.rewrite_flush ||
1596 (flush && i->thread_info.rewrite_nbytes != 0);
1597
1598 i->thread_info.dont_rewind_render =
1599 i->thread_info.dont_rewind_render ||
1600 dont_rewind_render;
1601
1602 if (nbytes != (size_t) -1) {
1603
1604 /* Transform to sink domain */
1605 if (i->thread_info.resampler)
1606 nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
1607
1608 if (nbytes > lbq)
1609 pa_sink_request_rewind(i->sink, nbytes - lbq);
1610 else
1611 /* This call will make sure process_rewind() is called later */
1612 pa_sink_request_rewind(i->sink, 0);
1613 }
1614 }
1615
1616 /* Called from main context */
1617 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
1618 pa_sink_input_assert_ref(i);
1619 pa_assert_ctl_context();
1620 pa_assert(ret);
1621
1622 /* FIXME: Shouldn't access resampler object from main context! */
1623
1624 pa_silence_memchunk_get(
1625 &i->core->silence_cache,
1626 i->core->mempool,
1627 ret,
1628 &i->sample_spec,
1629 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
1630
1631 return ret;
1632 }
1633
1634 /* Called from main context */
1635 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
1636 pa_proplist *pl = NULL;
1637 pa_sink_input_send_event_hook_data hook_data;
1638
1639 pa_sink_input_assert_ref(i);
1640 pa_assert_ctl_context();
1641 pa_assert(event);
1642
1643 if (!i->send_event)
1644 return;
1645
1646 if (!data)
1647 data = pl = pa_proplist_new();
1648
1649 hook_data.sink_input = i;
1650 hook_data.data = data;
1651 hook_data.event = event;
1652
1653 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
1654 goto finish;
1655
1656 i->send_event(i, event, data);
1657
1658 finish:
1659 if (pl)
1660 pa_proplist_free(pl);
1661 }