]> code.delx.au - pulseaudio/blob - src/pulsecore/sink.c
delx.au / code / pulseaudio / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
introduce relative_volume field in sink_input and make use of it on sink flat volume...
[pulseaudio] / src / pulsecore / sink.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 <stdlib.h>
28 #include <string.h>
29 #include <stdio.h>
30
31 #include <pulse/introspect.h>
32 #include <pulse/utf8.h>
33 #include <pulse/xmalloc.h>
34 #include <pulse/timeval.h>
35 #include <pulse/util.h>
36 #include <pulse/i18n.h>
37
38 #include <pulsecore/sink-input.h>
39 #include <pulsecore/namereg.h>
40 #include <pulsecore/core-util.h>
41 #include <pulsecore/sample-util.h>
42 #include <pulsecore/core-subscribe.h>
43 #include <pulsecore/log.h>
44 #include <pulsecore/macro.h>
45 #include <pulsecore/play-memblockq.h>
46
47 #include "sink.h"
48
49 #define MAX_MIX_CHANNELS 32
50 #define MIX_BUFFER_LENGTH (PA_PAGE_SIZE)
51 #define ABSOLUTE_MIN_LATENCY (500)
52 #define ABSOLUTE_MAX_LATENCY (10*PA_USEC_PER_SEC)
53
54 static PA_DEFINE_CHECK_TYPE(pa_sink, pa_msgobject);
55
56 static void sink_free(pa_object *s);
57
58 pa_sink_new_data* pa_sink_new_data_init(pa_sink_new_data *data) {
59 pa_assert(data);
60
61 memset(data, 0, sizeof(*data));
62 data->proplist = pa_proplist_new();
63
64 return data;
65 }
66
67 void pa_sink_new_data_set_name(pa_sink_new_data *data, const char *name) {
68 pa_assert(data);
69
70 pa_xfree(data->name);
71 data->name = pa_xstrdup(name);
72 }
73
74 void pa_sink_new_data_set_sample_spec(pa_sink_new_data *data, const pa_sample_spec *spec) {
75 pa_assert(data);
76
77 if ((data->sample_spec_is_set = !!spec))
78 data->sample_spec = *spec;
79 }
80
81 void pa_sink_new_data_set_channel_map(pa_sink_new_data *data, const pa_channel_map *map) {
82 pa_assert(data);
83
84 if ((data->channel_map_is_set = !!map))
85 data->channel_map = *map;
86 }
87
88 void pa_sink_new_data_set_volume(pa_sink_new_data *data, const pa_cvolume *volume) {
89 pa_assert(data);
90
91 if ((data->volume_is_set = !!volume))
92 data->volume = *volume;
93 }
94
95 void pa_sink_new_data_set_muted(pa_sink_new_data *data, pa_bool_t mute) {
96 pa_assert(data);
97
98 data->muted_is_set = TRUE;
99 data->muted = !!mute;
100 }
101
102 void pa_sink_new_data_done(pa_sink_new_data *data) {
103 pa_assert(data);
104
105 pa_xfree(data->name);
106 pa_proplist_free(data->proplist);
107 }
108
109 /* Called from main context */
110 static void reset_callbacks(pa_sink *s) {
111 pa_assert(s);
112
113 s->set_state = NULL;
114 s->get_volume = NULL;
115 s->set_volume = NULL;
116 s->get_mute = NULL;
117 s->set_mute = NULL;
118 s->request_rewind = NULL;
119 s->update_requested_latency = NULL;
120 }
121
122 /* Called from main context */
123 pa_sink* pa_sink_new(
124 pa_core *core,
125 pa_sink_new_data *data,
126 pa_sink_flags_t flags) {
127
128 pa_sink *s;
129 const char *name;
130 char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
131 pa_source_new_data source_data;
132 const char *dn;
133 char *pt;
134
135 pa_assert(core);
136 pa_assert(data);
137 pa_assert(data->name);
138
139 s = pa_msgobject_new(pa_sink);
140
141 if (!(name = pa_namereg_register(core, data->name, PA_NAMEREG_SINK, s, data->namereg_fail))) {
142 pa_xfree(s);
143 return NULL;
144 }
145
146 pa_sink_new_data_set_name(data, name);
147
148 if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_NEW], data) < 0) {
149 pa_xfree(s);
150 pa_namereg_unregister(core, name);
151 return NULL;
152 }
153
154 pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver));
155 pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]);
156
157 pa_return_null_if_fail(data->sample_spec_is_set && pa_sample_spec_valid(&data->sample_spec));
158
159 if (!data->channel_map_is_set)
160 pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
161
162 pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
163 pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
164
165 if (!data->volume_is_set)
166 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
167
168 pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
169 pa_return_null_if_fail(data->volume.channels == data->sample_spec.channels);
170
171 if (!data->muted_is_set)
172 data->muted = FALSE;
173
174 if (data->card)
175 pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
176
177 pa_device_init_description(data->proplist);
178 pa_device_init_icon(data->proplist, TRUE);
179
180 if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_FIXATE], data) < 0) {
181 pa_xfree(s);
182 pa_namereg_unregister(core, name);
183 return NULL;
184 }
185
186 s->parent.parent.free = sink_free;
187 s->parent.process_msg = pa_sink_process_msg;
188
189 s->core = core;
190 s->state = PA_SINK_INIT;
191 s->flags = flags;
192 s->name = pa_xstrdup(name);
193 s->proplist = pa_proplist_copy(data->proplist);
194 s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
195 s->module = data->module;
196 s->card = data->card;
197
198 s->sample_spec = data->sample_spec;
199 s->channel_map = data->channel_map;
200
201 s->inputs = pa_idxset_new(NULL, NULL);
202 s->n_corked = 0;
203
204 s->virtual_volume = data->volume;
205 pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
206 s->base_volume = PA_VOLUME_NORM;
207 s->n_volume_steps = PA_VOLUME_NORM+1;
208 s->muted = data->muted;
209 s->refresh_volume = s->refresh_muted = FALSE;
210
211 reset_callbacks(s);
212 s->userdata = NULL;
213
214 s->asyncmsgq = NULL;
215 s->rtpoll = NULL;
216
217 pa_silence_memchunk_get(
218 &core->silence_cache,
219 core->mempool,
220 &s->silence,
221 &s->sample_spec,
222 0);
223
224 s->thread_info.inputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
225 s->thread_info.soft_volume = s->soft_volume;
226 s->thread_info.soft_muted = s->muted;
227 s->thread_info.state = s->state;
228 s->thread_info.rewind_nbytes = 0;
229 s->thread_info.rewind_requested = FALSE;
230 s->thread_info.max_rewind = 0;
231 s->thread_info.max_request = 0;
232 s->thread_info.requested_latency_valid = FALSE;
233 s->thread_info.requested_latency = 0;
234 s->thread_info.min_latency = ABSOLUTE_MIN_LATENCY;
235 s->thread_info.max_latency = ABSOLUTE_MAX_LATENCY;
236
237 pa_assert_se(pa_idxset_put(core->sinks, s, &s->index) >= 0);
238
239 if (s->card)
240 pa_assert_se(pa_idxset_put(s->card->sinks, s, NULL) >= 0);
241
242 pt = pa_proplist_to_string_sep(s->proplist, "\n ");
243 pa_log_info("Created sink %u \"%s\" with sample spec %s and channel map %s\n %s",
244 s->index,
245 s->name,
246 pa_sample_spec_snprint(st, sizeof(st), &s->sample_spec),
247 pa_channel_map_snprint(cm, sizeof(cm), &s->channel_map),
248 pt);
249 pa_xfree(pt);
250
251 pa_source_new_data_init(&source_data);
252 pa_source_new_data_set_sample_spec(&source_data, &s->sample_spec);
253 pa_source_new_data_set_channel_map(&source_data, &s->channel_map);
254 source_data.name = pa_sprintf_malloc("%s.monitor", name);
255 source_data.driver = data->driver;
256 source_data.module = data->module;
257 source_data.card = data->card;
258
259 dn = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
260 pa_proplist_setf(source_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Monitor of %s", dn ? dn : s->name);
261 pa_proplist_sets(source_data.proplist, PA_PROP_DEVICE_CLASS, "monitor");
262
263 s->monitor_source = pa_source_new(core, &source_data, 0);
264
265 pa_source_new_data_done(&source_data);
266
267 if (!s->monitor_source) {
268 pa_sink_unlink(s);
269 pa_sink_unref(s);
270 return NULL;
271 }
272
273 s->monitor_source->monitor_of = s;
274
275 pa_source_set_latency_range(s->monitor_source, s->thread_info.min_latency, s->thread_info.max_latency);
276 pa_source_set_max_rewind(s->monitor_source, s->thread_info.max_rewind);
277
278 return s;
279 }
280
281 /* Called from main context */
282 static int sink_set_state(pa_sink *s, pa_sink_state_t state) {
283 int ret;
284 pa_bool_t suspend_change;
285 pa_sink_state_t original_state;
286
287 pa_assert(s);
288
289 if (s->state == state)
290 return 0;
291
292 original_state = s->state;
293
294 suspend_change =
295 (original_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(state)) ||
296 (PA_SINK_IS_OPENED(original_state) && state == PA_SINK_SUSPENDED);
297
298 if (s->set_state)
299 if ((ret = s->set_state(s, state)) < 0)
300 return ret;
301
302 if (s->asyncmsgq)
303 if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_STATE, PA_UINT_TO_PTR(state), 0, NULL)) < 0) {
304
305 if (s->set_state)
306 s->set_state(s, original_state);
307
308 return ret;
309 }
310
311 s->state = state;
312
313 if (state != PA_SINK_UNLINKED) { /* if we enter UNLINKED state pa_sink_unlink() will fire the apropriate events */
314 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_STATE_CHANGED], s);
315 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
316 }
317
318 if (suspend_change) {
319 pa_sink_input *i;
320 uint32_t idx;
321
322 /* We're suspending or resuming, tell everyone about it */
323
324 for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx)))
325 if (s->state == PA_SINK_SUSPENDED &&
326 (i->flags & PA_SINK_INPUT_FAIL_ON_SUSPEND))
327 pa_sink_input_kill(i);
328 else if (i->suspend)
329 i->suspend(i, state == PA_SINK_SUSPENDED);
330
331 if (s->monitor_source)
332 pa_source_sync_suspend(s->monitor_source);
333 }
334
335 return 0;
336 }
337
338 /* Called from main context */
339 void pa_sink_put(pa_sink* s) {
340 pa_sink_assert_ref(s);
341
342 pa_assert(s->state == PA_SINK_INIT);
343
344 /* The following fields must be initialized properly when calling _put() */
345 pa_assert(s->asyncmsgq);
346 pa_assert(s->rtpoll);
347 pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency);
348
349 if (!(s->flags & PA_SINK_HW_VOLUME_CTRL)) {
350 s->flags |= PA_SINK_DECIBEL_VOLUME;
351
352 s->thread_info.soft_volume = s->soft_volume;
353 s->thread_info.soft_muted = s->muted;
354 }
355
356 if (s->flags & PA_SINK_DECIBEL_VOLUME)
357 s->n_volume_steps = PA_VOLUME_NORM+1;
358
359 if (s->core->flat_volumes)
360 if (s->flags & PA_SINK_DECIBEL_VOLUME)
361 s->flags |= PA_SINK_FLAT_VOLUME;
362
363 if (s->flags & PA_SINK_LATENCY)
364 s->monitor_source->flags |= PA_SOURCE_LATENCY;
365
366 if (s->flags & PA_SINK_DYNAMIC_LATENCY)
367 s->monitor_source->flags |= PA_SOURCE_DYNAMIC_LATENCY;
368
369 pa_assert_se(sink_set_state(s, PA_SINK_IDLE) == 0);
370
371 pa_source_put(s->monitor_source);
372
373 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_NEW, s->index);
374 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PUT], s);
375 }
376
377 /* Called from main context */
378 void pa_sink_unlink(pa_sink* s) {
379 pa_bool_t linked;
380 pa_sink_input *i, *j = NULL;
381
382 pa_assert(s);
383
384 /* Please note that pa_sink_unlink() does more than simply
385 * reversing pa_sink_put(). It also undoes the registrations
386 * already done in pa_sink_new()! */
387
388 /* All operations here shall be idempotent, i.e. pa_sink_unlink()
389 * may be called multiple times on the same sink without bad
390 * effects. */
391
392 linked = PA_SINK_IS_LINKED(s->state);
393
394 if (linked)
395 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK], s);
396
397 if (s->state != PA_SINK_UNLINKED)
398 pa_namereg_unregister(s->core, s->name);
399 pa_idxset_remove_by_data(s->core->sinks, s, NULL);
400
401 if (s->card)
402 pa_idxset_remove_by_data(s->card->sinks, s, NULL);
403
404 while ((i = pa_idxset_first(s->inputs, NULL))) {
405 pa_assert(i != j);
406 pa_sink_input_kill(i);
407 j = i;
408 }
409
410 if (linked)
411 sink_set_state(s, PA_SINK_UNLINKED);
412 else
413 s->state = PA_SINK_UNLINKED;
414
415 reset_callbacks(s);
416
417 if (s->monitor_source)
418 pa_source_unlink(s->monitor_source);
419
420 if (linked) {
421 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
422 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK_POST], s);
423 }
424 }
425
426 /* Called from main context */
427 static void sink_free(pa_object *o) {
428 pa_sink *s = PA_SINK(o);
429 pa_sink_input *i;
430
431 pa_assert(s);
432 pa_assert(pa_sink_refcnt(s) == 0);
433
434 if (PA_SINK_IS_LINKED(s->state))
435 pa_sink_unlink(s);
436
437 pa_log_info("Freeing sink %u \"%s\"", s->index, s->name);
438
439 if (s->monitor_source) {
440 pa_source_unref(s->monitor_source);
441 s->monitor_source = NULL;
442 }
443
444 pa_idxset_free(s->inputs, NULL, NULL);
445
446 while ((i = pa_hashmap_steal_first(s->thread_info.inputs)))
447 pa_sink_input_unref(i);
448
449 pa_hashmap_free(s->thread_info.inputs, NULL, NULL);
450
451 if (s->silence.memblock)
452 pa_memblock_unref(s->silence.memblock);
453
454 pa_xfree(s->name);
455 pa_xfree(s->driver);
456
457 if (s->proplist)
458 pa_proplist_free(s->proplist);
459
460 pa_xfree(s);
461 }
462
463 /* Called from main context */
464 void pa_sink_set_asyncmsgq(pa_sink *s, pa_asyncmsgq *q) {
465 pa_sink_assert_ref(s);
466
467 s->asyncmsgq = q;
468
469 if (s->monitor_source)
470 pa_source_set_asyncmsgq(s->monitor_source, q);
471 }
472
473 /* Called from main context */
474 void pa_sink_set_rtpoll(pa_sink *s, pa_rtpoll *p) {
475 pa_sink_assert_ref(s);
476
477 s->rtpoll = p;
478 if (s->monitor_source)
479 pa_source_set_rtpoll(s->monitor_source, p);
480 }
481
482 /* Called from main context */
483 int pa_sink_update_status(pa_sink*s) {
484 pa_sink_assert_ref(s);
485 pa_assert(PA_SINK_IS_LINKED(s->state));
486
487 if (s->state == PA_SINK_SUSPENDED)
488 return 0;
489
490 return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
491 }
492
493 /* Called from main context */
494 int pa_sink_suspend(pa_sink *s, pa_bool_t suspend) {
495 pa_sink_assert_ref(s);
496 pa_assert(PA_SINK_IS_LINKED(s->state));
497
498 if (suspend)
499 return sink_set_state(s, PA_SINK_SUSPENDED);
500 else
501 return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
502 }
503
504 /* Called from main context */
505 pa_queue *pa_sink_move_all_start(pa_sink *s) {
506 pa_queue *q;
507 pa_sink_input *i, *n;
508 uint32_t idx;
509
510 pa_sink_assert_ref(s);
511 pa_assert(PA_SINK_IS_LINKED(s->state));
512
513 q = pa_queue_new();
514
515 for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = n) {
516 n = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx));
517
518 if (pa_sink_input_start_move(i) >= 0)
519 pa_queue_push(q, pa_sink_input_ref(i));
520 }
521
522 return q;
523 }
524
525 /* Called from main context */
526 void pa_sink_move_all_finish(pa_sink *s, pa_queue *q, pa_bool_t save) {
527 pa_sink_input *i;
528
529 pa_sink_assert_ref(s);
530 pa_assert(PA_SINK_IS_LINKED(s->state));
531 pa_assert(q);
532
533 while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
534 if (pa_sink_input_finish_move(i, s, save) < 0)
535 pa_sink_input_kill(i);
536
537 pa_sink_input_unref(i);
538 }
539
540 pa_queue_free(q, NULL, NULL);
541 }
542
543 /* Called from main context */
544 void pa_sink_move_all_fail(pa_queue *q) {
545 pa_sink_input *i;
546 pa_assert(q);
547
548 while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
549 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_OK) {
550 pa_sink_input_kill(i);
551 pa_sink_input_unref(i);
552 }
553 }
554
555 pa_queue_free(q, NULL, NULL);
556 }
557
558 /* Called from IO thread context */
559 void pa_sink_process_rewind(pa_sink *s, size_t nbytes) {
560 pa_sink_input *i;
561 void *state = NULL;
562 pa_sink_assert_ref(s);
563 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
564
565 /* If nobody requested this and this is actually no real rewind
566 * then we can short cut this */
567 if (!s->thread_info.rewind_requested && nbytes <= 0)
568 return;
569
570 s->thread_info.rewind_nbytes = 0;
571 s->thread_info.rewind_requested = FALSE;
572
573 if (s->thread_info.state == PA_SINK_SUSPENDED)
574 return;
575
576 if (nbytes > 0)
577 pa_log_debug("Processing rewind...");
578
579 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL))) {
580 pa_sink_input_assert_ref(i);
581 pa_sink_input_process_rewind(i, nbytes);
582 }
583
584 if (nbytes > 0)
585 if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
586 pa_source_process_rewind(s->monitor_source, nbytes);
587 }
588
589 /* Called from IO thread context */
590 static unsigned fill_mix_info(pa_sink *s, size_t *length, pa_mix_info *info, unsigned maxinfo) {
591 pa_sink_input *i;
592 unsigned n = 0;
593 void *state = NULL;
594 size_t mixlength = *length;
595
596 pa_sink_assert_ref(s);
597 pa_assert(info);
598
599 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)) && maxinfo > 0) {
600 pa_sink_input_assert_ref(i);
601
602 pa_sink_input_peek(i, *length, &info->chunk, &info->volume);
603
604 if (mixlength == 0 || info->chunk.length < mixlength)
605 mixlength = info->chunk.length;
606
607 if (pa_memblock_is_silence(info->chunk.memblock)) {
608 pa_memblock_unref(info->chunk.memblock);
609 continue;
610 }
611
612 info->userdata = pa_sink_input_ref(i);
613
614 pa_assert(info->chunk.memblock);
615 pa_assert(info->chunk.length > 0);
616
617 info++;
618 n++;
619 maxinfo--;
620 }
621
622 if (mixlength > 0)
623 *length = mixlength;
624
625 return n;
626 }
627
628 /* Called from IO thread context */
629 static void inputs_drop(pa_sink *s, pa_mix_info *info, unsigned n, pa_memchunk *result) {
630 pa_sink_input *i;
631 void *state = NULL;
632 unsigned p = 0;
633 unsigned n_unreffed = 0;
634
635 pa_sink_assert_ref(s);
636 pa_assert(result);
637 pa_assert(result->memblock);
638 pa_assert(result->length > 0);
639
640 /* We optimize for the case where the order of the inputs has not changed */
641
642 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL))) {
643 unsigned j;
644 pa_mix_info* m = NULL;
645
646 pa_sink_input_assert_ref(i);
647
648 /* Let's try to find the matching entry info the pa_mix_info array */
649 for (j = 0; j < n; j ++) {
650
651 if (info[p].userdata == i) {
652 m = info + p;
653 break;
654 }
655
656 p++;
657 if (p >= n)
658 p = 0;
659 }
660
661 /* Drop read data */
662 pa_sink_input_drop(i, result->length);
663
664 if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state)) {
665
666 if (pa_hashmap_size(i->thread_info.direct_outputs) > 0) {
667 void *ostate = NULL;
668 pa_source_output *o;
669 pa_memchunk c;
670
671 if (m && m->chunk.memblock) {
672 c = m->chunk;
673 pa_memblock_ref(c.memblock);
674 pa_assert(result->length <= c.length);
675 c.length = result->length;
676
677 pa_memchunk_make_writable(&c, 0);
678 pa_volume_memchunk(&c, &s->sample_spec, &m->volume);
679 } else {
680 c = s->silence;
681 pa_memblock_ref(c.memblock);
682 pa_assert(result->length <= c.length);
683 c.length = result->length;
684 }
685
686 while ((o = pa_hashmap_iterate(i->thread_info.direct_outputs, &ostate, NULL))) {
687 pa_source_output_assert_ref(o);
688 pa_assert(o->direct_on_input == i);
689 pa_source_post_direct(s->monitor_source, o, &c);
690 }
691
692 pa_memblock_unref(c.memblock);
693 }
694 }
695
696 if (m) {
697 if (m->chunk.memblock)
698 pa_memblock_unref(m->chunk.memblock);
699 pa_memchunk_reset(&m->chunk);
700
701 pa_sink_input_unref(m->userdata);
702 m->userdata = NULL;
703
704 n_unreffed += 1;
705 }
706 }
707
708 /* Now drop references to entries that are included in the
709 * pa_mix_info array but don't exist anymore */
710
711 if (n_unreffed < n) {
712 for (; n > 0; info++, n--) {
713 if (info->userdata)
714 pa_sink_input_unref(info->userdata);
715 if (info->chunk.memblock)
716 pa_memblock_unref(info->chunk.memblock);
717 }
718 }
719
720 if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
721 pa_source_post(s->monitor_source, result);
722 }
723
724 /* Called from IO thread context */
725 void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result) {
726 pa_mix_info info[MAX_MIX_CHANNELS];
727 unsigned n;
728 size_t block_size_max;
729
730 pa_sink_assert_ref(s);
731 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
732 pa_assert(pa_frame_aligned(length, &s->sample_spec));
733 pa_assert(result);
734
735 pa_sink_ref(s);
736
737 pa_assert(!s->thread_info.rewind_requested);
738 pa_assert(s->thread_info.rewind_nbytes == 0);
739
740 if (s->thread_info.state == PA_SINK_SUSPENDED) {
741 result->memblock = pa_memblock_ref(s->silence.memblock);
742 result->index = s->silence.index;
743 result->length = PA_MIN(s->silence.length, length);
744 return;
745 }
746
747 if (length <= 0)
748 length = pa_frame_align(MIX_BUFFER_LENGTH, &s->sample_spec);
749
750 block_size_max = pa_mempool_block_size_max(s->core->mempool);
751 if (length > block_size_max)
752 length = pa_frame_align(block_size_max, &s->sample_spec);
753
754 pa_assert(length > 0);
755
756 n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
757
758 if (n == 0) {
759
760 *result = s->silence;
761 pa_memblock_ref(result->memblock);
762
763 if (result->length > length)
764 result->length = length;
765
766 } else if (n == 1) {
767 pa_cvolume volume;
768
769 *result = info[0].chunk;
770 pa_memblock_ref(result->memblock);
771
772 if (result->length > length)
773 result->length = length;
774
775 pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
776
777 if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&volume)) {
778 pa_memchunk_make_writable(result, 0);
779 if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume))
780 pa_silence_memchunk(result, &s->sample_spec);
781 else
782 pa_volume_memchunk(result, &s->sample_spec, &volume);
783 }
784 } else {
785 void *ptr;
786 result->memblock = pa_memblock_new(s->core->mempool, length);
787
788 ptr = pa_memblock_acquire(result->memblock);
789 result->length = pa_mix(info, n,
790 ptr, length,
791 &s->sample_spec,
792 &s->thread_info.soft_volume,
793 s->thread_info.soft_muted);
794 pa_memblock_release(result->memblock);
795
796 result->index = 0;
797 }
798
799 inputs_drop(s, info, n, result);
800
801 pa_sink_unref(s);
802 }
803
804 /* Called from IO thread context */
805 void pa_sink_render_into(pa_sink*s, pa_memchunk *target) {
806 pa_mix_info info[MAX_MIX_CHANNELS];
807 unsigned n;
808 size_t length, block_size_max;
809
810 pa_sink_assert_ref(s);
811 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
812 pa_assert(target);
813 pa_assert(target->memblock);
814 pa_assert(target->length > 0);
815 pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
816
817 pa_sink_ref(s);
818
819 pa_assert(!s->thread_info.rewind_requested);
820 pa_assert(s->thread_info.rewind_nbytes == 0);
821
822 if (s->thread_info.state == PA_SINK_SUSPENDED) {
823 pa_silence_memchunk(target, &s->sample_spec);
824 return;
825 }
826
827 length = target->length;
828 block_size_max = pa_mempool_block_size_max(s->core->mempool);
829 if (length > block_size_max)
830 length = pa_frame_align(block_size_max, &s->sample_spec);
831
832 pa_assert(length > 0);
833
834 n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
835
836 if (n == 0) {
837 if (target->length > length)
838 target->length = length;
839
840 pa_silence_memchunk(target, &s->sample_spec);
841 } else if (n == 1) {
842 pa_cvolume volume;
843
844 if (target->length > length)
845 target->length = length;
846
847 pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
848
849 if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume))
850 pa_silence_memchunk(target, &s->sample_spec);
851 else {
852 pa_memchunk vchunk;
853
854 vchunk = info[0].chunk;
855 pa_memblock_ref(vchunk.memblock);
856
857 if (vchunk.length > length)
858 vchunk.length = length;
859
860 if (!pa_cvolume_is_norm(&volume)) {
861 pa_memchunk_make_writable(&vchunk, 0);
862 pa_volume_memchunk(&vchunk, &s->sample_spec, &volume);
863 }
864
865 pa_memchunk_memcpy(target, &vchunk);
866 pa_memblock_unref(vchunk.memblock);
867 }
868
869 } else {
870 void *ptr;
871
872 ptr = pa_memblock_acquire(target->memblock);
873
874 target->length = pa_mix(info, n,
875 (uint8_t*) ptr + target->index, length,
876 &s->sample_spec,
877 &s->thread_info.soft_volume,
878 s->thread_info.soft_muted);
879
880 pa_memblock_release(target->memblock);
881 }
882
883 inputs_drop(s, info, n, target);
884
885 pa_sink_unref(s);
886 }
887
888 /* Called from IO thread context */
889 void pa_sink_render_into_full(pa_sink *s, pa_memchunk *target) {
890 pa_memchunk chunk;
891 size_t l, d;
892
893 pa_sink_assert_ref(s);
894 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
895 pa_assert(target);
896 pa_assert(target->memblock);
897 pa_assert(target->length > 0);
898 pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
899
900 pa_sink_ref(s);
901
902 pa_assert(!s->thread_info.rewind_requested);
903 pa_assert(s->thread_info.rewind_nbytes == 0);
904
905 l = target->length;
906 d = 0;
907 while (l > 0) {
908 chunk = *target;
909 chunk.index += d;
910 chunk.length -= d;
911
912 pa_sink_render_into(s, &chunk);
913
914 d += chunk.length;
915 l -= chunk.length;
916 }
917
918 pa_sink_unref(s);
919 }
920
921 /* Called from IO thread context */
922 void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result) {
923 pa_sink_assert_ref(s);
924 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
925 pa_assert(length > 0);
926 pa_assert(pa_frame_aligned(length, &s->sample_spec));
927 pa_assert(result);
928
929 pa_assert(!s->thread_info.rewind_requested);
930 pa_assert(s->thread_info.rewind_nbytes == 0);
931
932 /*** This needs optimization ***/
933
934 result->index = 0;
935 result->length = length;
936 result->memblock = pa_memblock_new(s->core->mempool, length);
937
938 pa_sink_render_into_full(s, result);
939 }
940
941 /* Called from main thread */
942 pa_usec_t pa_sink_get_latency(pa_sink *s) {
943 pa_usec_t usec = 0;
944
945 pa_sink_assert_ref(s);
946 pa_assert(PA_SINK_IS_LINKED(s->state));
947
948 /* The returned value is supposed to be in the time domain of the sound card! */
949
950 if (s->state == PA_SINK_SUSPENDED)
951 return 0;
952
953 if (!(s->flags & PA_SINK_LATENCY))
954 return 0;
955
956 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
957
958 return usec;
959 }
960
961 /* Called from IO thread */
962 pa_usec_t pa_sink_get_latency_within_thread(pa_sink *s) {
963 pa_usec_t usec = 0;
964 pa_msgobject *o;
965
966 pa_sink_assert_ref(s);
967 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
968
969 /* The returned value is supposed to be in the time domain of the sound card! */
970
971 if (s->thread_info.state == PA_SINK_SUSPENDED)
972 return 0;
973
974 if (!(s->flags & PA_SINK_LATENCY))
975 return 0;
976
977 o = PA_MSGOBJECT(s);
978
979 /* We probably should make this a proper vtable callback instead of going through process_msg() */
980
981 if (o->process_msg(o, PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
982 return -1;
983
984 return usec;
985 }
986
987 static void compute_new_soft_volume(pa_sink_input *i, const pa_cvolume *new_volume) {
988 unsigned c;
989
990 pa_sink_input_assert_ref(i);
991 pa_assert(new_volume->channels == i->sample_spec.channels);
992
993 /*
994 * This basically calculates:
995 *
996 * i->relative_volume := i->virtual_volume / new_volume
997 * i->soft_volume := i->relative_volume * i->volume_factor
998 */
999
1000 /* The new sink volume passed in here must already be remapped to
1001 * the sink input's channel map! */
1002
1003 i->soft_volume.channels = i->sample_spec.channels;
1004
1005 for (c = 0; c < i->sample_spec.channels; c++)
1006
1007 if (new_volume->values[c] <= PA_VOLUME_MUTED)
1008 /* We leave i->relative_volume untouched */
1009 i->soft_volume.values[c] = PA_VOLUME_MUTED;
1010 else {
1011 i->relative_volume[c] =
1012 pa_sw_volume_to_linear(i->virtual_volume.values[c]) /
1013 pa_sw_volume_to_linear(new_volume->values[c]);
1014
1015 i->soft_volume.values[c] = pa_sw_volume_from_linear(
1016 i->relative_volume[c] *
1017 pa_sw_volume_to_linear(i->volume_factor.values[c]));
1018 }
1019
1020 /* Hooks have the ability to play games with i->soft_volume */
1021 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME], i);
1022
1023 /* We don't copy the soft_volume to the thread_info data
1024 * here. That must be done by the caller */
1025 }
1026
1027 /* Called from main thread */
1028 void pa_sink_update_flat_volume(pa_sink *s, pa_cvolume *new_volume) {
1029 pa_sink_input *i;
1030 uint32_t idx;
1031
1032 pa_sink_assert_ref(s);
1033 pa_assert(new_volume);
1034 pa_assert(PA_SINK_IS_LINKED(s->state));
1035 pa_assert(s->flags & PA_SINK_FLAT_VOLUME);
1036
1037 /* This is called whenever a sink input volume changes and we
1038 * might need to fix up the sink volume accordingly. Please note
1039 * that we don't actually update the sinks volume here, we only
1040 * return how it needs to be updated. The caller should then call
1041 * pa_sink_set_volume().*/
1042
1043 if (pa_idxset_isempty(s->inputs)) {
1044 /* In the special case that we have no sink input we leave the
1045 * volume unmodified. */
1046 *new_volume = s->virtual_volume;
1047 return;
1048 }
1049
1050 pa_cvolume_mute(new_volume, s->channel_map.channels);
1051
1052 /* First let's determine the new maximum volume of all inputs
1053 * connected to this sink */
1054 for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) {
1055 unsigned c;
1056 pa_cvolume remapped_volume;
1057
1058 remapped_volume = i->virtual_volume;
1059 pa_cvolume_remap(&remapped_volume, &i->channel_map, &s->channel_map);
1060
1061 for (c = 0; c < new_volume->channels; c++)
1062 if (remapped_volume.values[c] > new_volume->values[c])
1063 new_volume->values[c] = remapped_volume.values[c];
1064 }
1065
1066 /* Then, let's update the soft volumes of all inputs connected
1067 * to this sink */
1068 for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) {
1069 pa_cvolume remapped_new_volume;
1070
1071 remapped_new_volume = *new_volume;
1072 pa_cvolume_remap(&remapped_new_volume, &s->channel_map, &i->channel_map);
1073 compute_new_soft_volume(i, &remapped_new_volume);
1074
1075 /* We don't copy soft_volume to the thread_info data here
1076 * (i.e. issue PA_SINK_INPUT_MESSAGE_SET_VOLUME) because we
1077 * want the update to be atomically with the sink volume
1078 * update, hence we do it within the pa_sink_set_volume() call
1079 * below */
1080 }
1081 }
1082
1083 /* Called from main thread */
1084 void pa_sink_propagate_flat_volume(pa_sink *s) {
1085 pa_sink_input *i;
1086 uint32_t idx;
1087
1088 pa_sink_assert_ref(s);
1089 pa_assert(PA_SINK_IS_LINKED(s->state));
1090 pa_assert(s->flags & PA_SINK_FLAT_VOLUME);
1091
1092 /* This is called whenever the sink volume changes that is not
1093 * caused by a sink input volume change. We need to fix up the
1094 * sink input volumes accordingly */
1095
1096 for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) {
1097 pa_cvolume sink_volume, new_virtual_volume;
1098 unsigned c;
1099
1100 /* This basically calculates i->virtual_volume := i->relative_volume * s->virtual_volume */
1101
1102 sink_volume = s->virtual_volume;
1103 pa_cvolume_remap(&sink_volume, &s->channel_map, &i->channel_map);
1104
1105 for (c = 0; c < i->sample_spec.channels; c++)
1106 new_virtual_volume.values[c] = pa_sw_volume_from_linear(
1107 i->relative_volume[c] *
1108 pa_sw_volume_to_linear(sink_volume.values[c]));
1109
1110 new_virtual_volume.channels = i->sample_spec.channels;
1111
1112 if (!pa_cvolume_equal(&new_virtual_volume, &i->virtual_volume)) {
1113 i->virtual_volume = new_virtual_volume;
1114
1115 /* Hmm, the soft volume might no longer actually match
1116 * what has been chosen as new virtual volume here,
1117 * especially when the old volume was
1118 * PA_VOLUME_MUTED. Hence let's recalculate the soft
1119 * volumes here. */
1120 compute_new_soft_volume(i, &sink_volume);
1121
1122 /* The virtual volume changed, let's tell people so */
1123 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1124 }
1125 }
1126
1127 /* If the soft_volume of any of the sink inputs got changed, let's
1128 * make sure the thread copies are synced up. */
1129 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SYNC_VOLUMES, NULL, 0, NULL) == 0);
1130 }
1131
1132 /* Called from main thread */
1133 void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume, pa_bool_t propagate, pa_bool_t sendmsg) {
1134 pa_bool_t virtual_volume_changed;
1135
1136 pa_sink_assert_ref(s);
1137 pa_assert(PA_SINK_IS_LINKED(s->state));
1138 pa_assert(volume);
1139 pa_assert(pa_cvolume_valid(volume));
1140 pa_assert(pa_cvolume_compatible(volume, &s->sample_spec));
1141
1142 virtual_volume_changed = !pa_cvolume_equal(volume, &s->virtual_volume);
1143 s->virtual_volume = *volume;
1144
1145 /* Propagate this volume change back to the inputs */
1146 if (virtual_volume_changed)
1147 if (propagate && (s->flags & PA_SINK_FLAT_VOLUME))
1148 pa_sink_propagate_flat_volume(s);
1149
1150 if (s->set_volume) {
1151 /* If we have a function set_volume(), then we do not apply a
1152 * soft volume by default. However, set_volume() is apply one
1153 * to s->soft_volume */
1154
1155 pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
1156 s->set_volume(s);
1157
1158 } else
1159 /* If we have no function set_volume(), then the soft volume
1160 * becomes the virtual volume */
1161 s->soft_volume = s->virtual_volume;
1162
1163 /* This tells the sink that soft and/or virtual volume changed */
1164 if (sendmsg)
1165 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
1166
1167 if (virtual_volume_changed)
1168 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1169 }
1170
1171 /* Called from main thread. Only to be called by sink implementor */
1172 void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
1173 pa_sink_assert_ref(s);
1174 pa_assert(volume);
1175
1176 s->soft_volume = *volume;
1177
1178 if (PA_SINK_IS_LINKED(s->state))
1179 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
1180 else
1181 s->thread_info.soft_volume = *volume;
1182 }
1183
1184 /* Called from main thread */
1185 const pa_cvolume *pa_sink_get_volume(pa_sink *s, pa_bool_t force_refresh) {
1186 pa_sink_assert_ref(s);
1187
1188 if (s->refresh_volume || force_refresh) {
1189 struct pa_cvolume old_virtual_volume = s->virtual_volume;
1190
1191 if (s->get_volume)
1192 s->get_volume(s);
1193
1194 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
1195
1196 if (!pa_cvolume_equal(&old_virtual_volume, &s->virtual_volume)) {
1197
1198 if (s->flags & PA_SINK_FLAT_VOLUME)
1199 pa_sink_propagate_flat_volume(s);
1200
1201 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1202 }
1203 }
1204
1205 return &s->virtual_volume;
1206 }
1207
1208 /* Called from main thread */
1209 void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_volume) {
1210 pa_sink_assert_ref(s);
1211
1212 /* The sink implementor may call this if the volume changed to make sure everyone is notified */
1213
1214 if (pa_cvolume_equal(&s->virtual_volume, new_volume))
1215 return;
1216
1217 s->virtual_volume = *new_volume;
1218 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1219 }
1220
1221 /* Called from main thread */
1222 void pa_sink_set_mute(pa_sink *s, pa_bool_t mute) {
1223 pa_bool_t old_muted;
1224
1225 pa_sink_assert_ref(s);
1226 pa_assert(PA_SINK_IS_LINKED(s->state));
1227
1228 old_muted = s->muted;
1229 s->muted = mute;
1230
1231 if (s->set_mute)
1232 s->set_mute(s);
1233
1234 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1235
1236 if (old_muted != s->muted)
1237 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1238 }
1239
1240 /* Called from main thread */
1241 pa_bool_t pa_sink_get_mute(pa_sink *s, pa_bool_t force_refresh) {
1242
1243 pa_sink_assert_ref(s);
1244
1245 if (s->refresh_muted || force_refresh) {
1246 pa_bool_t old_muted = s->muted;
1247
1248 if (s->get_mute)
1249 s->get_mute(s);
1250
1251 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
1252
1253 if (old_muted != s->muted)
1254 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1255 }
1256
1257 return s->muted;
1258 }
1259
1260 /* Called from main thread */
1261 void pa_sink_mute_changed(pa_sink *s, pa_bool_t new_muted) {
1262 pa_sink_assert_ref(s);
1263
1264 /* The sink implementor may call this if the volume changed to make sure everyone is notified */
1265
1266 if (s->muted == new_muted)
1267 return;
1268
1269 s->muted = new_muted;
1270 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1271 }
1272
1273 /* Called from main thread */
1274 pa_bool_t pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p) {
1275 pa_sink_assert_ref(s);
1276
1277 if (p)
1278 pa_proplist_update(s->proplist, mode, p);
1279
1280 if (PA_SINK_IS_LINKED(s->state)) {
1281 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
1282 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1283 }
1284
1285 return TRUE;
1286 }
1287
1288 /* Called from main thread */
1289 void pa_sink_set_description(pa_sink *s, const char *description) {
1290 const char *old;
1291 pa_sink_assert_ref(s);
1292
1293 if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
1294 return;
1295
1296 old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1297
1298 if (old && description && !strcmp(old, description))
1299 return;
1300
1301 if (description)
1302 pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
1303 else
1304 pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1305
1306 if (s->monitor_source) {
1307 char *n;
1308
1309 n = pa_sprintf_malloc("Monitor Source of %s", description ? description : s->name);
1310 pa_source_set_description(s->monitor_source, n);
1311 pa_xfree(n);
1312 }
1313
1314 if (PA_SINK_IS_LINKED(s->state)) {
1315 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1316 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
1317 }
1318 }
1319
1320 /* Called from main thread */
1321 unsigned pa_sink_linked_by(pa_sink *s) {
1322 unsigned ret;
1323
1324 pa_sink_assert_ref(s);
1325 pa_assert(PA_SINK_IS_LINKED(s->state));
1326
1327 ret = pa_idxset_size(s->inputs);
1328
1329 /* We add in the number of streams connected to us here. Please
1330 * note the asymmmetry to pa_sink_used_by()! */
1331
1332 if (s->monitor_source)
1333 ret += pa_source_linked_by(s->monitor_source);
1334
1335 return ret;
1336 }
1337
1338 /* Called from main thread */
1339 unsigned pa_sink_used_by(pa_sink *s) {
1340 unsigned ret;
1341
1342 pa_sink_assert_ref(s);
1343 pa_assert(PA_SINK_IS_LINKED(s->state));
1344
1345 ret = pa_idxset_size(s->inputs);
1346 pa_assert(ret >= s->n_corked);
1347
1348 /* Streams connected to our monitor source do not matter for
1349 * pa_sink_used_by()!.*/
1350
1351 return ret - s->n_corked;
1352 }
1353
1354 /* Called from main thread */
1355 unsigned pa_sink_check_suspend(pa_sink *s) {
1356 unsigned ret;
1357 pa_sink_input *i;
1358 uint32_t idx;
1359
1360 pa_sink_assert_ref(s);
1361
1362 if (!PA_SINK_IS_LINKED(s->state))
1363 return 0;
1364
1365 ret = 0;
1366
1367 for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) {
1368 pa_sink_input_state_t st;
1369
1370 st = pa_sink_input_get_state(i);
1371 pa_assert(PA_SINK_INPUT_IS_LINKED(st));
1372
1373 if (st == PA_SINK_INPUT_CORKED)
1374 continue;
1375
1376 if (i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND)
1377 continue;
1378
1379 ret ++;
1380 }
1381
1382 if (s->monitor_source)
1383 ret += pa_source_check_suspend(s->monitor_source);
1384
1385 return ret;
1386 }
1387
1388 /* Called from the IO thread */
1389 static void sync_input_volumes_within_thread(pa_sink *s) {
1390 pa_sink_input *i;
1391 void *state = NULL;
1392
1393 pa_sink_assert_ref(s);
1394
1395 while ((i = PA_SINK_INPUT(pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))) {
1396 if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume))
1397 continue;
1398
1399 i->thread_info.soft_volume = i->soft_volume;
1400 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1401 }
1402 }
1403
1404 /* Called from IO thread, except when it is not */
1405 int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1406 pa_sink *s = PA_SINK(o);
1407 pa_sink_assert_ref(s);
1408
1409 switch ((pa_sink_message_t) code) {
1410
1411 case PA_SINK_MESSAGE_ADD_INPUT: {
1412 pa_sink_input *i = PA_SINK_INPUT(userdata);
1413
1414 /* If you change anything here, make sure to change the
1415 * sink input handling a few lines down at
1416 * PA_SINK_MESSAGE_FINISH_MOVE, too. */
1417
1418 pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
1419
1420 /* Since the caller sleeps in pa_sink_input_put(), we can
1421 * safely access data outside of thread_info even though
1422 * it is mutable */
1423
1424 if ((i->thread_info.sync_prev = i->sync_prev)) {
1425 pa_assert(i->sink == i->thread_info.sync_prev->sink);
1426 pa_assert(i->sync_prev->sync_next == i);
1427 i->thread_info.sync_prev->thread_info.sync_next = i;
1428 }
1429
1430 if ((i->thread_info.sync_next = i->sync_next)) {
1431 pa_assert(i->sink == i->thread_info.sync_next->sink);
1432 pa_assert(i->sync_next->sync_prev == i);
1433 i->thread_info.sync_next->thread_info.sync_prev = i;
1434 }
1435
1436 pa_assert(!i->thread_info.attached);
1437 i->thread_info.attached = TRUE;
1438
1439 if (i->attach)
1440 i->attach(i);
1441
1442 pa_sink_input_set_state_within_thread(i, i->state);
1443
1444 /* The requested latency of the sink input needs to be
1445 * fixed up and then configured on the sink */
1446
1447 if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
1448 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
1449
1450 pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
1451 pa_sink_input_update_max_request(i, s->thread_info.max_request);
1452
1453 /* We don't rewind here automatically. This is left to the
1454 * sink input implementor because some sink inputs need a
1455 * slow start, i.e. need some time to buffer client
1456 * samples before beginning streaming. */
1457
1458 /* In flat volume mode we need to update the volume as
1459 * well */
1460 return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL);
1461 }
1462
1463 case PA_SINK_MESSAGE_REMOVE_INPUT: {
1464 pa_sink_input *i = PA_SINK_INPUT(userdata);
1465
1466 /* If you change anything here, make sure to change the
1467 * sink input handling a few lines down at
1468 * PA_SINK_MESSAGE_PREPAPRE_MOVE, too. */
1469
1470 if (i->detach)
1471 i->detach(i);
1472
1473 pa_sink_input_set_state_within_thread(i, i->state);
1474
1475 pa_assert(i->thread_info.attached);
1476 i->thread_info.attached = FALSE;
1477
1478 /* Since the caller sleeps in pa_sink_input_unlink(),
1479 * we can safely access data outside of thread_info even
1480 * though it is mutable */
1481
1482 pa_assert(!i->sync_prev);
1483 pa_assert(!i->sync_next);
1484
1485 if (i->thread_info.sync_prev) {
1486 i->thread_info.sync_prev->thread_info.sync_next = i->thread_info.sync_prev->sync_next;
1487 i->thread_info.sync_prev = NULL;
1488 }
1489
1490 if (i->thread_info.sync_next) {
1491 i->thread_info.sync_next->thread_info.sync_prev = i->thread_info.sync_next->sync_prev;
1492 i->thread_info.sync_next = NULL;
1493 }
1494
1495 if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
1496 pa_sink_input_unref(i);
1497
1498 pa_sink_invalidate_requested_latency(s);
1499 pa_sink_request_rewind(s, (size_t) -1);
1500
1501 /* In flat volume mode we need to update the volume as
1502 * well */
1503 return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL);
1504 }
1505
1506 case PA_SINK_MESSAGE_START_MOVE: {
1507 pa_sink_input *i = PA_SINK_INPUT(userdata);
1508
1509 /* We don't support moving synchronized streams. */
1510 pa_assert(!i->sync_prev);
1511 pa_assert(!i->sync_next);
1512 pa_assert(!i->thread_info.sync_next);
1513 pa_assert(!i->thread_info.sync_prev);
1514
1515 if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
1516 pa_usec_t usec = 0;
1517 size_t sink_nbytes, total_nbytes;
1518
1519 /* Get the latency of the sink */
1520 if (!(s->flags & PA_SINK_LATENCY) ||
1521 PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1522 usec = 0;
1523
1524 sink_nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
1525 total_nbytes = sink_nbytes + pa_memblockq_get_length(i->thread_info.render_memblockq);
1526
1527 if (total_nbytes > 0) {
1528 i->thread_info.rewrite_nbytes = i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, total_nbytes) : total_nbytes;
1529 i->thread_info.rewrite_flush = TRUE;
1530 pa_sink_input_process_rewind(i, sink_nbytes);
1531 }
1532 }
1533
1534 if (i->detach)
1535 i->detach(i);
1536
1537 pa_assert(i->thread_info.attached);
1538 i->thread_info.attached = FALSE;
1539
1540 /* Let's remove the sink input ...*/
1541 if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
1542 pa_sink_input_unref(i);
1543
1544 pa_sink_invalidate_requested_latency(s);
1545
1546 pa_log_debug("Requesting rewind due to started move");
1547 pa_sink_request_rewind(s, (size_t) -1);
1548
1549 /* In flat volume mode we need to update the volume as
1550 * well */
1551 return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL);
1552 }
1553
1554 case PA_SINK_MESSAGE_FINISH_MOVE: {
1555 pa_sink_input *i = PA_SINK_INPUT(userdata);
1556
1557 /* We don't support moving synchronized streams. */
1558 pa_assert(!i->sync_prev);
1559 pa_assert(!i->sync_next);
1560 pa_assert(!i->thread_info.sync_next);
1561 pa_assert(!i->thread_info.sync_prev);
1562
1563 pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
1564
1565 pa_assert(!i->thread_info.attached);
1566 i->thread_info.attached = TRUE;
1567
1568 if (i->attach)
1569 i->attach(i);
1570
1571 if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
1572 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
1573
1574 pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
1575 pa_sink_input_update_max_request(i, s->thread_info.max_request);
1576
1577 if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
1578 pa_usec_t usec = 0;
1579 size_t nbytes;
1580
1581 /* Get the latency of the sink */
1582 if (!(s->flags & PA_SINK_LATENCY) ||
1583 PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1584 usec = 0;
1585
1586 nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
1587
1588 if (nbytes > 0)
1589 pa_sink_input_drop(i, nbytes);
1590
1591 pa_log_debug("Requesting rewind due to finished move");
1592 pa_sink_request_rewind(s, nbytes);
1593 }
1594
1595 /* In flat volume mode we need to update the volume as
1596 * well */
1597 return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL);
1598 }
1599
1600 case PA_SINK_MESSAGE_SET_VOLUME:
1601
1602 if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
1603 s->thread_info.soft_volume = s->soft_volume;
1604 pa_sink_request_rewind(s, (size_t) -1);
1605 }
1606
1607 if (!(s->flags & PA_SINK_FLAT_VOLUME))
1608 return 0;
1609
1610 /* Fall through ... */
1611
1612 case PA_SINK_MESSAGE_SYNC_VOLUMES:
1613 sync_input_volumes_within_thread(s);
1614 return 0;
1615
1616 case PA_SINK_MESSAGE_GET_VOLUME:
1617 return 0;
1618
1619 case PA_SINK_MESSAGE_SET_MUTE:
1620
1621 if (s->thread_info.soft_muted != s->muted) {
1622 s->thread_info.soft_muted = s->muted;
1623 pa_sink_request_rewind(s, (size_t) -1);
1624 }
1625
1626 return 0;
1627
1628 case PA_SINK_MESSAGE_GET_MUTE:
1629 return 0;
1630
1631 case PA_SINK_MESSAGE_SET_STATE: {
1632
1633 pa_bool_t suspend_change =
1634 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
1635 (PA_SINK_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SINK_SUSPENDED);
1636
1637 s->thread_info.state = PA_PTR_TO_UINT(userdata);
1638
1639 if (s->thread_info.state == PA_SINK_SUSPENDED) {
1640 s->thread_info.rewind_nbytes = 0;
1641 s->thread_info.rewind_requested = FALSE;
1642 }
1643
1644 if (suspend_change) {
1645 pa_sink_input *i;
1646 void *state = NULL;
1647
1648 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
1649 if (i->suspend_within_thread)
1650 i->suspend_within_thread(i, s->thread_info.state == PA_SINK_SUSPENDED);
1651 }
1652
1653 return 0;
1654 }
1655
1656 case PA_SINK_MESSAGE_DETACH:
1657
1658 /* Detach all streams */
1659 pa_sink_detach_within_thread(s);
1660 return 0;
1661
1662 case PA_SINK_MESSAGE_ATTACH:
1663
1664 /* Reattach all streams */
1665 pa_sink_attach_within_thread(s);
1666 return 0;
1667
1668 case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY: {
1669
1670 pa_usec_t *usec = userdata;
1671 *usec = pa_sink_get_requested_latency_within_thread(s);
1672
1673 if (*usec == (pa_usec_t) -1)
1674 *usec = s->thread_info.max_latency;
1675
1676 return 0;
1677 }
1678
1679 case PA_SINK_MESSAGE_SET_LATENCY_RANGE: {
1680 pa_usec_t *r = userdata;
1681
1682 pa_sink_set_latency_range_within_thread(s, r[0], r[1]);
1683
1684 return 0;
1685 }
1686
1687 case PA_SINK_MESSAGE_GET_LATENCY_RANGE: {
1688 pa_usec_t *r = userdata;
1689
1690 r[0] = s->thread_info.min_latency;
1691 r[1] = s->thread_info.max_latency;
1692
1693 return 0;
1694 }
1695
1696 case PA_SINK_MESSAGE_GET_MAX_REWIND:
1697
1698 *((size_t*) userdata) = s->thread_info.max_rewind;
1699 return 0;
1700
1701 case PA_SINK_MESSAGE_GET_MAX_REQUEST:
1702
1703 *((size_t*) userdata) = s->thread_info.max_request;
1704 return 0;
1705
1706 case PA_SINK_MESSAGE_SET_MAX_REWIND:
1707
1708 pa_sink_set_max_rewind_within_thread(s, (size_t) offset);
1709 return 0;
1710
1711 case PA_SINK_MESSAGE_SET_MAX_REQUEST:
1712
1713 pa_sink_set_max_request_within_thread(s, (size_t) offset);
1714 return 0;
1715
1716 case PA_SINK_MESSAGE_GET_LATENCY:
1717 case PA_SINK_MESSAGE_MAX:
1718 ;
1719 }
1720
1721 return -1;
1722 }
1723
1724 /* Called from main thread */
1725 int pa_sink_suspend_all(pa_core *c, pa_bool_t suspend) {
1726 pa_sink *sink;
1727 uint32_t idx;
1728 int ret = 0;
1729
1730 pa_core_assert_ref(c);
1731
1732 for (sink = PA_SINK(pa_idxset_first(c->sinks, &idx)); sink; sink = PA_SINK(pa_idxset_next(c->sinks, &idx))) {
1733 int r;
1734
1735 if ((r = pa_sink_suspend(sink, suspend)) < 0)
1736 ret = r;
1737 }
1738
1739 return ret;
1740 }
1741
1742 /* Called from main thread */
1743 void pa_sink_detach(pa_sink *s) {
1744 pa_sink_assert_ref(s);
1745 pa_assert(PA_SINK_IS_LINKED(s->state));
1746
1747 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_DETACH, NULL, 0, NULL) == 0);
1748 }
1749
1750 /* Called from main thread */
1751 void pa_sink_attach(pa_sink *s) {
1752 pa_sink_assert_ref(s);
1753 pa_assert(PA_SINK_IS_LINKED(s->state));
1754
1755 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_ATTACH, NULL, 0, NULL) == 0);
1756 }
1757
1758 /* Called from IO thread */
1759 void pa_sink_detach_within_thread(pa_sink *s) {
1760 pa_sink_input *i;
1761 void *state = NULL;
1762
1763 pa_sink_assert_ref(s);
1764 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1765
1766 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
1767 if (i->detach)
1768 i->detach(i);
1769
1770 if (s->monitor_source)
1771 pa_source_detach_within_thread(s->monitor_source);
1772 }
1773
1774 /* Called from IO thread */
1775 void pa_sink_attach_within_thread(pa_sink *s) {
1776 pa_sink_input *i;
1777 void *state = NULL;
1778
1779 pa_sink_assert_ref(s);
1780 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1781
1782 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
1783 if (i->attach)
1784 i->attach(i);
1785
1786 if (s->monitor_source)
1787 pa_source_attach_within_thread(s->monitor_source);
1788 }
1789
1790 /* Called from IO thread */
1791 void pa_sink_request_rewind(pa_sink*s, size_t nbytes) {
1792 pa_sink_assert_ref(s);
1793 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1794
1795 if (s->thread_info.state == PA_SINK_SUSPENDED)
1796 return;
1797
1798 if (nbytes == (size_t) -1)
1799 nbytes = s->thread_info.max_rewind;
1800
1801 nbytes = PA_MIN(nbytes, s->thread_info.max_rewind);
1802
1803 if (s->thread_info.rewind_requested &&
1804 nbytes <= s->thread_info.rewind_nbytes)
1805 return;
1806
1807 s->thread_info.rewind_nbytes = nbytes;
1808 s->thread_info.rewind_requested = TRUE;
1809
1810 if (s->request_rewind)
1811 s->request_rewind(s);
1812 }
1813
1814 /* Called from IO thread */
1815 pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s) {
1816 pa_usec_t result = (pa_usec_t) -1;
1817 pa_sink_input *i;
1818 void *state = NULL;
1819 pa_usec_t monitor_latency;
1820
1821 pa_sink_assert_ref(s);
1822
1823 if (s->thread_info.requested_latency_valid)
1824 return s->thread_info.requested_latency;
1825
1826 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
1827
1828 if (i->thread_info.requested_sink_latency != (pa_usec_t) -1 &&
1829 (result == (pa_usec_t) -1 || result > i->thread_info.requested_sink_latency))
1830 result = i->thread_info.requested_sink_latency;
1831
1832 monitor_latency = pa_source_get_requested_latency_within_thread(s->monitor_source);
1833
1834 if (monitor_latency != (pa_usec_t) -1 &&
1835 (result == (pa_usec_t) -1 || result > monitor_latency))
1836 result = monitor_latency;
1837
1838 if (result != (pa_usec_t) -1) {
1839 if (result > s->thread_info.max_latency)
1840 result = s->thread_info.max_latency;
1841
1842 if (result < s->thread_info.min_latency)
1843 result = s->thread_info.min_latency;
1844 }
1845
1846 s->thread_info.requested_latency = result;
1847 s->thread_info.requested_latency_valid = TRUE;
1848
1849 return result;
1850 }
1851
1852 /* Called from main thread */
1853 pa_usec_t pa_sink_get_requested_latency(pa_sink *s) {
1854 pa_usec_t usec = 0;
1855
1856 pa_sink_assert_ref(s);
1857 pa_assert(PA_SINK_IS_LINKED(s->state));
1858
1859 if (s->state == PA_SINK_SUSPENDED)
1860 return 0;
1861
1862 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1863 return usec;
1864 }
1865
1866 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
1867 void pa_sink_set_max_rewind_within_thread(pa_sink *s, size_t max_rewind) {
1868 pa_sink_input *i;
1869 void *state = NULL;
1870
1871 pa_sink_assert_ref(s);
1872
1873 if (max_rewind == s->thread_info.max_rewind)
1874 return;
1875
1876 s->thread_info.max_rewind = max_rewind;
1877
1878 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
1879 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
1880 pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
1881 }
1882
1883 if (s->monitor_source)
1884 pa_source_set_max_rewind_within_thread(s->monitor_source, s->thread_info.max_rewind);
1885 }
1886
1887 /* Called from main thread */
1888 void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind) {
1889 pa_sink_assert_ref(s);
1890
1891 if (PA_SINK_IS_LINKED(s->state))
1892 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
1893 else
1894 pa_sink_set_max_rewind_within_thread(s, max_rewind);
1895 }
1896
1897 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
1898 void pa_sink_set_max_request_within_thread(pa_sink *s, size_t max_request) {
1899 void *state = NULL;
1900
1901 pa_sink_assert_ref(s);
1902
1903 if (max_request == s->thread_info.max_request)
1904 return;
1905
1906 s->thread_info.max_request = max_request;
1907
1908 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
1909 pa_sink_input *i;
1910
1911 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
1912 pa_sink_input_update_max_request(i, s->thread_info.max_request);
1913 }
1914 }
1915
1916 /* Called from main thread */
1917 void pa_sink_set_max_request(pa_sink *s, size_t max_request) {
1918 pa_sink_assert_ref(s);
1919
1920 if (PA_SINK_IS_LINKED(s->state))
1921 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REQUEST, NULL, max_request, NULL) == 0);
1922 else
1923 pa_sink_set_max_request_within_thread(s, max_request);
1924 }
1925
1926 /* Called from IO thread */
1927 void pa_sink_invalidate_requested_latency(pa_sink *s) {
1928 pa_sink_input *i;
1929 void *state = NULL;
1930
1931 pa_sink_assert_ref(s);
1932
1933 s->thread_info.requested_latency_valid = FALSE;
1934
1935 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
1936
1937 if (s->update_requested_latency)
1938 s->update_requested_latency(s);
1939
1940 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
1941 if (i->update_sink_requested_latency)
1942 i->update_sink_requested_latency(i);
1943 }
1944 }
1945
1946 /* Called from main thread */
1947 void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
1948 pa_sink_assert_ref(s);
1949
1950 /* min_latency == 0: no limit
1951 * min_latency anything else: specified limit
1952 *
1953 * Similar for max_latency */
1954
1955 if (min_latency < ABSOLUTE_MIN_LATENCY)
1956 min_latency = ABSOLUTE_MIN_LATENCY;
1957
1958 if (max_latency <= 0 ||
1959 max_latency > ABSOLUTE_MAX_LATENCY)
1960 max_latency = ABSOLUTE_MAX_LATENCY;
1961
1962 pa_assert(min_latency <= max_latency);
1963
1964 /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
1965 pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
1966 max_latency == ABSOLUTE_MAX_LATENCY) ||
1967 (s->flags & PA_SINK_DYNAMIC_LATENCY));
1968
1969 if (PA_SINK_IS_LINKED(s->state)) {
1970 pa_usec_t r[2];
1971
1972 r[0] = min_latency;
1973 r[1] = max_latency;
1974
1975 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
1976 } else
1977 pa_sink_set_latency_range_within_thread(s, min_latency, max_latency);
1978 }
1979
1980 /* Called from main thread */
1981 void pa_sink_get_latency_range(pa_sink *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
1982 pa_sink_assert_ref(s);
1983 pa_assert(min_latency);
1984 pa_assert(max_latency);
1985
1986 if (PA_SINK_IS_LINKED(s->state)) {
1987 pa_usec_t r[2] = { 0, 0 };
1988
1989 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
1990
1991 *min_latency = r[0];
1992 *max_latency = r[1];
1993 } else {
1994 *min_latency = s->thread_info.min_latency;
1995 *max_latency = s->thread_info.max_latency;
1996 }
1997 }
1998
1999 /* Called from IO thread */
2000 void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2001 void *state = NULL;
2002
2003 pa_sink_assert_ref(s);
2004
2005 pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
2006 pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
2007 pa_assert(min_latency <= max_latency);
2008
2009 /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2010 pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2011 max_latency == ABSOLUTE_MAX_LATENCY) ||
2012 (s->flags & PA_SINK_DYNAMIC_LATENCY));
2013
2014 s->thread_info.min_latency = min_latency;
2015 s->thread_info.max_latency = max_latency;
2016
2017 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2018 pa_sink_input *i;
2019
2020 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
2021 if (i->update_sink_latency_range)
2022 i->update_sink_latency_range(i);
2023 }
2024
2025 pa_sink_invalidate_requested_latency(s);
2026
2027 pa_source_set_latency_range_within_thread(s->monitor_source, min_latency, max_latency);
2028 }
2029
2030 /* Called from main context */
2031 size_t pa_sink_get_max_rewind(pa_sink *s) {
2032 size_t r;
2033 pa_sink_assert_ref(s);
2034
2035 if (!PA_SINK_IS_LINKED(s->state))
2036 return s->thread_info.max_rewind;
2037
2038 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
2039
2040 return r;
2041 }
2042
2043 /* Called from main context */
2044 size_t pa_sink_get_max_request(pa_sink *s) {
2045 size_t r;
2046 pa_sink_assert_ref(s);
2047
2048 if (!PA_SINK_IS_LINKED(s->state))
2049 return s->thread_info.max_request;
2050
2051 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REQUEST, &r, 0, NULL) == 0);
2052
2053 return r;
2054 }
2055
2056 /* Called from main context */
2057 pa_bool_t pa_device_init_icon(pa_proplist *p, pa_bool_t is_sink) {
2058 const char *ff, *c, *t = NULL, *s = "", *profile, *bus;
2059
2060 pa_assert(p);
2061
2062 if (pa_proplist_contains(p, PA_PROP_DEVICE_ICON_NAME))
2063 return TRUE;
2064
2065 if ((ff = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
2066
2067 if (pa_streq(ff, "microphone"))
2068 t = "audio-input-microphone";
2069 else if (pa_streq(ff, "webcam"))
2070 t = "camera-web";
2071 else if (pa_streq(ff, "computer"))
2072 t = "computer";
2073 else if (pa_streq(ff, "handset"))
2074 t = "phone";
2075 else if (pa_streq(ff, "portable"))
2076 t = "multimedia-player";
2077 else if (pa_streq(ff, "tv"))
2078 t = "video-display";
2079 }
2080
2081 if (!t)
2082 if ((c = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
2083 if (pa_streq(c, "modem"))
2084 t = "modem";
2085
2086 if (!t) {
2087 if (is_sink)
2088 t = "audio-card";
2089 else
2090 t = "audio-input-microphone";
2091 }
2092
2093 if ((profile = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
2094 if (strstr(profile, "analog"))
2095 s = "-analog";
2096 else if (strstr(profile, "iec958"))
2097 s = "-iec958";
2098 else if (strstr(profile, "hdmi"))
2099 s = "-hdmi";
2100 }
2101
2102 bus = pa_proplist_gets(p, PA_PROP_DEVICE_BUS);
2103
2104 pa_proplist_setf(p, PA_PROP_DEVICE_ICON_NAME, "%s%s%s%s", t, pa_strempty(s), bus ? "-" : "", pa_strempty(bus));
2105
2106 return TRUE;
2107 }
2108
2109 pa_bool_t pa_device_init_description(pa_proplist *p) {
2110 const char *s;
2111 pa_assert(p);
2112
2113 if (pa_proplist_contains(p, PA_PROP_DEVICE_DESCRIPTION))
2114 return TRUE;
2115
2116 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
2117 if (pa_streq(s, "internal")) {
2118 pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, _("Internal Audio"));
2119 return TRUE;
2120 }
2121
2122 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
2123 if (pa_streq(s, "modem")) {
2124 pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, _("Modem"));
2125 return TRUE;
2126 }
2127
2128 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_PRODUCT_NAME))) {
2129 pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, s);
2130 return TRUE;
2131 }
2132
2133 return FALSE;
2134 }