]> code.delx.au - pulseaudio/blob - src/pulsecore/sink-input.c
delx.au / code / pulseaudio / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
sink, source: Prevent unnecessary rate update attempts
[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
30 #include <pulse/utf8.h>
31 #include <pulse/xmalloc.h>
32 #include <pulse/util.h>
33 #include <pulse/internal.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 SINK_INPUT_DEBUG */
45
46 #define MEMBLOCKQ_MAXLENGTH (32*1024*1024)
47 #define CONVERT_BUFFER_LENGTH (PA_PAGE_SIZE)
48
49 PA_DEFINE_PUBLIC_CLASS(pa_sink_input, pa_msgobject);
50
51 static void sink_input_free(pa_object *o);
52 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v);
53
54 static int check_passthrough_connection(pa_bool_t passthrough, pa_sink *dest) {
55 if (pa_sink_is_passthrough(dest)) {
56 pa_log_warn("Sink is already connected to PASSTHROUGH input");
57 return -PA_ERR_BUSY;
58 }
59
60 /* If current input(s) exist, check new input is not PASSTHROUGH */
61 if (pa_idxset_size(dest->inputs) > 0 && passthrough) {
62 pa_log_warn("Sink is already connected, cannot accept new PASSTHROUGH INPUT");
63 return -PA_ERR_BUSY;
64 }
65
66 return PA_OK;
67 }
68
69 pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data) {
70 pa_assert(data);
71
72 pa_zero(*data);
73 data->resample_method = PA_RESAMPLER_INVALID;
74 data->proplist = pa_proplist_new();
75 data->volume_writable = TRUE;
76
77 return data;
78 }
79
80 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec) {
81 pa_assert(data);
82
83 if ((data->sample_spec_is_set = !!spec))
84 data->sample_spec = *spec;
85 }
86
87 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map) {
88 pa_assert(data);
89
90 if ((data->channel_map_is_set = !!map))
91 data->channel_map = *map;
92 }
93
94 pa_bool_t pa_sink_input_new_data_is_passthrough(pa_sink_input_new_data *data) {
95 pa_assert(data);
96
97 if (PA_LIKELY(data->format) && PA_UNLIKELY(!pa_format_info_is_pcm(data->format)))
98 return TRUE;
99
100 if (PA_UNLIKELY(data->flags & PA_SINK_INPUT_PASSTHROUGH))
101 return TRUE;
102
103 return FALSE;
104 }
105
106 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume) {
107 pa_assert(data);
108 pa_assert(data->volume_writable);
109
110 if ((data->volume_is_set = !!volume))
111 data->volume = *volume;
112 }
113
114 void pa_sink_input_new_data_apply_volume_factor(pa_sink_input_new_data *data, const pa_cvolume *volume_factor) {
115 pa_assert(data);
116 pa_assert(volume_factor);
117
118 if (data->volume_factor_is_set)
119 pa_sw_cvolume_multiply(&data->volume_factor, &data->volume_factor, volume_factor);
120 else {
121 data->volume_factor_is_set = TRUE;
122 data->volume_factor = *volume_factor;
123 }
124 }
125
126 void pa_sink_input_new_data_apply_volume_factor_sink(pa_sink_input_new_data *data, const pa_cvolume *volume_factor) {
127 pa_assert(data);
128 pa_assert(volume_factor);
129
130 if (data->volume_factor_sink_is_set)
131 pa_sw_cvolume_multiply(&data->volume_factor_sink, &data->volume_factor_sink, volume_factor);
132 else {
133 data->volume_factor_sink_is_set = TRUE;
134 data->volume_factor_sink = *volume_factor;
135 }
136 }
137
138 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, pa_bool_t mute) {
139 pa_assert(data);
140
141 data->muted_is_set = TRUE;
142 data->muted = !!mute;
143 }
144
145 pa_bool_t pa_sink_input_new_data_set_sink(pa_sink_input_new_data *data, pa_sink *s, pa_bool_t save) {
146 pa_bool_t ret = TRUE;
147 pa_idxset *formats = NULL;
148
149 pa_assert(data);
150 pa_assert(s);
151
152 if (!data->req_formats) {
153 /* We're not working with the extended API */
154 data->sink = s;
155 data->save_sink = save;
156 } else {
157 /* Extended API: let's see if this sink supports the formats the client can provide */
158 formats = pa_sink_check_formats(s, data->req_formats);
159
160 if (formats && !pa_idxset_isempty(formats)) {
161 /* Sink supports at least one of the requested formats */
162 data->sink = s;
163 data->save_sink = save;
164 if (data->nego_formats)
165 pa_idxset_free(data->nego_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
166 data->nego_formats = formats;
167 } else {
168 /* Sink doesn't support any of the formats requested by the client */
169 if (formats)
170 pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
171 ret = FALSE;
172 }
173 }
174
175 return ret;
176 }
177
178 pa_bool_t pa_sink_input_new_data_set_formats(pa_sink_input_new_data *data, pa_idxset *formats) {
179 pa_assert(data);
180 pa_assert(formats);
181
182 if (data->req_formats)
183 pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
184
185 data->req_formats = formats;
186
187 if (data->sink) {
188 /* Trigger format negotiation */
189 return pa_sink_input_new_data_set_sink(data, data->sink, data->save_sink);
190 }
191
192 return TRUE;
193 }
194
195 void pa_sink_input_new_data_done(pa_sink_input_new_data *data) {
196 pa_assert(data);
197
198 if (data->req_formats)
199 pa_idxset_free(data->req_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
200
201 if (data->nego_formats)
202 pa_idxset_free(data->nego_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
203
204 if (data->format)
205 pa_format_info_free(data->format);
206
207 pa_proplist_free(data->proplist);
208 }
209
210 /* Called from main context */
211 static void reset_callbacks(pa_sink_input *i) {
212 pa_assert(i);
213
214 i->pop = NULL;
215 i->process_rewind = NULL;
216 i->update_max_rewind = NULL;
217 i->update_max_request = NULL;
218 i->update_sink_requested_latency = NULL;
219 i->update_sink_latency_range = NULL;
220 i->update_sink_fixed_latency = NULL;
221 i->attach = NULL;
222 i->detach = NULL;
223 i->suspend = NULL;
224 i->suspend_within_thread = NULL;
225 i->moving = NULL;
226 i->kill = NULL;
227 i->get_latency = NULL;
228 i->state_change = NULL;
229 i->may_move_to = NULL;
230 i->send_event = NULL;
231 i->volume_changed = NULL;
232 i->mute_changed = NULL;
233 }
234
235 /* Called from main context */
236 int pa_sink_input_new(
237 pa_sink_input **_i,
238 pa_core *core,
239 pa_sink_input_new_data *data) {
240
241 pa_sink_input *i;
242 pa_resampler *resampler = NULL;
243 char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
244 pa_channel_map original_cm;
245 int r;
246 char *pt;
247 char *memblockq_name;
248 pa_sample_spec ss;
249 pa_channel_map map;
250
251 pa_assert(_i);
252 pa_assert(core);
253 pa_assert(data);
254 pa_assert_ctl_context();
255
256 if (data->client)
257 pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->client->proplist);
258
259 if (data->origin_sink && (data->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
260 data->volume_writable = FALSE;
261
262 if (!data->req_formats) {
263 /* From this point on, we want to work only with formats, and get back
264 * to using the sample spec and channel map after all decisions w.r.t.
265 * routing are complete. */
266 pa_idxset *tmp = pa_idxset_new(NULL, NULL);
267 pa_format_info *f = pa_format_info_from_sample_spec(&data->sample_spec,
268 data->channel_map_is_set ? &data->channel_map : NULL);
269 pa_idxset_put(tmp, f, NULL);
270 pa_sink_input_new_data_set_formats(data, tmp);
271 }
272
273 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], data)) < 0)
274 return r;
275
276 pa_return_val_if_fail(!data->driver || pa_utf8_valid(data->driver), -PA_ERR_INVALID);
277
278 if (!data->sink) {
279 pa_sink *sink = pa_namereg_get(core, NULL, PA_NAMEREG_SINK);
280 pa_return_val_if_fail(sink, -PA_ERR_NOENTITY);
281 pa_sink_input_new_data_set_sink(data, sink, FALSE);
282 }
283 /* Routing's done, we have a sink. Now let's fix the format and set up the
284 * sample spec */
285
286 /* If something didn't pick a format for us, pick the top-most format since
287 * we assume this is sorted in priority order */
288 if (!data->format && data->nego_formats && !pa_idxset_isempty(data->nego_formats))
289 data->format = pa_format_info_copy(pa_idxset_first(data->nego_formats, NULL));
290
291 pa_return_val_if_fail(data->format, -PA_ERR_NOTSUPPORTED);
292
293 /* Now populate the sample spec and format according to the final
294 * format that we've negotiated */
295 pa_return_val_if_fail(pa_format_info_to_sample_spec(data->format, &ss, &map) == 0, -PA_ERR_INVALID);
296 pa_sink_input_new_data_set_sample_spec(data, &ss);
297 if (pa_format_info_is_pcm(data->format) && pa_channel_map_valid(&map))
298 pa_sink_input_new_data_set_channel_map(data, &map);
299
300 pa_return_val_if_fail(PA_SINK_IS_LINKED(pa_sink_get_state(data->sink)), -PA_ERR_BADSTATE);
301 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);
302
303 r = check_passthrough_connection(pa_sink_input_new_data_is_passthrough(data), data->sink);
304 if (r != PA_OK)
305 return r;
306
307 if (!data->sample_spec_is_set)
308 data->sample_spec = data->sink->sample_spec;
309
310 pa_return_val_if_fail(pa_sample_spec_valid(&data->sample_spec), -PA_ERR_INVALID);
311
312 if (!data->channel_map_is_set) {
313 if (pa_channel_map_compatible(&data->sink->channel_map, &data->sample_spec))
314 data->channel_map = data->sink->channel_map;
315 else
316 pa_channel_map_init_extend(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
317 }
318
319 pa_return_val_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec), -PA_ERR_INVALID);
320
321 /* Don't restore (or save) stream volume for passthrough streams and
322 * prevent attenuation/gain */
323 if (pa_sink_input_new_data_is_passthrough(data)) {
324 data->volume_is_set = TRUE;
325 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
326 data->volume_is_absolute = TRUE;
327 data->save_volume = FALSE;
328 }
329
330 if (!data->volume_is_set) {
331 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
332 data->volume_is_absolute = FALSE;
333 data->save_volume = FALSE;
334 }
335
336 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec), -PA_ERR_INVALID);
337
338 if (!data->volume_factor_is_set)
339 pa_cvolume_reset(&data->volume_factor, data->sample_spec.channels);
340
341 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume_factor, &data->sample_spec), -PA_ERR_INVALID);
342
343 if (!data->volume_factor_sink_is_set)
344 pa_cvolume_reset(&data->volume_factor_sink, data->sink->sample_spec.channels);
345
346 pa_return_val_if_fail(pa_cvolume_compatible(&data->volume_factor_sink, &data->sink->sample_spec), -PA_ERR_INVALID);
347
348 if (!data->muted_is_set)
349 data->muted = FALSE;
350
351 if (data->flags & PA_SINK_INPUT_FIX_FORMAT)
352 data->sample_spec.format = data->sink->sample_spec.format;
353
354 if (data->flags & PA_SINK_INPUT_FIX_RATE)
355 data->sample_spec.rate = data->sink->sample_spec.rate;
356
357 original_cm = data->channel_map;
358
359 if (data->flags & PA_SINK_INPUT_FIX_CHANNELS) {
360 data->sample_spec.channels = data->sink->sample_spec.channels;
361 data->channel_map = data->sink->channel_map;
362 }
363
364 pa_assert(pa_sample_spec_valid(&data->sample_spec));
365 pa_assert(pa_channel_map_valid(&data->channel_map));
366
367 if (!(data->flags & PA_SINK_INPUT_VARIABLE_RATE) &&
368 !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec)) {
369 /* try to change sink rate. This is done before the FIXATE hook since
370 module-suspend-on-idle can resume a sink */
371
372 pa_log_info("Trying to change sample rate");
373 if (pa_sink_update_rate(data->sink, data->sample_spec.rate, pa_sink_input_new_data_is_passthrough(data)) == TRUE)
374 pa_log_info("Rate changed to %u Hz", data->sink->sample_spec.rate);
375 }
376
377 /* Due to the fixing of the sample spec the volume might not match anymore */
378 pa_cvolume_remap(&data->volume, &original_cm, &data->channel_map);
379
380 if (data->resample_method == PA_RESAMPLER_INVALID)
381 data->resample_method = core->resample_method;
382
383 pa_return_val_if_fail(data->resample_method < PA_RESAMPLER_MAX, -PA_ERR_INVALID);
384
385 if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], data)) < 0)
386 return r;
387
388 if ((data->flags & PA_SINK_INPUT_NO_CREATE_ON_SUSPEND) &&
389 pa_sink_get_state(data->sink) == PA_SINK_SUSPENDED) {
390 pa_log_warn("Failed to create sink input: sink is suspended.");
391 return -PA_ERR_BADSTATE;
392 }
393
394 if (pa_idxset_size(data->sink->inputs) >= PA_MAX_INPUTS_PER_SINK) {
395 pa_log_warn("Failed to create sink input: too many inputs per sink.");
396 return -PA_ERR_TOOLARGE;
397 }
398
399 if ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
400 !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec) ||
401 !pa_channel_map_equal(&data->channel_map, &data->sink->channel_map)) {
402
403 /* Note: for passthrough content we need to adjust the output rate to that of the current sink-input */
404 if (!pa_sink_input_new_data_is_passthrough(data)) /* no resampler for passthrough content */
405 if (!(resampler = pa_resampler_new(
406 core->mempool,
407 &data->sample_spec, &data->channel_map,
408 &data->sink->sample_spec, &data->sink->channel_map,
409 data->resample_method,
410 ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
411 ((data->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
412 (core->disable_remixing || (data->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0) |
413 (core->disable_lfe_remixing ? PA_RESAMPLER_NO_LFE : 0)))) {
414 pa_log_warn("Unsupported resampling operation.");
415 return -PA_ERR_NOTSUPPORTED;
416 }
417 }
418
419 i = pa_msgobject_new(pa_sink_input);
420 i->parent.parent.free = sink_input_free;
421 i->parent.process_msg = pa_sink_input_process_msg;
422
423 i->core = core;
424 i->state = PA_SINK_INPUT_INIT;
425 i->flags = data->flags;
426 i->proplist = pa_proplist_copy(data->proplist);
427 i->driver = pa_xstrdup(pa_path_get_filename(data->driver));
428 i->module = data->module;
429 i->sink = data->sink;
430 i->origin_sink = data->origin_sink;
431 i->client = data->client;
432
433 i->requested_resample_method = data->resample_method;
434 i->actual_resample_method = resampler ? pa_resampler_get_method(resampler) : PA_RESAMPLER_INVALID;
435 i->sample_spec = data->sample_spec;
436 i->channel_map = data->channel_map;
437 i->format = pa_format_info_copy(data->format);
438
439 if (!data->volume_is_absolute && pa_sink_flat_volume_enabled(i->sink)) {
440 pa_cvolume remapped;
441
442 /* When the 'absolute' bool is not set then we'll treat the volume
443 * as relative to the sink volume even in flat volume mode */
444 remapped = data->sink->reference_volume;
445 pa_cvolume_remap(&remapped, &data->sink->channel_map, &data->channel_map);
446 pa_sw_cvolume_multiply(&i->volume, &data->volume, &remapped);
447 } else
448 i->volume = data->volume;
449
450 i->volume_factor = data->volume_factor;
451 i->volume_factor_sink = data->volume_factor_sink;
452 i->real_ratio = i->reference_ratio = data->volume;
453 pa_cvolume_reset(&i->soft_volume, i->sample_spec.channels);
454 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
455 i->volume_writable = data->volume_writable;
456 i->save_volume = data->save_volume;
457 i->save_sink = data->save_sink;
458 i->save_muted = data->save_muted;
459
460 i->muted = data->muted;
461
462 if (data->sync_base) {
463 i->sync_next = data->sync_base->sync_next;
464 i->sync_prev = data->sync_base;
465
466 if (data->sync_base->sync_next)
467 data->sync_base->sync_next->sync_prev = i;
468 data->sync_base->sync_next = i;
469 } else
470 i->sync_next = i->sync_prev = NULL;
471
472 i->direct_outputs = pa_idxset_new(NULL, NULL);
473
474 reset_callbacks(i);
475 i->userdata = NULL;
476
477 i->thread_info.state = i->state;
478 i->thread_info.attached = FALSE;
479 pa_atomic_store(&i->thread_info.drained, 1);
480 i->thread_info.sample_spec = i->sample_spec;
481 i->thread_info.resampler = resampler;
482 i->thread_info.soft_volume = i->soft_volume;
483 i->thread_info.muted = i->muted;
484 i->thread_info.requested_sink_latency = (pa_usec_t) -1;
485 i->thread_info.rewrite_nbytes = 0;
486 i->thread_info.rewrite_flush = FALSE;
487 i->thread_info.dont_rewind_render = FALSE;
488 i->thread_info.underrun_for = (uint64_t) -1;
489 i->thread_info.playing_for = 0;
490 i->thread_info.direct_outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
491
492 pa_assert_se(pa_idxset_put(core->sink_inputs, i, &i->index) == 0);
493 pa_assert_se(pa_idxset_put(i->sink->inputs, pa_sink_input_ref(i), NULL) == 0);
494
495 if (i->client)
496 pa_assert_se(pa_idxset_put(i->client->sink_inputs, i, NULL) >= 0);
497
498 memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
499 i->thread_info.render_memblockq = pa_memblockq_new(
500 memblockq_name,
501 0,
502 MEMBLOCKQ_MAXLENGTH,
503 0,
504 &i->sink->sample_spec,
505 0,
506 1,
507 0,
508 &i->sink->silence);
509 pa_xfree(memblockq_name);
510
511 pt = pa_proplist_to_string_sep(i->proplist, "\n ");
512 pa_log_info("Created input %u \"%s\" on %s with sample spec %s and channel map %s\n %s",
513 i->index,
514 pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)),
515 i->sink->name,
516 pa_sample_spec_snprint(st, sizeof(st), &i->sample_spec),
517 pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
518 pt);
519 pa_xfree(pt);
520
521 /* Don't forget to call pa_sink_input_put! */
522
523 *_i = i;
524 return 0;
525 }
526
527 /* Called from main context */
528 static void update_n_corked(pa_sink_input *i, pa_sink_input_state_t state) {
529 pa_assert(i);
530 pa_assert_ctl_context();
531
532 if (!i->sink)
533 return;
534
535 if (i->state == PA_SINK_INPUT_CORKED && state != PA_SINK_INPUT_CORKED)
536 pa_assert_se(i->sink->n_corked -- >= 1);
537 else if (i->state != PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_CORKED)
538 i->sink->n_corked++;
539 }
540
541 /* Called from main context */
542 static void sink_input_set_state(pa_sink_input *i, pa_sink_input_state_t state) {
543 pa_sink_input *ssync;
544 pa_assert(i);
545 pa_assert_ctl_context();
546
547 if (state == PA_SINK_INPUT_DRAINED)
548 state = PA_SINK_INPUT_RUNNING;
549
550 if (i->state == state)
551 return;
552
553 if (i->state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING && pa_sink_used_by(i->sink) == 0 &&
554 !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec)) {
555 /* We were uncorked and the sink was not playing anything -- let's try
556 * to update the sample rate to avoid resampling */
557 pa_sink_update_rate(i->sink, i->sample_spec.rate, pa_sink_input_is_passthrough(i));
558 }
559
560 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);
561
562 update_n_corked(i, state);
563 i->state = state;
564
565 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev) {
566 update_n_corked(ssync, state);
567 ssync->state = state;
568 }
569 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next) {
570 update_n_corked(ssync, state);
571 ssync->state = state;
572 }
573
574 if (state != PA_SINK_INPUT_UNLINKED) {
575 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], i);
576
577 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev)
578 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
579
580 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next)
581 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
582
583 if (PA_SINK_INPUT_IS_LINKED(state))
584 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
585 }
586
587 pa_sink_update_status(i->sink);
588 }
589
590 /* Called from main context */
591 void pa_sink_input_unlink(pa_sink_input *i) {
592 pa_bool_t linked;
593 pa_source_output *o, *p = NULL;
594
595 pa_assert(i);
596 pa_assert_ctl_context();
597
598 /* See pa_sink_unlink() for a couple of comments how this function
599 * works */
600
601 pa_sink_input_ref(i);
602
603 linked = PA_SINK_INPUT_IS_LINKED(i->state);
604
605 if (linked)
606 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], i);
607
608 if (i->sync_prev)
609 i->sync_prev->sync_next = i->sync_next;
610 if (i->sync_next)
611 i->sync_next->sync_prev = i->sync_prev;
612
613 i->sync_prev = i->sync_next = NULL;
614
615 pa_idxset_remove_by_data(i->core->sink_inputs, i, NULL);
616
617 if (i->sink)
618 if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL))
619 pa_sink_input_unref(i);
620
621 if (i->client)
622 pa_idxset_remove_by_data(i->client->sink_inputs, i, NULL);
623
624 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
625 pa_assert(o != p);
626 pa_source_output_kill(o);
627 p = o;
628 }
629
630 update_n_corked(i, PA_SINK_INPUT_UNLINKED);
631 i->state = PA_SINK_INPUT_UNLINKED;
632
633 if (linked && i->sink) {
634 if (pa_sink_input_is_passthrough(i))
635 pa_sink_leave_passthrough(i->sink);
636
637 /* We might need to update the sink's volume if we are in flat volume mode. */
638 if (pa_sink_flat_volume_enabled(i->sink))
639 pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
640
641 if (i->sink->asyncmsgq)
642 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_REMOVE_INPUT, i, 0, NULL) == 0);
643 }
644
645 reset_callbacks(i);
646
647 if (linked) {
648 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_REMOVE, i->index);
649 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST], i);
650 }
651
652 if (i->sink) {
653 if (PA_SINK_IS_LINKED(pa_sink_get_state(i->sink)))
654 pa_sink_update_status(i->sink);
655
656 i->sink = NULL;
657 }
658
659 pa_core_maybe_vacuum(i->core);
660
661 pa_sink_input_unref(i);
662 }
663
664 /* Called from main context */
665 static void sink_input_free(pa_object *o) {
666 pa_sink_input* i = PA_SINK_INPUT(o);
667
668 pa_assert(i);
669 pa_assert_ctl_context();
670 pa_assert(pa_sink_input_refcnt(i) == 0);
671
672 if (PA_SINK_INPUT_IS_LINKED(i->state))
673 pa_sink_input_unlink(i);
674
675 pa_log_info("Freeing input %u \"%s\"", i->index, pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)));
676
677 /* Side note: this function must be able to destruct properly any
678 * kind of sink input in any state, even those which are
679 * "half-moved" or are connected to sinks that have no asyncmsgq
680 * and are hence half-destructed themselves! */
681
682 if (i->thread_info.render_memblockq)
683 pa_memblockq_free(i->thread_info.render_memblockq);
684
685 if (i->thread_info.resampler)
686 pa_resampler_free(i->thread_info.resampler);
687
688 if (i->format)
689 pa_format_info_free(i->format);
690
691 if (i->proplist)
692 pa_proplist_free(i->proplist);
693
694 if (i->direct_outputs)
695 pa_idxset_free(i->direct_outputs, NULL, NULL);
696
697 if (i->thread_info.direct_outputs)
698 pa_hashmap_free(i->thread_info.direct_outputs, NULL, NULL);
699
700 pa_xfree(i->driver);
701 pa_xfree(i);
702 }
703
704 /* Called from main context */
705 void pa_sink_input_put(pa_sink_input *i) {
706 pa_sink_input_state_t state;
707
708 pa_sink_input_assert_ref(i);
709 pa_assert_ctl_context();
710
711 pa_assert(i->state == PA_SINK_INPUT_INIT);
712
713 /* The following fields must be initialized properly */
714 pa_assert(i->pop);
715 pa_assert(i->process_rewind);
716 pa_assert(i->kill);
717
718 state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING;
719
720 update_n_corked(i, state);
721 i->state = state;
722
723 /* We might need to update the sink's volume if we are in flat volume mode. */
724 if (pa_sink_flat_volume_enabled(i->sink))
725 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
726 else {
727 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
728 pa_assert(pa_cvolume_is_norm(&i->volume));
729 pa_assert(pa_cvolume_is_norm(&i->reference_ratio));
730 }
731
732 set_real_ratio(i, &i->volume);
733 }
734
735 if (pa_sink_input_is_passthrough(i))
736 pa_sink_enter_passthrough(i->sink);
737
738 i->thread_info.soft_volume = i->soft_volume;
739 i->thread_info.muted = i->muted;
740
741 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_ADD_INPUT, i, 0, NULL) == 0);
742
743 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, i->index);
744 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], i);
745
746 pa_sink_update_status(i->sink);
747 }
748
749 /* Called from main context */
750 void pa_sink_input_kill(pa_sink_input*i) {
751 pa_sink_input_assert_ref(i);
752 pa_assert_ctl_context();
753 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
754
755 i->kill(i);
756 }
757
758 /* Called from main context */
759 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency) {
760 pa_usec_t r[2] = { 0, 0 };
761
762 pa_sink_input_assert_ref(i);
763 pa_assert_ctl_context();
764 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
765
766 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_LATENCY, r, 0, NULL) == 0);
767
768 if (i->get_latency)
769 r[0] += i->get_latency(i);
770
771 if (sink_latency)
772 *sink_latency = r[1];
773
774 return r[0];
775 }
776
777 /* Called from thread context */
778 void pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink frames */, pa_memchunk *chunk, pa_cvolume *volume) {
779 pa_bool_t do_volume_adj_here, need_volume_factor_sink;
780 pa_bool_t volume_is_norm;
781 size_t block_size_max_sink, block_size_max_sink_input;
782 size_t ilength;
783 size_t ilength_full;
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(slength, &i->sink->sample_spec));
789 pa_assert(chunk);
790 pa_assert(volume);
791
792 #ifdef SINK_INPUT_DEBUG
793 pa_log_debug("peek");
794 #endif
795
796 block_size_max_sink_input = i->thread_info.resampler ?
797 pa_resampler_max_block_size(i->thread_info.resampler) :
798 pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sample_spec);
799
800 block_size_max_sink = pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sink->sample_spec);
801
802 /* Default buffer size */
803 if (slength <= 0)
804 slength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sink->sample_spec);
805
806 if (slength > block_size_max_sink)
807 slength = block_size_max_sink;
808
809 if (i->thread_info.resampler) {
810 ilength = pa_resampler_request(i->thread_info.resampler, slength);
811
812 if (ilength <= 0)
813 ilength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sample_spec);
814 } else
815 ilength = slength;
816
817 /* Length corresponding to slength (without limiting to
818 * block_size_max_sink_input). */
819 ilength_full = ilength;
820
821 if (ilength > block_size_max_sink_input)
822 ilength = block_size_max_sink_input;
823
824 /* If the channel maps of the sink and this stream differ, we need
825 * to adjust the volume *before* we resample. Otherwise we can do
826 * it after and leave it for the sink code */
827
828 do_volume_adj_here = !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map);
829 volume_is_norm = pa_cvolume_is_norm(&i->thread_info.soft_volume) && !i->thread_info.muted;
830 need_volume_factor_sink = !pa_cvolume_is_norm(&i->volume_factor_sink);
831
832 while (!pa_memblockq_is_readable(i->thread_info.render_memblockq)) {
833 pa_memchunk tchunk;
834
835 /* There's nothing in our render queue. We need to fill it up
836 * with data from the implementor. */
837
838 if (i->thread_info.state == PA_SINK_INPUT_CORKED ||
839 i->pop(i, ilength, &tchunk) < 0) {
840
841 /* OK, we're corked or the implementor didn't give us any
842 * data, so let's just hand out silence */
843 pa_atomic_store(&i->thread_info.drained, 1);
844
845 pa_memblockq_seek(i->thread_info.render_memblockq, (int64_t) slength, PA_SEEK_RELATIVE, TRUE);
846 i->thread_info.playing_for = 0;
847 if (i->thread_info.underrun_for != (uint64_t) -1)
848 i->thread_info.underrun_for += ilength_full;
849 break;
850 }
851
852 pa_atomic_store(&i->thread_info.drained, 0);
853
854 pa_assert(tchunk.length > 0);
855 pa_assert(tchunk.memblock);
856
857 i->thread_info.underrun_for = 0;
858 i->thread_info.playing_for += tchunk.length;
859
860 while (tchunk.length > 0) {
861 pa_memchunk wchunk;
862 pa_bool_t nvfs = need_volume_factor_sink;
863
864 wchunk = tchunk;
865 pa_memblock_ref(wchunk.memblock);
866
867 if (wchunk.length > block_size_max_sink_input)
868 wchunk.length = block_size_max_sink_input;
869
870 /* It might be necessary to adjust the volume here */
871 if (do_volume_adj_here && !volume_is_norm) {
872 pa_memchunk_make_writable(&wchunk, 0);
873
874 if (i->thread_info.muted) {
875 pa_silence_memchunk(&wchunk, &i->thread_info.sample_spec);
876 nvfs = FALSE;
877
878 } else if (!i->thread_info.resampler && nvfs) {
879 pa_cvolume v;
880
881 /* If we don't need a resampler we can merge the
882 * post and the pre volume adjustment into one */
883
884 pa_sw_cvolume_multiply(&v, &i->thread_info.soft_volume, &i->volume_factor_sink);
885 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &v);
886 nvfs = FALSE;
887
888 } else
889 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.soft_volume);
890 }
891
892 if (!i->thread_info.resampler) {
893
894 if (nvfs) {
895 pa_memchunk_make_writable(&wchunk, 0);
896 pa_volume_memchunk(&wchunk, &i->sink->sample_spec, &i->volume_factor_sink);
897 }
898
899 pa_memblockq_push_align(i->thread_info.render_memblockq, &wchunk);
900 } else {
901 pa_memchunk rchunk;
902 pa_resampler_run(i->thread_info.resampler, &wchunk, &rchunk);
903
904 #ifdef SINK_INPUT_DEBUG
905 pa_log_debug("pushing %lu", (unsigned long) rchunk.length);
906 #endif
907
908 if (rchunk.memblock) {
909
910 if (nvfs) {
911 pa_memchunk_make_writable(&rchunk, 0);
912 pa_volume_memchunk(&rchunk, &i->sink->sample_spec, &i->volume_factor_sink);
913 }
914
915 pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk);
916 pa_memblock_unref(rchunk.memblock);
917 }
918 }
919
920 pa_memblock_unref(wchunk.memblock);
921
922 tchunk.index += wchunk.length;
923 tchunk.length -= wchunk.length;
924 }
925
926 pa_memblock_unref(tchunk.memblock);
927 }
928
929 pa_assert_se(pa_memblockq_peek(i->thread_info.render_memblockq, chunk) >= 0);
930
931 pa_assert(chunk->length > 0);
932 pa_assert(chunk->memblock);
933
934 #ifdef SINK_INPUT_DEBUG
935 pa_log_debug("peeking %lu", (unsigned long) chunk->length);
936 #endif
937
938 if (chunk->length > block_size_max_sink)
939 chunk->length = block_size_max_sink;
940
941 /* Let's see if we had to apply the volume adjustment ourselves,
942 * or if this can be done by the sink for us */
943
944 if (do_volume_adj_here)
945 /* We had different channel maps, so we already did the adjustment */
946 pa_cvolume_reset(volume, i->sink->sample_spec.channels);
947 else if (i->thread_info.muted)
948 /* We've both the same channel map, so let's have the sink do the adjustment for us*/
949 pa_cvolume_mute(volume, i->sink->sample_spec.channels);
950 else
951 *volume = i->thread_info.soft_volume;
952 }
953
954 /* Called from thread context */
955 void pa_sink_input_drop(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
956
957 pa_sink_input_assert_ref(i);
958 pa_sink_input_assert_io_context(i);
959 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
960 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
961 pa_assert(nbytes > 0);
962
963 #ifdef SINK_INPUT_DEBUG
964 pa_log_debug("dropping %lu", (unsigned long) nbytes);
965 #endif
966
967 pa_memblockq_drop(i->thread_info.render_memblockq, nbytes);
968 }
969
970 /* Called from thread context */
971 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
972 size_t lbq;
973 pa_bool_t called = FALSE;
974
975 pa_sink_input_assert_ref(i);
976 pa_sink_input_assert_io_context(i);
977 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
978 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
979
980 #ifdef SINK_INPUT_DEBUG
981 pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes);
982 #endif
983
984 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
985
986 if (nbytes > 0 && !i->thread_info.dont_rewind_render) {
987 pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes);
988 pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes);
989 }
990
991 if (i->thread_info.rewrite_nbytes == (size_t) -1) {
992
993 /* We were asked to drop all buffered data, and rerequest new
994 * data from implementor the next time peek() is called */
995
996 pa_memblockq_flush_write(i->thread_info.render_memblockq, TRUE);
997
998 } else if (i->thread_info.rewrite_nbytes > 0) {
999 size_t max_rewrite, amount;
1000
1001 /* Calculate how much make sense to rewrite at most */
1002 max_rewrite = nbytes + lbq;
1003
1004 /* Transform into local domain */
1005 if (i->thread_info.resampler)
1006 max_rewrite = pa_resampler_request(i->thread_info.resampler, max_rewrite);
1007
1008 /* Calculate how much of the rewinded data should actually be rewritten */
1009 amount = PA_MIN(i->thread_info.rewrite_nbytes, max_rewrite);
1010
1011 if (amount > 0) {
1012 pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount);
1013
1014 /* Tell the implementor */
1015 if (i->process_rewind)
1016 i->process_rewind(i, amount);
1017 called = TRUE;
1018
1019 /* Convert back to to sink domain */
1020 if (i->thread_info.resampler)
1021 amount = pa_resampler_result(i->thread_info.resampler, amount);
1022
1023 if (amount > 0)
1024 /* Ok, now update the write pointer */
1025 pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) amount), PA_SEEK_RELATIVE, TRUE);
1026
1027 if (i->thread_info.rewrite_flush)
1028 pa_memblockq_silence(i->thread_info.render_memblockq);
1029
1030 /* And reset the resampler */
1031 if (i->thread_info.resampler)
1032 pa_resampler_reset(i->thread_info.resampler);
1033 }
1034 }
1035
1036 if (!called)
1037 if (i->process_rewind)
1038 i->process_rewind(i, 0);
1039
1040 i->thread_info.rewrite_nbytes = 0;
1041 i->thread_info.rewrite_flush = FALSE;
1042 i->thread_info.dont_rewind_render = FALSE;
1043 }
1044
1045 /* Called from thread context */
1046 size_t pa_sink_input_get_max_rewind(pa_sink_input *i) {
1047 pa_sink_input_assert_ref(i);
1048 pa_sink_input_assert_io_context(i);
1049
1050 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_rewind) : i->sink->thread_info.max_rewind;
1051 }
1052
1053 /* Called from thread context */
1054 size_t pa_sink_input_get_max_request(pa_sink_input *i) {
1055 pa_sink_input_assert_ref(i);
1056 pa_sink_input_assert_io_context(i);
1057
1058 /* We're not verifying the status here, to allow this to be called
1059 * in the state change handler between _INIT and _RUNNING */
1060
1061 return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_request) : i->sink->thread_info.max_request;
1062 }
1063
1064 /* Called from thread context */
1065 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1066 pa_sink_input_assert_ref(i);
1067 pa_sink_input_assert_io_context(i);
1068 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1069 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1070
1071 pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes);
1072
1073 if (i->update_max_rewind)
1074 i->update_max_rewind(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1075 }
1076
1077 /* Called from thread context */
1078 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */) {
1079 pa_sink_input_assert_ref(i);
1080 pa_sink_input_assert_io_context(i);
1081 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1082 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1083
1084 if (i->update_max_request)
1085 i->update_max_request(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1086 }
1087
1088 /* Called from thread context */
1089 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) {
1090 pa_sink_input_assert_ref(i);
1091 pa_sink_input_assert_io_context(i);
1092
1093 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1094 usec = i->sink->thread_info.fixed_latency;
1095
1096 if (usec != (pa_usec_t) -1)
1097 usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
1098
1099 i->thread_info.requested_sink_latency = usec;
1100 pa_sink_invalidate_requested_latency(i->sink, TRUE);
1101
1102 return usec;
1103 }
1104
1105 /* Called from main context */
1106 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) {
1107 pa_sink_input_assert_ref(i);
1108 pa_assert_ctl_context();
1109
1110 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1111 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1112 return usec;
1113 }
1114
1115 /* If this sink input is not realized yet or we are being moved,
1116 * we have to touch the thread info data directly */
1117
1118 if (i->sink) {
1119 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1120 usec = pa_sink_get_fixed_latency(i->sink);
1121
1122 if (usec != (pa_usec_t) -1) {
1123 pa_usec_t min_latency, max_latency;
1124 pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
1125 usec = PA_CLAMP(usec, min_latency, max_latency);
1126 }
1127 }
1128
1129 i->thread_info.requested_sink_latency = usec;
1130
1131 return usec;
1132 }
1133
1134 /* Called from main context */
1135 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
1136 pa_sink_input_assert_ref(i);
1137 pa_assert_ctl_context();
1138
1139 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1140 pa_usec_t usec = 0;
1141 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1142 return usec;
1143 }
1144
1145 /* If this sink input is not realized yet or we are being moved,
1146 * we have to touch the thread info data directly */
1147
1148 return i->thread_info.requested_sink_latency;
1149 }
1150
1151 /* Called from main context */
1152 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, pa_bool_t save, pa_bool_t absolute) {
1153 pa_cvolume v;
1154
1155 pa_sink_input_assert_ref(i);
1156 pa_assert_ctl_context();
1157 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1158 pa_assert(volume);
1159 pa_assert(pa_cvolume_valid(volume));
1160 pa_assert(volume->channels == 1 || pa_cvolume_compatible(volume, &i->sample_spec));
1161 pa_assert(i->volume_writable);
1162
1163 if (!absolute && pa_sink_flat_volume_enabled(i->sink)) {
1164 v = i->sink->reference_volume;
1165 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
1166
1167 if (pa_cvolume_compatible(volume, &i->sample_spec))
1168 volume = pa_sw_cvolume_multiply(&v, &v, volume);
1169 else
1170 volume = pa_sw_cvolume_multiply_scalar(&v, &v, pa_cvolume_max(volume));
1171 } else {
1172 if (!pa_cvolume_compatible(volume, &i->sample_spec)) {
1173 v = i->volume;
1174 volume = pa_cvolume_scale(&v, pa_cvolume_max(volume));
1175 }
1176 }
1177
1178 if (pa_cvolume_equal(volume, &i->volume)) {
1179 i->save_volume = i->save_volume || save;
1180 return;
1181 }
1182
1183 i->volume = *volume;
1184 i->save_volume = save;
1185
1186 if (pa_sink_flat_volume_enabled(i->sink)) {
1187 /* We are in flat volume mode, so let's update all sink input
1188 * volumes and update the flat volume of the sink */
1189
1190 pa_sink_set_volume(i->sink, NULL, TRUE, save);
1191
1192 } else {
1193 /* OK, we are in normal volume mode. The volume only affects
1194 * ourselves */
1195 set_real_ratio(i, volume);
1196
1197 /* Copy the new soft_volume to the thread_info struct */
1198 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1199 }
1200
1201 /* The volume changed, let's tell people so */
1202 if (i->volume_changed)
1203 i->volume_changed(i);
1204
1205 /* The virtual volume changed, let's tell people so */
1206 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1207 }
1208
1209 /* Called from main context */
1210 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
1211 pa_sink_input_assert_ref(i);
1212 pa_assert_ctl_context();
1213 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1214 pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
1215
1216 /* This basically calculates:
1217 *
1218 * i->real_ratio := v
1219 * i->soft_volume := i->real_ratio * i->volume_factor */
1220
1221 if (v)
1222 i->real_ratio = *v;
1223 else
1224 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
1225
1226 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1227 /* We don't copy the data to the thread_info data. That's left for someone else to do */
1228 }
1229
1230 /* Called from main or I/O context */
1231 pa_bool_t pa_sink_input_is_passthrough(pa_sink_input *i) {
1232 pa_sink_input_assert_ref(i);
1233
1234 if (PA_UNLIKELY(!pa_format_info_is_pcm(i->format)))
1235 return TRUE;
1236
1237 if (PA_UNLIKELY(i->flags & PA_SINK_INPUT_PASSTHROUGH))
1238 return TRUE;
1239
1240 return FALSE;
1241 }
1242
1243 /* Called from main context */
1244 pa_bool_t pa_sink_input_is_volume_readable(pa_sink_input *i) {
1245 pa_sink_input_assert_ref(i);
1246 pa_assert_ctl_context();
1247
1248 return !pa_sink_input_is_passthrough(i);
1249 }
1250
1251 /* Called from main context */
1252 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, pa_bool_t absolute) {
1253 pa_sink_input_assert_ref(i);
1254 pa_assert_ctl_context();
1255 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1256 pa_assert(pa_sink_input_is_volume_readable(i));
1257
1258 if (absolute || !pa_sink_flat_volume_enabled(i->sink))
1259 *volume = i->volume;
1260 else
1261 *volume = i->reference_ratio;
1262
1263 return volume;
1264 }
1265
1266 /* Called from main context */
1267 void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute, pa_bool_t save) {
1268 pa_sink_input_assert_ref(i);
1269 pa_assert_ctl_context();
1270 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1271
1272 if (!i->muted == !mute) {
1273 i->save_muted = i->save_muted || mute;
1274 return;
1275 }
1276
1277 i->muted = mute;
1278 i->save_muted = save;
1279
1280 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1281
1282 /* The mute status changed, let's tell people so */
1283 if (i->mute_changed)
1284 i->mute_changed(i);
1285
1286 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1287 }
1288
1289 /* Called from main context */
1290 pa_bool_t pa_sink_input_get_mute(pa_sink_input *i) {
1291 pa_sink_input_assert_ref(i);
1292 pa_assert_ctl_context();
1293 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1294
1295 return i->muted;
1296 }
1297
1298 /* Called from main thread */
1299 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1300 pa_sink_input_assert_ref(i);
1301 pa_assert_ctl_context();
1302
1303 if (p)
1304 pa_proplist_update(i->proplist, mode, p);
1305
1306 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1307 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1308 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1309 }
1310 }
1311
1312 /* Called from main context */
1313 void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b) {
1314 pa_sink_input_assert_ref(i);
1315 pa_assert_ctl_context();
1316 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1317
1318 sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1319 }
1320
1321 /* Called from main context */
1322 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1323 pa_sink_input_assert_ref(i);
1324 pa_assert_ctl_context();
1325 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1326 pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1327
1328 if (i->sample_spec.rate == rate)
1329 return 0;
1330
1331 i->sample_spec.rate = rate;
1332
1333 pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1334
1335 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1336 return 0;
1337 }
1338
1339 /* Called from main context */
1340 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1341 const char *old;
1342 pa_sink_input_assert_ref(i);
1343 pa_assert_ctl_context();
1344
1345 if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1346 return;
1347
1348 old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1349
1350 if (old && name && pa_streq(old, name))
1351 return;
1352
1353 if (name)
1354 pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1355 else
1356 pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1357
1358 if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1359 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1360 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1361 }
1362 }
1363
1364 /* Called from main context */
1365 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1366 pa_sink_input_assert_ref(i);
1367 pa_assert_ctl_context();
1368
1369 return i->actual_resample_method;
1370 }
1371
1372 /* Called from main context */
1373 pa_bool_t pa_sink_input_may_move(pa_sink_input *i) {
1374 pa_sink_input_assert_ref(i);
1375 pa_assert_ctl_context();
1376 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1377
1378 if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1379 return FALSE;
1380
1381 if (i->sync_next || i->sync_prev) {
1382 pa_log_warn("Moving synchronized streams not supported.");
1383 return FALSE;
1384 }
1385
1386 return TRUE;
1387 }
1388
1389 static pa_bool_t find_filter_sink_input(pa_sink_input *target, pa_sink *s) {
1390 int i = 0;
1391 while (s && s->input_to_master) {
1392 if (s->input_to_master == target)
1393 return TRUE;
1394 s = s->input_to_master->sink;
1395 pa_assert(i++ < 100);
1396 }
1397 return FALSE;
1398 }
1399
1400 /* Called from main context */
1401 pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1402 pa_sink_input_assert_ref(i);
1403 pa_assert_ctl_context();
1404 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1405 pa_sink_assert_ref(dest);
1406
1407 if (dest == i->sink)
1408 return TRUE;
1409
1410 if (!pa_sink_input_may_move(i))
1411 return FALSE;
1412
1413 /* Make sure we're not creating a filter sink cycle */
1414 if (find_filter_sink_input(i, dest)) {
1415 pa_log_debug("Can't connect input to %s, as that would create a cycle.", dest->name);
1416 return FALSE;
1417 }
1418
1419 if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1420 pa_log_warn("Failed to move sink input: too many inputs per sink.");
1421 return FALSE;
1422 }
1423
1424 if (check_passthrough_connection(pa_sink_input_is_passthrough(i), dest) < 0)
1425 return FALSE;
1426
1427 if (i->may_move_to)
1428 if (!i->may_move_to(i, dest))
1429 return FALSE;
1430
1431 return TRUE;
1432 }
1433
1434 /* Called from main context */
1435 int pa_sink_input_start_move(pa_sink_input *i) {
1436 pa_source_output *o, *p = NULL;
1437 int r;
1438
1439 pa_sink_input_assert_ref(i);
1440 pa_assert_ctl_context();
1441 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1442 pa_assert(i->sink);
1443
1444 if (!pa_sink_input_may_move(i))
1445 return -PA_ERR_NOTSUPPORTED;
1446
1447 if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1448 return r;
1449
1450 /* Kill directly connected outputs */
1451 while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1452 pa_assert(o != p);
1453 pa_source_output_kill(o);
1454 p = o;
1455 }
1456 pa_assert(pa_idxset_isempty(i->direct_outputs));
1457
1458 pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1459
1460 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1461 pa_assert_se(i->sink->n_corked-- >= 1);
1462
1463 if (pa_sink_input_is_passthrough(i))
1464 pa_sink_leave_passthrough(i->sink);
1465
1466 if (pa_sink_flat_volume_enabled(i->sink))
1467 /* We might need to update the sink's volume if we are in flat
1468 * volume mode. */
1469 pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
1470
1471 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1472
1473 pa_sink_update_status(i->sink);
1474 pa_cvolume_remap(&i->volume_factor_sink, &i->sink->channel_map, &i->channel_map);
1475 i->sink = NULL;
1476
1477 pa_sink_input_unref(i);
1478
1479 return 0;
1480 }
1481
1482 /* Called from main context. If i has an origin sink that uses volume sharing,
1483 * then also the origin sink and all streams connected to it need to update
1484 * their volume - this function does all that by using recursion. */
1485 static void update_volume_due_to_moving(pa_sink_input *i, pa_sink *dest) {
1486 pa_cvolume old_volume;
1487
1488 pa_assert(i);
1489 pa_assert(dest);
1490 pa_assert(i->sink); /* The destination sink should already be set. */
1491
1492 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1493 pa_sink *root_sink = pa_sink_get_master(i->sink);
1494 pa_sink_input *origin_sink_input;
1495 uint32_t idx;
1496
1497 if (PA_UNLIKELY(!root_sink))
1498 return;
1499
1500 if (pa_sink_flat_volume_enabled(i->sink)) {
1501 /* Ok, so the origin sink uses volume sharing, and flat volume is
1502 * enabled. The volume will have to be updated as follows:
1503 *
1504 * i->volume := i->sink->real_volume
1505 * (handled later by pa_sink_set_volume)
1506 * i->reference_ratio := i->volume / i->sink->reference_volume
1507 * (handled later by pa_sink_set_volume)
1508 * i->real_ratio stays unchanged
1509 * (streams whose origin sink uses volume sharing should
1510 * always have real_ratio of 0 dB)
1511 * i->soft_volume stays unchanged
1512 * (streams whose origin sink uses volume sharing should
1513 * always have volume_factor as soft_volume, so no change
1514 * should be needed) */
1515
1516 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1517 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1518
1519 /* Notifications will be sent by pa_sink_set_volume(). */
1520
1521 } else {
1522 /* Ok, so the origin sink uses volume sharing, and flat volume is
1523 * disabled. The volume will have to be updated as follows:
1524 *
1525 * i->volume := 0 dB
1526 * i->reference_ratio := 0 dB
1527 * i->real_ratio stays unchanged
1528 * (streams whose origin sink uses volume sharing should
1529 * always have real_ratio of 0 dB)
1530 * i->soft_volume stays unchanged
1531 * (streams whose origin sink uses volume sharing should
1532 * always have volume_factor as soft_volume, so no change
1533 * should be needed) */
1534
1535 old_volume = i->volume;
1536 pa_cvolume_reset(&i->volume, i->volume.channels);
1537 pa_cvolume_reset(&i->reference_ratio, i->reference_ratio.channels);
1538 pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1539 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1540
1541 /* Notify others about the changed sink input volume. */
1542 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1543 if (i->volume_changed)
1544 i->volume_changed(i);
1545
1546 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1547 }
1548 }
1549
1550 /* Additionally, the origin sink volume needs updating:
1551 *
1552 * i->origin_sink->reference_volume := root_sink->reference_volume
1553 * i->origin_sink->real_volume := root_sink->real_volume
1554 * i->origin_sink->soft_volume stays unchanged
1555 * (sinks that use volume sharing should always have
1556 * soft_volume of 0 dB) */
1557
1558 old_volume = i->origin_sink->reference_volume;
1559
1560 i->origin_sink->reference_volume = root_sink->reference_volume;
1561 pa_cvolume_remap(&i->origin_sink->reference_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1562
1563 i->origin_sink->real_volume = root_sink->real_volume;
1564 pa_cvolume_remap(&i->origin_sink->real_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1565
1566 pa_assert(pa_cvolume_is_norm(&i->origin_sink->soft_volume));
1567
1568 /* Notify others about the changed sink volume. If you wonder whether
1569 * i->origin_sink->set_volume() should be called somewhere, that's not
1570 * the case, because sinks that use volume sharing shouldn't have any
1571 * internal volume that set_volume() would update. If you wonder
1572 * whether the thread_info variables should be synced, yes, they
1573 * should, and it's done by the PA_SINK_MESSAGE_FINISH_MOVE message
1574 * handler. */
1575 if (!pa_cvolume_equal(&i->origin_sink->reference_volume, &old_volume))
1576 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, i->origin_sink->index);
1577
1578 /* Recursively update origin sink inputs. */
1579 PA_IDXSET_FOREACH(origin_sink_input, i->origin_sink->inputs, idx)
1580 update_volume_due_to_moving(origin_sink_input, dest);
1581
1582 } else {
1583 old_volume = i->volume;
1584
1585 if (pa_sink_flat_volume_enabled(i->sink)) {
1586 /* Ok, so this is a regular stream, and flat volume is enabled. The
1587 * volume will have to be updated as follows:
1588 *
1589 * i->volume := i->reference_ratio * i->sink->reference_volume
1590 * i->reference_ratio stays unchanged
1591 * i->real_ratio := i->volume / i->sink->real_volume
1592 * (handled later by pa_sink_set_volume)
1593 * i->soft_volume := i->real_ratio * i->volume_factor
1594 * (handled later by pa_sink_set_volume) */
1595
1596 i->volume = i->sink->reference_volume;
1597 pa_cvolume_remap(&i->volume, &i->sink->channel_map, &i->channel_map);
1598 pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1599
1600 } else {
1601 /* Ok, so this is a regular stream, and flat volume is disabled.
1602 * The volume will have to be updated as follows:
1603 *
1604 * i->volume := i->reference_ratio
1605 * i->reference_ratio stays unchanged
1606 * i->real_ratio := i->reference_ratio
1607 * i->soft_volume := i->real_ratio * i->volume_factor */
1608
1609 i->volume = i->reference_ratio;
1610 i->real_ratio = i->reference_ratio;
1611 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1612 }
1613
1614 /* Notify others about the changed sink input volume. */
1615 if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1616 /* XXX: In case i->sink has flat volume enabled, then real_ratio
1617 * and soft_volume are not updated yet. Let's hope that the
1618 * callback implementation doesn't care about those variables... */
1619 if (i->volume_changed)
1620 i->volume_changed(i);
1621
1622 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1623 }
1624 }
1625
1626 /* If i->sink == dest, then recursion has finished, and we can finally call
1627 * pa_sink_set_volume(), which will do the rest of the updates. */
1628 if ((i->sink == dest) && pa_sink_flat_volume_enabled(i->sink))
1629 pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
1630 }
1631
1632 /* Called from main context */
1633 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1634 pa_sink_input_assert_ref(i);
1635 pa_assert_ctl_context();
1636 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1637 pa_assert(!i->sink);
1638 pa_sink_assert_ref(dest);
1639
1640 if (!pa_sink_input_may_move_to(i, dest))
1641 return -PA_ERR_NOTSUPPORTED;
1642
1643 if (pa_sink_input_is_passthrough(i) && !pa_sink_check_format(dest, i->format)) {
1644 pa_proplist *p = pa_proplist_new();
1645 pa_log_debug("New sink doesn't support stream format, sending format-changed and killing");
1646 /* Tell the client what device we want to be on if it is going to
1647 * reconnect */
1648 pa_proplist_sets(p, "device", dest->name);
1649 pa_sink_input_send_event(i, PA_STREAM_EVENT_FORMAT_LOST, p);
1650 pa_proplist_free(p);
1651 return -PA_ERR_NOTSUPPORTED;
1652 }
1653
1654 if (!(i->flags & PA_SINK_INPUT_VARIABLE_RATE) &&
1655 !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec)) {
1656 /* try to change dest sink rate if possible without glitches.
1657 module-suspend-on-idle resumes destination sink with
1658 SINK_INPUT_MOVE_FINISH hook */
1659
1660 pa_log_info("Trying to change sample rate");
1661 if (pa_sink_update_rate(dest, i->sample_spec.rate, pa_sink_input_is_passthrough(i)) == TRUE)
1662 pa_log_info("Rate changed to %u Hz", dest->sample_spec.rate);
1663 }
1664
1665 if (i->moving)
1666 i->moving(i, dest);
1667
1668 i->sink = dest;
1669 i->save_sink = save;
1670 pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1671
1672 pa_cvolume_remap(&i->volume_factor_sink, &i->channel_map, &i->sink->channel_map);
1673
1674 if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1675 i->sink->n_corked++;
1676
1677 pa_sink_input_update_rate(i);
1678
1679 pa_sink_update_status(dest);
1680
1681 update_volume_due_to_moving(i, dest);
1682
1683 if (pa_sink_input_is_passthrough(i))
1684 pa_sink_enter_passthrough(i->sink);
1685
1686 pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1687
1688 pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1689
1690 /* Notify everyone */
1691 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1692 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1693
1694 return 0;
1695 }
1696
1697 /* Called from main context */
1698 void pa_sink_input_fail_move(pa_sink_input *i) {
1699
1700 pa_sink_input_assert_ref(i);
1701 pa_assert_ctl_context();
1702 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1703 pa_assert(!i->sink);
1704
1705 /* Check if someone wants this sink input? */
1706 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1707 return;
1708
1709 if (i->moving)
1710 i->moving(i, NULL);
1711
1712 pa_sink_input_kill(i);
1713 }
1714
1715 /* Called from main context */
1716 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1717 int r;
1718
1719 pa_sink_input_assert_ref(i);
1720 pa_assert_ctl_context();
1721 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1722 pa_assert(i->sink);
1723 pa_sink_assert_ref(dest);
1724
1725 if (dest == i->sink)
1726 return 0;
1727
1728 if (!pa_sink_input_may_move_to(i, dest))
1729 return -PA_ERR_NOTSUPPORTED;
1730
1731 pa_sink_input_ref(i);
1732
1733 if ((r = pa_sink_input_start_move(i)) < 0) {
1734 pa_sink_input_unref(i);
1735 return r;
1736 }
1737
1738 if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1739 pa_sink_input_fail_move(i);
1740 pa_sink_input_unref(i);
1741 return r;
1742 }
1743
1744 pa_sink_input_unref(i);
1745
1746 return 0;
1747 }
1748
1749 /* Called from IO thread context */
1750 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1751 pa_bool_t corking, uncorking;
1752
1753 pa_sink_input_assert_ref(i);
1754 pa_sink_input_assert_io_context(i);
1755
1756 if (state == i->thread_info.state)
1757 return;
1758
1759 if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1760 !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1761 pa_atomic_store(&i->thread_info.drained, 1);
1762
1763 corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1764 uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1765
1766 if (i->state_change)
1767 i->state_change(i, state);
1768
1769 if (corking) {
1770
1771 pa_log_debug("Requesting rewind due to corking");
1772
1773 /* This will tell the implementing sink input driver to rewind
1774 * so that the unplayed already mixed data is not lost */
1775 pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1776
1777 /* Set the corked state *after* requesting rewind */
1778 i->thread_info.state = state;
1779
1780 } else if (uncorking) {
1781
1782 pa_log_debug("Requesting rewind due to uncorking");
1783
1784 i->thread_info.underrun_for = (uint64_t) -1;
1785 i->thread_info.playing_for = 0;
1786
1787 /* Set the uncorked state *before* requesting rewind */
1788 i->thread_info.state = state;
1789
1790 /* OK, we're being uncorked. Make sure we're not rewound when
1791 * the hw buffer is remixed and request a remix. */
1792 pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1793 } else
1794 /* We may not be corking or uncorking, but we still need to set the state. */
1795 i->thread_info.state = state;
1796 }
1797
1798 /* Called from thread context, except when it is not. */
1799 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1800 pa_sink_input *i = PA_SINK_INPUT(o);
1801 pa_sink_input_assert_ref(i);
1802
1803 switch (code) {
1804
1805 case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1806 if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1807 i->thread_info.soft_volume = i->soft_volume;
1808 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1809 }
1810 return 0;
1811
1812 case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1813 if (i->thread_info.muted != i->muted) {
1814 i->thread_info.muted = i->muted;
1815 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1816 }
1817 return 0;
1818
1819 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1820 pa_usec_t *r = userdata;
1821
1822 r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1823 r[1] += pa_sink_get_latency_within_thread(i->sink);
1824
1825 return 0;
1826 }
1827
1828 case PA_SINK_INPUT_MESSAGE_SET_RATE:
1829
1830 i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1831 pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1832
1833 return 0;
1834
1835 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1836 pa_sink_input *ssync;
1837
1838 pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
1839
1840 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
1841 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1842
1843 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
1844 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1845
1846 return 0;
1847 }
1848
1849 case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
1850 pa_usec_t *usec = userdata;
1851
1852 *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
1853 return 0;
1854 }
1855
1856 case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
1857 pa_usec_t *r = userdata;
1858
1859 *r = i->thread_info.requested_sink_latency;
1860 return 0;
1861 }
1862 }
1863
1864 return -PA_ERR_NOTIMPLEMENTED;
1865 }
1866
1867 /* Called from main thread */
1868 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
1869 pa_sink_input_assert_ref(i);
1870 pa_assert_ctl_context();
1871
1872 if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
1873 return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
1874
1875 return i->state;
1876 }
1877
1878 /* Called from IO context */
1879 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
1880 pa_sink_input_assert_ref(i);
1881 pa_sink_input_assert_io_context(i);
1882
1883 if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
1884 return pa_memblockq_is_empty(i->thread_info.render_memblockq);
1885
1886 return TRUE;
1887 }
1888
1889 /* Called from IO context */
1890 void pa_sink_input_request_rewind(
1891 pa_sink_input *i,
1892 size_t nbytes /* in our sample spec */,
1893 pa_bool_t rewrite,
1894 pa_bool_t flush,
1895 pa_bool_t dont_rewind_render) {
1896
1897 size_t lbq;
1898
1899 /* If 'rewrite' is TRUE the sink is rewound as far as requested
1900 * and possible and the exact value of this is passed back the
1901 * implementor via process_rewind(). If 'flush' is also TRUE all
1902 * already rendered data is also dropped.
1903 *
1904 * If 'rewrite' is FALSE the sink is rewound as far as requested
1905 * and possible and the already rendered data is dropped so that
1906 * in the next iteration we read new data from the
1907 * implementor. This implies 'flush' is TRUE. If
1908 * dont_rewind_render is TRUE then the render memblockq is not
1909 * rewound. */
1910
1911 /* nbytes = 0 means maximum rewind request */
1912
1913 pa_sink_input_assert_ref(i);
1914 pa_sink_input_assert_io_context(i);
1915 pa_assert(rewrite || flush);
1916 pa_assert(!dont_rewind_render || !rewrite);
1917
1918 /* We don't take rewind requests while we are corked */
1919 if (i->thread_info.state == PA_SINK_INPUT_CORKED)
1920 return;
1921
1922 nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
1923
1924 #ifdef SINK_INPUT_DEBUG
1925 pa_log_debug("request rewrite %zu", nbytes);
1926 #endif
1927
1928 /* Calculate how much we can rewind locally without having to
1929 * touch the sink */
1930 if (rewrite)
1931 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1932 else
1933 lbq = 0;
1934
1935 /* Check if rewinding for the maximum is requested, and if so, fix up */
1936 if (nbytes <= 0) {
1937
1938 /* Calculate maximum number of bytes that could be rewound in theory */
1939 nbytes = i->sink->thread_info.max_rewind + lbq;
1940
1941 /* Transform from sink domain */
1942 if (i->thread_info.resampler)
1943 nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
1944 }
1945
1946 /* Remember how much we actually want to rewrite */
1947 if (i->thread_info.rewrite_nbytes != (size_t) -1) {
1948 if (rewrite) {
1949 /* Make sure to not overwrite over underruns */
1950 if (nbytes > i->thread_info.playing_for)
1951 nbytes = (size_t) i->thread_info.playing_for;
1952
1953 i->thread_info.rewrite_nbytes = nbytes;
1954 } else
1955 i->thread_info.rewrite_nbytes = (size_t) -1;
1956 }
1957
1958 i->thread_info.rewrite_flush =
1959 i->thread_info.rewrite_flush || flush;
1960
1961 i->thread_info.dont_rewind_render =
1962 i->thread_info.dont_rewind_render ||
1963 dont_rewind_render;
1964
1965 /* nbytes is -1 if some earlier rewind request had rewrite == false. */
1966 if (nbytes != (size_t) -1) {
1967
1968 /* Transform to sink domain */
1969 if (i->thread_info.resampler)
1970 nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
1971
1972 if (nbytes > lbq)
1973 pa_sink_request_rewind(i->sink, nbytes - lbq);
1974 else
1975 /* This call will make sure process_rewind() is called later */
1976 pa_sink_request_rewind(i->sink, 0);
1977 }
1978 }
1979
1980 /* Called from main context */
1981 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
1982 pa_sink_input_assert_ref(i);
1983 pa_assert_ctl_context();
1984 pa_assert(ret);
1985
1986 /* FIXME: Shouldn't access resampler object from main context! */
1987
1988 pa_silence_memchunk_get(
1989 &i->core->silence_cache,
1990 i->core->mempool,
1991 ret,
1992 &i->sample_spec,
1993 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
1994
1995 return ret;
1996 }
1997
1998 /* Called from main context */
1999 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
2000 pa_proplist *pl = NULL;
2001 pa_sink_input_send_event_hook_data hook_data;
2002
2003 pa_sink_input_assert_ref(i);
2004 pa_assert_ctl_context();
2005 pa_assert(event);
2006
2007 if (!i->send_event)
2008 return;
2009
2010 if (!data)
2011 data = pl = pa_proplist_new();
2012
2013 hook_data.sink_input = i;
2014 hook_data.data = data;
2015 hook_data.event = event;
2016
2017 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
2018 goto finish;
2019
2020 i->send_event(i, event, data);
2021
2022 finish:
2023 if (pl)
2024 pa_proplist_free(pl);
2025 }
2026
2027 /* Called from main context */
2028 /* Updates the sink input's resampler with whatever the current sink requires
2029 * -- useful when the underlying sink's rate might have changed */
2030 int pa_sink_input_update_rate(pa_sink_input *i) {
2031 pa_resampler *new_resampler;
2032 char *memblockq_name;
2033
2034 pa_sink_input_assert_ref(i);
2035 pa_assert_ctl_context();
2036
2037 if (i->thread_info.resampler &&
2038 pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &i->sink->sample_spec) &&
2039 pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &i->sink->channel_map))
2040
2041 new_resampler = i->thread_info.resampler;
2042
2043 else if (!pa_sink_input_is_passthrough(i) &&
2044 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
2045 !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec) ||
2046 !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map))) {
2047
2048 new_resampler = pa_resampler_new(i->core->mempool,
2049 &i->sample_spec, &i->channel_map,
2050 &i->sink->sample_spec, &i->sink->channel_map,
2051 i->requested_resample_method,
2052 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
2053 ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
2054 (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0));
2055
2056 if (!new_resampler) {
2057 pa_log_warn("Unsupported resampling operation.");
2058 return -PA_ERR_NOTSUPPORTED;
2059 }
2060 } else
2061 new_resampler = NULL;
2062
2063 if (new_resampler == i->thread_info.resampler)
2064 return 0;
2065
2066 if (i->thread_info.resampler)
2067 pa_resampler_free(i->thread_info.resampler);
2068
2069 i->thread_info.resampler = new_resampler;
2070
2071 pa_memblockq_free(i->thread_info.render_memblockq);
2072
2073 memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
2074 i->thread_info.render_memblockq = pa_memblockq_new(
2075 memblockq_name,
2076 0,
2077 MEMBLOCKQ_MAXLENGTH,
2078 0,
2079 &i->sink->sample_spec,
2080 0,
2081 1,
2082 0,
2083 &i->sink->silence);
2084 pa_xfree(memblockq_name);
2085
2086 i->actual_resample_method = new_resampler ? pa_resampler_get_method(new_resampler) : PA_RESAMPLER_INVALID;
2087
2088 pa_log_debug("Updated resampler for sink input %d", i->index);
2089
2090 return 0;
2091 }