?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implement the "volume sharing" feature.
[pulseaudio-raopUDP/pulseaudio-raop-alac.git] / src / pulsecore / sink.c
blobd713be11fdeb8072b72066683735738a7308f094
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 #include <pulse/rtclock.h>
38
39 #include <pulsecore/sink-input.h>
40 #include <pulsecore/namereg.h>
41 #include <pulsecore/core-util.h>
42 #include <pulsecore/sample-util.h>
43 #include <pulsecore/core-subscribe.h>
44 #include <pulsecore/log.h>
45 #include <pulsecore/macro.h>
46 #include <pulsecore/play-memblockq.h>
47 #include <pulsecore/flist.h>
48
49 #include "sink.h"
50
51 #define MAX_MIX_CHANNELS 32
52 #define MIX_BUFFER_LENGTH (PA_PAGE_SIZE)
53 #define ABSOLUTE_MIN_LATENCY (500)
54 #define ABSOLUTE_MAX_LATENCY (10*PA_USEC_PER_SEC)
55 #define DEFAULT_FIXED_LATENCY (250*PA_USEC_PER_MSEC)
56
57 PA_DEFINE_PUBLIC_CLASS(pa_sink, pa_msgobject);
58
59 struct pa_sink_volume_change {
60 pa_usec_t at;
61 pa_cvolume hw_volume;
62
63 PA_LLIST_FIELDS(pa_sink_volume_change);
64 };
65
66 struct sink_message_set_port {
67 pa_device_port *port;
68 int ret;
69 };
70
71 static void sink_free(pa_object *s);
72
73 static void pa_sink_volume_change_push(pa_sink *s);
74 static void pa_sink_volume_change_flush(pa_sink *s);
75 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes);
76
77 pa_sink_new_data* pa_sink_new_data_init(pa_sink_new_data *data) {
78 pa_assert(data);
79
80 pa_zero(*data);
81 data->proplist = pa_proplist_new();
82
83 return data;
84 }
85
86 void pa_sink_new_data_set_name(pa_sink_new_data *data, const char *name) {
87 pa_assert(data);
88
89 pa_xfree(data->name);
90 data->name = pa_xstrdup(name);
91 }
92
93 void pa_sink_new_data_set_sample_spec(pa_sink_new_data *data, const pa_sample_spec *spec) {
94 pa_assert(data);
95
96 if ((data->sample_spec_is_set = !!spec))
97 data->sample_spec = *spec;
98 }
99
100 void pa_sink_new_data_set_channel_map(pa_sink_new_data *data, const pa_channel_map *map) {
101 pa_assert(data);
102
103 if ((data->channel_map_is_set = !!map))
104 data->channel_map = *map;
105 }
106
107 void pa_sink_new_data_set_volume(pa_sink_new_data *data, const pa_cvolume *volume) {
108 pa_assert(data);
109
110 if ((data->volume_is_set = !!volume))
111 data->volume = *volume;
112 }
113
114 void pa_sink_new_data_set_muted(pa_sink_new_data *data, pa_bool_t mute) {
115 pa_assert(data);
116
117 data->muted_is_set = TRUE;
118 data->muted = !!mute;
119 }
120
121 void pa_sink_new_data_set_port(pa_sink_new_data *data, const char *port) {
122 pa_assert(data);
123
124 pa_xfree(data->active_port);
125 data->active_port = pa_xstrdup(port);
126 }
127
128 void pa_sink_new_data_done(pa_sink_new_data *data) {
129 pa_assert(data);
130
131 pa_proplist_free(data->proplist);
132
133 if (data->ports) {
134 pa_device_port *p;
135
136 while ((p = pa_hashmap_steal_first(data->ports)))
137 pa_device_port_free(p);
138
139 pa_hashmap_free(data->ports, NULL, NULL);
140 }
141
142 pa_xfree(data->name);
143 pa_xfree(data->active_port);
144 }
145
146 pa_device_port *pa_device_port_new(const char *name, const char *description, size_t extra) {
147 pa_device_port *p;
148
149 pa_assert(name);
150
151 p = pa_xmalloc(PA_ALIGN(sizeof(pa_device_port)) + extra);
152 p->name = pa_xstrdup(name);
153 p->description = pa_xstrdup(description);
154
155 p->priority = 0;
156
157 return p;
158 }
159
160 void pa_device_port_free(pa_device_port *p) {
161 pa_assert(p);
162
163 pa_xfree(p->name);
164 pa_xfree(p->description);
165 pa_xfree(p);
166 }
167
168 /* Called from main context */
169 static void reset_callbacks(pa_sink *s) {
170 pa_assert(s);
171
172 s->set_state = NULL;
173 s->get_volume = NULL;
174 s->set_volume = NULL;
175 s->get_mute = NULL;
176 s->set_mute = NULL;
177 s->request_rewind = NULL;
178 s->update_requested_latency = NULL;
179 s->set_port = NULL;
180 }
181
182 /* Called from main context */
183 pa_sink* pa_sink_new(
184 pa_core *core,
185 pa_sink_new_data *data,
186 pa_sink_flags_t flags) {
187
188 pa_sink *s;
189 const char *name;
190 char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
191 pa_source_new_data source_data;
192 const char *dn;
193 char *pt;
194
195 pa_assert(core);
196 pa_assert(data);
197 pa_assert(data->name);
198 pa_assert_ctl_context();
199
200 s = pa_msgobject_new(pa_sink);
201
202 if (!(name = pa_namereg_register(core, data->name, PA_NAMEREG_SINK, s, data->namereg_fail))) {
203 pa_log_debug("Failed to register name %s.", data->name);
204 pa_xfree(s);
205 return NULL;
206 }
207
208 pa_sink_new_data_set_name(data, name);
209
210 if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_NEW], data) < 0) {
211 pa_xfree(s);
212 pa_namereg_unregister(core, name);
213 return NULL;
214 }
215
216 /* FIXME, need to free s here on failure */
217
218 pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver));
219 pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]);
220
221 pa_return_null_if_fail(data->sample_spec_is_set && pa_sample_spec_valid(&data->sample_spec));
222
223 if (!data->channel_map_is_set)
224 pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
225
226 pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
227 pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
228
229 /* FIXME: There should probably be a general function for checking whether
230 * the sink volume is allowed to be set, like there is for sink inputs. */
231 pa_assert(!data->volume_is_set || !(flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
232
233 if (!data->volume_is_set) {
234 pa_cvolume_reset(&data->volume, data->sample_spec.channels);
235 data->save_volume = FALSE;
236 }
237
238 pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
239 pa_return_null_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec));
240
241 if (!data->muted_is_set)
242 data->muted = FALSE;
243
244 if (data->card)
245 pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
246
247 pa_device_init_description(data->proplist);
248 pa_device_init_icon(data->proplist, TRUE);
249 pa_device_init_intended_roles(data->proplist);
250
251 if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_FIXATE], data) < 0) {
252 pa_xfree(s);
253 pa_namereg_unregister(core, name);
254 return NULL;
255 }
256
257 s->parent.parent.free = sink_free;
258 s->parent.process_msg = pa_sink_process_msg;
259
260 s->core = core;
261 s->state = PA_SINK_INIT;
262 s->flags = flags;
263 s->priority = 0;
264 s->suspend_cause = 0;
265 s->name = pa_xstrdup(name);
266 s->proplist = pa_proplist_copy(data->proplist);
267 s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
268 s->module = data->module;
269 s->card = data->card;
270
271 s->priority = pa_device_init_priority(s->proplist);
272
273 s->sample_spec = data->sample_spec;
274 s->channel_map = data->channel_map;
275
276 s->inputs = pa_idxset_new(NULL, NULL);
277 s->n_corked = 0;
278 s->input_to_master = NULL;
279
280 s->reference_volume = s->real_volume = data->volume;
281 pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
282 s->base_volume = PA_VOLUME_NORM;
283 s->n_volume_steps = PA_VOLUME_NORM+1;
284 s->muted = data->muted;
285 s->refresh_volume = s->refresh_muted = FALSE;
286
287 reset_callbacks(s);
288 s->userdata = NULL;
289
290 s->asyncmsgq = NULL;
291
292 /* As a minor optimization we just steal the list instead of
293 * copying it here */
294 s->ports = data->ports;
295 data->ports = NULL;
296
297 s->active_port = NULL;
298 s->save_port = FALSE;
299
300 if (data->active_port && s->ports)
301 if ((s->active_port = pa_hashmap_get(s->ports, data->active_port)))
302 s->save_port = data->save_port;
303
304 if (!s->active_port && s->ports) {
305 void *state;
306 pa_device_port *p;
307
308 PA_HASHMAP_FOREACH(p, s->ports, state)
309 if (!s->active_port || p->priority > s->active_port->priority)
310 s->active_port = p;
311 }
312
313 s->save_volume = data->save_volume;
314 s->save_muted = data->save_muted;
315
316 pa_silence_memchunk_get(
317 &core->silence_cache,
318 core->mempool,
319 &s->silence,
320 &s->sample_spec,
321 0);
322
323 s->thread_info.rtpoll = NULL;
324 s->thread_info.inputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
325 s->thread_info.soft_volume = s->soft_volume;
326 s->thread_info.soft_muted = s->muted;
327 s->thread_info.state = s->state;
328 s->thread_info.rewind_nbytes = 0;
329 s->thread_info.rewind_requested = FALSE;
330 s->thread_info.max_rewind = 0;
331 s->thread_info.max_request = 0;
332 s->thread_info.requested_latency_valid = FALSE;
333 s->thread_info.requested_latency = 0;
334 s->thread_info.min_latency = ABSOLUTE_MIN_LATENCY;
335 s->thread_info.max_latency = ABSOLUTE_MAX_LATENCY;
336 s->thread_info.fixed_latency = flags & PA_SINK_DYNAMIC_LATENCY ? 0 : DEFAULT_FIXED_LATENCY;
337
338 PA_LLIST_HEAD_INIT(pa_sink_volume_change, s->thread_info.volume_changes);
339 s->thread_info.volume_changes_tail = NULL;
340 pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
341 s->thread_info.volume_change_safety_margin = core->sync_volume_safety_margin_usec;
342 s->thread_info.volume_change_extra_delay = core->sync_volume_extra_delay_usec;
343
344 /* FIXME: This should probably be moved to pa_sink_put() */
345 pa_assert_se(pa_idxset_put(core->sinks, s, &s->index) >= 0);
346
347 if (s->card)
348 pa_assert_se(pa_idxset_put(s->card->sinks, s, NULL) >= 0);
349
350 pt = pa_proplist_to_string_sep(s->proplist, "\n ");
351 pa_log_info("Created sink %u \"%s\" with sample spec %s and channel map %s\n %s",
352 s->index,
353 s->name,
354 pa_sample_spec_snprint(st, sizeof(st), &s->sample_spec),
355 pa_channel_map_snprint(cm, sizeof(cm), &s->channel_map),
356 pt);
357 pa_xfree(pt);
358
359 pa_source_new_data_init(&source_data);
360 pa_source_new_data_set_sample_spec(&source_data, &s->sample_spec);
361 pa_source_new_data_set_channel_map(&source_data, &s->channel_map);
362 source_data.name = pa_sprintf_malloc("%s.monitor", name);
363 source_data.driver = data->driver;
364 source_data.module = data->module;
365 source_data.card = data->card;
366
367 dn = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
368 pa_proplist_setf(source_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Monitor of %s", dn ? dn : s->name);
369 pa_proplist_sets(source_data.proplist, PA_PROP_DEVICE_CLASS, "monitor");
370
371 s->monitor_source = pa_source_new(core, &source_data,
372 ((flags & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
373 ((flags & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0));
374
375 pa_source_new_data_done(&source_data);
376
377 if (!s->monitor_source) {
378 pa_sink_unlink(s);
379 pa_sink_unref(s);
380 return NULL;
381 }
382
383 s->monitor_source->monitor_of = s;
384
385 pa_source_set_latency_range(s->monitor_source, s->thread_info.min_latency, s->thread_info.max_latency);
386 pa_source_set_fixed_latency(s->monitor_source, s->thread_info.fixed_latency);
387 pa_source_set_max_rewind(s->monitor_source, s->thread_info.max_rewind);
388
389 return s;
390 }
391
392 /* Called from main context */
393 static int sink_set_state(pa_sink *s, pa_sink_state_t state) {
394 int ret;
395 pa_bool_t suspend_change;
396 pa_sink_state_t original_state;
397
398 pa_assert(s);
399 pa_assert_ctl_context();
400
401 if (s->state == state)
402 return 0;
403
404 original_state = s->state;
405
406 suspend_change =
407 (original_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(state)) ||
408 (PA_SINK_IS_OPENED(original_state) && state == PA_SINK_SUSPENDED);
409
410 if (s->set_state)
411 if ((ret = s->set_state(s, state)) < 0)
412 return ret;
413
414 if (s->asyncmsgq)
415 if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_STATE, PA_UINT_TO_PTR(state), 0, NULL)) < 0) {
416
417 if (s->set_state)
418 s->set_state(s, original_state);
419
420 return ret;
421 }
422
423 s->state = state;
424
425 if (state != PA_SINK_UNLINKED) { /* if we enter UNLINKED state pa_sink_unlink() will fire the apropriate events */
426 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_STATE_CHANGED], s);
427 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
428 }
429
430 if (suspend_change) {
431 pa_sink_input *i;
432 uint32_t idx;
433
434 /* We're suspending or resuming, tell everyone about it */
435
436 PA_IDXSET_FOREACH(i, s->inputs, idx)
437 if (s->state == PA_SINK_SUSPENDED &&
438 (i->flags & PA_SINK_INPUT_KILL_ON_SUSPEND))
439 pa_sink_input_kill(i);
440 else if (i->suspend)
441 i->suspend(i, state == PA_SINK_SUSPENDED);
442
443 if (s->monitor_source)
444 pa_source_sync_suspend(s->monitor_source);
445 }
446
447 return 0;
448 }
449
450 /* Called from main context */
451 void pa_sink_put(pa_sink* s) {
452 pa_sink_assert_ref(s);
453 pa_assert_ctl_context();
454
455 pa_assert(s->state == PA_SINK_INIT);
456 pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) || s->input_to_master);
457
458 /* The following fields must be initialized properly when calling _put() */
459 pa_assert(s->asyncmsgq);
460 pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency);
461
462 /* Generally, flags should be initialized via pa_sink_new(). As a
463 * special exception we allow volume related flags to be set
464 * between _new() and _put(). */
465
466 /* XXX: Currently decibel volume is disabled for all sinks that use volume
467 * sharing. When the master sink supports decibel volume, it would be good
468 * to have the flag also in the filter sink, but currently we don't do that
469 * so that the flags of the filter sink never change when it's moved from
470 * a master sink to another. One solution for this problem would be to
471 * remove user-visible volume altogether from filter sinks when volume
472 * sharing is used, but the current approach was easier to implement... */
473 if (!(s->flags & PA_SINK_HW_VOLUME_CTRL) && !(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
474 s->flags |= PA_SINK_DECIBEL_VOLUME;
475
476 if ((s->flags & PA_SINK_DECIBEL_VOLUME) && s->core->flat_volumes)
477 s->flags |= PA_SINK_FLAT_VOLUME;
478
479 if (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) {
480 pa_sink *root_sink = s->input_to_master->sink;
481
482 while (root_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)
483 root_sink = root_sink->input_to_master->sink;
484
485 s->reference_volume = root_sink->reference_volume;
486 pa_cvolume_remap(&s->reference_volume, &root_sink->channel_map, &s->channel_map);
487
488 s->real_volume = root_sink->real_volume;
489 pa_cvolume_remap(&s->real_volume, &root_sink->channel_map, &s->channel_map);
490 } else
491 /* We assume that if the sink implementor changed the default
492 * volume he did so in real_volume, because that is the usual
493 * place where he is supposed to place his changes. */
494 s->reference_volume = s->real_volume;
495
496 s->thread_info.soft_volume = s->soft_volume;
497 s->thread_info.soft_muted = s->muted;
498 pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
499
500 pa_assert((s->flags & PA_SINK_HW_VOLUME_CTRL)
501 || (s->base_volume == PA_VOLUME_NORM
502 && ((s->flags & PA_SINK_DECIBEL_VOLUME || (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)))));
503 pa_assert(!(s->flags & PA_SINK_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1);
504 pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == (s->thread_info.fixed_latency != 0));
505 pa_assert(!(s->flags & PA_SINK_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_LATENCY));
506 pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_DYNAMIC_LATENCY));
507 pa_assert(!(s->flags & PA_SINK_HW_VOLUME_CTRL) || s->set_volume);
508 pa_assert(!(s->flags & PA_SINK_SYNC_VOLUME) || (s->flags & PA_SINK_HW_VOLUME_CTRL));
509 pa_assert(!(s->flags & PA_SINK_SYNC_VOLUME) || s->write_volume);
510 pa_assert(!(s->flags & PA_SINK_HW_MUTE_CTRL) || s->set_mute);
511
512 pa_assert(s->monitor_source->thread_info.fixed_latency == s->thread_info.fixed_latency);
513 pa_assert(s->monitor_source->thread_info.min_latency == s->thread_info.min_latency);
514 pa_assert(s->monitor_source->thread_info.max_latency == s->thread_info.max_latency);
515
516 pa_assert_se(sink_set_state(s, PA_SINK_IDLE) == 0);
517
518 pa_source_put(s->monitor_source);
519
520 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_NEW, s->index);
521 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PUT], s);
522 }
523
524 /* Called from main context */
525 void pa_sink_unlink(pa_sink* s) {
526 pa_bool_t linked;
527 pa_sink_input *i, *j = NULL;
528
529 pa_assert(s);
530 pa_assert_ctl_context();
531
532 /* Please note that pa_sink_unlink() does more than simply
533 * reversing pa_sink_put(). It also undoes the registrations
534 * already done in pa_sink_new()! */
535
536 /* All operations here shall be idempotent, i.e. pa_sink_unlink()
537 * may be called multiple times on the same sink without bad
538 * effects. */
539
540 linked = PA_SINK_IS_LINKED(s->state);
541
542 if (linked)
543 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK], s);
544
545 if (s->state != PA_SINK_UNLINKED)
546 pa_namereg_unregister(s->core, s->name);
547 pa_idxset_remove_by_data(s->core->sinks, s, NULL);
548
549 if (s->card)
550 pa_idxset_remove_by_data(s->card->sinks, s, NULL);
551
552 while ((i = pa_idxset_first(s->inputs, NULL))) {
553 pa_assert(i != j);
554 pa_sink_input_kill(i);
555 j = i;
556 }
557
558 if (linked)
559 sink_set_state(s, PA_SINK_UNLINKED);
560 else
561 s->state = PA_SINK_UNLINKED;
562
563 reset_callbacks(s);
564
565 if (s->monitor_source)
566 pa_source_unlink(s->monitor_source);
567
568 if (linked) {
569 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
570 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK_POST], s);
571 }
572 }
573
574 /* Called from main context */
575 static void sink_free(pa_object *o) {
576 pa_sink *s = PA_SINK(o);
577 pa_sink_input *i;
578
579 pa_assert(s);
580 pa_assert_ctl_context();
581 pa_assert(pa_sink_refcnt(s) == 0);
582
583 if (PA_SINK_IS_LINKED(s->state))
584 pa_sink_unlink(s);
585
586 pa_log_info("Freeing sink %u \"%s\"", s->index, s->name);
587
588 if (s->monitor_source) {
589 pa_source_unref(s->monitor_source);
590 s->monitor_source = NULL;
591 }
592
593 pa_idxset_free(s->inputs, NULL, NULL);
594
595 while ((i = pa_hashmap_steal_first(s->thread_info.inputs)))
596 pa_sink_input_unref(i);
597
598 pa_hashmap_free(s->thread_info.inputs, NULL, NULL);
599
600 if (s->silence.memblock)
601 pa_memblock_unref(s->silence.memblock);
602
603 pa_xfree(s->name);
604 pa_xfree(s->driver);
605
606 if (s->proplist)
607 pa_proplist_free(s->proplist);
608
609 if (s->ports) {
610 pa_device_port *p;
611
612 while ((p = pa_hashmap_steal_first(s->ports)))
613 pa_device_port_free(p);
614
615 pa_hashmap_free(s->ports, NULL, NULL);
616 }
617
618 pa_xfree(s);
619 }
620
621 /* Called from main context, and not while the IO thread is active, please */
622 void pa_sink_set_asyncmsgq(pa_sink *s, pa_asyncmsgq *q) {
623 pa_sink_assert_ref(s);
624 pa_assert_ctl_context();
625
626 s->asyncmsgq = q;
627
628 if (s->monitor_source)
629 pa_source_set_asyncmsgq(s->monitor_source, q);
630 }
631
632 /* Called from main context, and not while the IO thread is active, please */
633 void pa_sink_update_flags(pa_sink *s, pa_sink_flags_t mask, pa_sink_flags_t value) {
634 pa_sink_assert_ref(s);
635 pa_assert_ctl_context();
636
637 if (mask == 0)
638 return;
639
640 /* For now, allow only a minimal set of flags to be changed. */
641 pa_assert((mask & ~(PA_SINK_DYNAMIC_LATENCY|PA_SINK_LATENCY)) == 0);
642
643 s->flags = (s->flags & ~mask) | (value & mask);
644
645 pa_source_update_flags(s->monitor_source,
646 ((mask & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
647 ((mask & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0),
648 ((value & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
649 ((value & PA_SINK_DYNAMIC_LATENCY) ? PA_SINK_DYNAMIC_LATENCY : 0));
650 }
651
652 /* Called from IO context, or before _put() from main context */
653 void pa_sink_set_rtpoll(pa_sink *s, pa_rtpoll *p) {
654 pa_sink_assert_ref(s);
655 pa_sink_assert_io_context(s);
656
657 s->thread_info.rtpoll = p;
658
659 if (s->monitor_source)
660 pa_source_set_rtpoll(s->monitor_source, p);
661 }
662
663 /* Called from main context */
664 int pa_sink_update_status(pa_sink*s) {
665 pa_sink_assert_ref(s);
666 pa_assert_ctl_context();
667 pa_assert(PA_SINK_IS_LINKED(s->state));
668
669 if (s->state == PA_SINK_SUSPENDED)
670 return 0;
671
672 return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
673 }
674
675 /* Called from main context */
676 int pa_sink_suspend(pa_sink *s, pa_bool_t suspend, pa_suspend_cause_t cause) {
677 pa_sink_assert_ref(s);
678 pa_assert_ctl_context();
679 pa_assert(PA_SINK_IS_LINKED(s->state));
680 pa_assert(cause != 0);
681
682 if (suspend) {
683 s->suspend_cause |= cause;
684 s->monitor_source->suspend_cause |= cause;
685 } else {
686 s->suspend_cause &= ~cause;
687 s->monitor_source->suspend_cause &= ~cause;
688 }
689
690 if ((pa_sink_get_state(s) == PA_SINK_SUSPENDED) == !!s->suspend_cause)
691 return 0;
692
693 pa_log_debug("Suspend cause of sink %s is 0x%04x, %s", s->name, s->suspend_cause, s->suspend_cause ? "suspending" : "resuming");
694
695 if (s->suspend_cause)
696 return sink_set_state(s, PA_SINK_SUSPENDED);
697 else
698 return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
699 }
700
701 /* Called from main context */
702 pa_queue *pa_sink_move_all_start(pa_sink *s, pa_queue *q) {
703 pa_sink_input *i, *n;
704 uint32_t idx;
705
706 pa_sink_assert_ref(s);
707 pa_assert_ctl_context();
708 pa_assert(PA_SINK_IS_LINKED(s->state));
709
710 if (!q)
711 q = pa_queue_new();
712
713 for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = n) {
714 n = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx));
715
716 pa_sink_input_ref(i);
717
718 if (pa_sink_input_start_move(i) >= 0)
719 pa_queue_push(q, i);
720 else
721 pa_sink_input_unref(i);
722 }
723
724 return q;
725 }
726
727 /* Called from main context */
728 void pa_sink_move_all_finish(pa_sink *s, pa_queue *q, pa_bool_t save) {
729 pa_sink_input *i;
730
731 pa_sink_assert_ref(s);
732 pa_assert_ctl_context();
733 pa_assert(PA_SINK_IS_LINKED(s->state));
734 pa_assert(q);
735
736 while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
737 if (pa_sink_input_finish_move(i, s, save) < 0)
738 pa_sink_input_fail_move(i);
739
740 pa_sink_input_unref(i);
741 }
742
743 pa_queue_free(q, NULL, NULL);
744 }
745
746 /* Called from main context */
747 void pa_sink_move_all_fail(pa_queue *q) {
748 pa_sink_input *i;
749
750 pa_assert_ctl_context();
751 pa_assert(q);
752
753 while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
754 pa_sink_input_fail_move(i);
755 pa_sink_input_unref(i);
756 }
757
758 pa_queue_free(q, NULL, NULL);
759 }
760
761 /* Called from IO thread context */
762 void pa_sink_process_rewind(pa_sink *s, size_t nbytes) {
763 pa_sink_input *i;
764 void *state = NULL;
765
766 pa_sink_assert_ref(s);
767 pa_sink_assert_io_context(s);
768 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
769
770 /* If nobody requested this and this is actually no real rewind
771 * then we can short cut this. Please note that this means that
772 * not all rewind requests triggered upstream will always be
773 * translated in actual requests! */
774 if (!s->thread_info.rewind_requested && nbytes <= 0)
775 return;
776
777 s->thread_info.rewind_nbytes = 0;
778 s->thread_info.rewind_requested = FALSE;
779
780 if (s->thread_info.state == PA_SINK_SUSPENDED)
781 return;
782
783 if (nbytes > 0) {
784 pa_log_debug("Processing rewind...");
785 if (s->flags & PA_SINK_SYNC_VOLUME)
786 pa_sink_volume_change_rewind(s, nbytes);
787 }
788
789 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
790 pa_sink_input_assert_ref(i);
791 pa_sink_input_process_rewind(i, nbytes);
792 }
793
794 if (nbytes > 0) {
795 if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
796 pa_source_process_rewind(s->monitor_source, nbytes);
797 }
798 }
799
800 /* Called from IO thread context */
801 static unsigned fill_mix_info(pa_sink *s, size_t *length, pa_mix_info *info, unsigned maxinfo) {
802 pa_sink_input *i;
803 unsigned n = 0;
804 void *state = NULL;
805 size_t mixlength = *length;
806
807 pa_sink_assert_ref(s);
808 pa_sink_assert_io_context(s);
809 pa_assert(info);
810
811 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)) && maxinfo > 0) {
812 pa_sink_input_assert_ref(i);
813
814 pa_sink_input_peek(i, *length, &info->chunk, &info->volume);
815
816 if (mixlength == 0 || info->chunk.length < mixlength)
817 mixlength = info->chunk.length;
818
819 if (pa_memblock_is_silence(info->chunk.memblock)) {
820 pa_memblock_unref(info->chunk.memblock);
821 continue;
822 }
823
824 info->userdata = pa_sink_input_ref(i);
825
826 pa_assert(info->chunk.memblock);
827 pa_assert(info->chunk.length > 0);
828
829 info++;
830 n++;
831 maxinfo--;
832 }
833
834 if (mixlength > 0)
835 *length = mixlength;
836
837 return n;
838 }
839
840 /* Called from IO thread context */
841 static void inputs_drop(pa_sink *s, pa_mix_info *info, unsigned n, pa_memchunk *result) {
842 pa_sink_input *i;
843 void *state;
844 unsigned p = 0;
845 unsigned n_unreffed = 0;
846
847 pa_sink_assert_ref(s);
848 pa_sink_assert_io_context(s);
849 pa_assert(result);
850 pa_assert(result->memblock);
851 pa_assert(result->length > 0);
852
853 /* We optimize for the case where the order of the inputs has not changed */
854
855 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
856 unsigned j;
857 pa_mix_info* m = NULL;
858
859 pa_sink_input_assert_ref(i);
860
861 /* Let's try to find the matching entry info the pa_mix_info array */
862 for (j = 0; j < n; j ++) {
863
864 if (info[p].userdata == i) {
865 m = info + p;
866 break;
867 }
868
869 p++;
870 if (p >= n)
871 p = 0;
872 }
873
874 /* Drop read data */
875 pa_sink_input_drop(i, result->length);
876
877 if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state)) {
878
879 if (pa_hashmap_size(i->thread_info.direct_outputs) > 0) {
880 void *ostate = NULL;
881 pa_source_output *o;
882 pa_memchunk c;
883
884 if (m && m->chunk.memblock) {
885 c = m->chunk;
886 pa_memblock_ref(c.memblock);
887 pa_assert(result->length <= c.length);
888 c.length = result->length;
889
890 pa_memchunk_make_writable(&c, 0);
891 pa_volume_memchunk(&c, &s->sample_spec, &m->volume);
892 } else {
893 c = s->silence;
894 pa_memblock_ref(c.memblock);
895 pa_assert(result->length <= c.length);
896 c.length = result->length;
897 }
898
899 while ((o = pa_hashmap_iterate(i->thread_info.direct_outputs, &ostate, NULL))) {
900 pa_source_output_assert_ref(o);
901 pa_assert(o->direct_on_input == i);
902 pa_source_post_direct(s->monitor_source, o, &c);
903 }
904
905 pa_memblock_unref(c.memblock);
906 }
907 }
908
909 if (m) {
910 if (m->chunk.memblock)
911 pa_memblock_unref(m->chunk.memblock);
912 pa_memchunk_reset(&m->chunk);
913
914 pa_sink_input_unref(m->userdata);
915 m->userdata = NULL;
916
917 n_unreffed += 1;
918 }
919 }
920
921 /* Now drop references to entries that are included in the
922 * pa_mix_info array but don't exist anymore */
923
924 if (n_unreffed < n) {
925 for (; n > 0; info++, n--) {
926 if (info->userdata)
927 pa_sink_input_unref(info->userdata);
928 if (info->chunk.memblock)
929 pa_memblock_unref(info->chunk.memblock);
930 }
931 }
932
933 if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
934 pa_source_post(s->monitor_source, result);
935 }
936
937 /* Called from IO thread context */
938 void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result) {
939 pa_mix_info info[MAX_MIX_CHANNELS];
940 unsigned n;
941 size_t block_size_max;
942
943 pa_sink_assert_ref(s);
944 pa_sink_assert_io_context(s);
945 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
946 pa_assert(pa_frame_aligned(length, &s->sample_spec));
947 pa_assert(result);
948
949 pa_assert(!s->thread_info.rewind_requested);
950 pa_assert(s->thread_info.rewind_nbytes == 0);
951
952 if (s->thread_info.state == PA_SINK_SUSPENDED) {
953 result->memblock = pa_memblock_ref(s->silence.memblock);
954 result->index = s->silence.index;
955 result->length = PA_MIN(s->silence.length, length);
956 return;
957 }
958
959 pa_sink_ref(s);
960
961 if (length <= 0)
962 length = pa_frame_align(MIX_BUFFER_LENGTH, &s->sample_spec);
963
964 block_size_max = pa_mempool_block_size_max(s->core->mempool);
965 if (length > block_size_max)
966 length = pa_frame_align(block_size_max, &s->sample_spec);
967
968 pa_assert(length > 0);
969
970 n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
971
972 if (n == 0) {
973
974 *result = s->silence;
975 pa_memblock_ref(result->memblock);
976
977 if (result->length > length)
978 result->length = length;
979
980 } else if (n == 1) {
981 pa_cvolume volume;
982
983 *result = info[0].chunk;
984 pa_memblock_ref(result->memblock);
985
986 if (result->length > length)
987 result->length = length;
988
989 pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
990
991 if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume)) {
992 pa_memblock_unref(result->memblock);
993 pa_silence_memchunk_get(&s->core->silence_cache,
994 s->core->mempool,
995 result,
996 &s->sample_spec,
997 result->length);
998 } else if (!pa_cvolume_is_norm(&volume)) {
999 pa_memchunk_make_writable(result, 0);
1000 pa_volume_memchunk(result, &s->sample_spec, &volume);
1001 }
1002 } else {
1003 void *ptr;
1004 result->memblock = pa_memblock_new(s->core->mempool, length);
1005
1006 ptr = pa_memblock_acquire(result->memblock);
1007 result->length = pa_mix(info, n,
1008 ptr, length,
1009 &s->sample_spec,
1010 &s->thread_info.soft_volume,
1011 s->thread_info.soft_muted);
1012 pa_memblock_release(result->memblock);
1013
1014 result->index = 0;
1015 }
1016
1017 inputs_drop(s, info, n, result);
1018
1019 pa_sink_unref(s);
1020 }
1021
1022 /* Called from IO thread context */
1023 void pa_sink_render_into(pa_sink*s, pa_memchunk *target) {
1024 pa_mix_info info[MAX_MIX_CHANNELS];
1025 unsigned n;
1026 size_t length, block_size_max;
1027
1028 pa_sink_assert_ref(s);
1029 pa_sink_assert_io_context(s);
1030 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1031 pa_assert(target);
1032 pa_assert(target->memblock);
1033 pa_assert(target->length > 0);
1034 pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
1035
1036 pa_assert(!s->thread_info.rewind_requested);
1037 pa_assert(s->thread_info.rewind_nbytes == 0);
1038
1039 if (s->thread_info.state == PA_SINK_SUSPENDED) {
1040 pa_silence_memchunk(target, &s->sample_spec);
1041 return;
1042 }
1043
1044 pa_sink_ref(s);
1045
1046 length = target->length;
1047 block_size_max = pa_mempool_block_size_max(s->core->mempool);
1048 if (length > block_size_max)
1049 length = pa_frame_align(block_size_max, &s->sample_spec);
1050
1051 pa_assert(length > 0);
1052
1053 n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
1054
1055 if (n == 0) {
1056 if (target->length > length)
1057 target->length = length;
1058
1059 pa_silence_memchunk(target, &s->sample_spec);
1060 } else if (n == 1) {
1061 pa_cvolume volume;
1062
1063 if (target->length > length)
1064 target->length = length;
1065
1066 pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
1067
1068 if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume))
1069 pa_silence_memchunk(target, &s->sample_spec);
1070 else {
1071 pa_memchunk vchunk;
1072
1073 vchunk = info[0].chunk;
1074 pa_memblock_ref(vchunk.memblock);
1075
1076 if (vchunk.length > length)
1077 vchunk.length = length;
1078
1079 if (!pa_cvolume_is_norm(&volume)) {
1080 pa_memchunk_make_writable(&vchunk, 0);
1081 pa_volume_memchunk(&vchunk, &s->sample_spec, &volume);
1082 }
1083
1084 pa_memchunk_memcpy(target, &vchunk);
1085 pa_memblock_unref(vchunk.memblock);
1086 }
1087
1088 } else {
1089 void *ptr;
1090
1091 ptr = pa_memblock_acquire(target->memblock);
1092
1093 target->length = pa_mix(info, n,
1094 (uint8_t*) ptr + target->index, length,
1095 &s->sample_spec,
1096 &s->thread_info.soft_volume,
1097 s->thread_info.soft_muted);
1098
1099 pa_memblock_release(target->memblock);
1100 }
1101
1102 inputs_drop(s, info, n, target);
1103
1104 pa_sink_unref(s);
1105 }
1106
1107 /* Called from IO thread context */
1108 void pa_sink_render_into_full(pa_sink *s, pa_memchunk *target) {
1109 pa_memchunk chunk;
1110 size_t l, d;
1111
1112 pa_sink_assert_ref(s);
1113 pa_sink_assert_io_context(s);
1114 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1115 pa_assert(target);
1116 pa_assert(target->memblock);
1117 pa_assert(target->length > 0);
1118 pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
1119
1120 pa_assert(!s->thread_info.rewind_requested);
1121 pa_assert(s->thread_info.rewind_nbytes == 0);
1122
1123 if (s->thread_info.state == PA_SINK_SUSPENDED) {
1124 pa_silence_memchunk(target, &s->sample_spec);
1125 return;
1126 }
1127
1128 pa_sink_ref(s);
1129
1130 l = target->length;
1131 d = 0;
1132 while (l > 0) {
1133 chunk = *target;
1134 chunk.index += d;
1135 chunk.length -= d;
1136
1137 pa_sink_render_into(s, &chunk);
1138
1139 d += chunk.length;
1140 l -= chunk.length;
1141 }
1142
1143 pa_sink_unref(s);
1144 }
1145
1146 /* Called from IO thread context */
1147 void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result) {
1148 pa_sink_assert_ref(s);
1149 pa_sink_assert_io_context(s);
1150 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1151 pa_assert(length > 0);
1152 pa_assert(pa_frame_aligned(length, &s->sample_spec));
1153 pa_assert(result);
1154
1155 pa_assert(!s->thread_info.rewind_requested);
1156 pa_assert(s->thread_info.rewind_nbytes == 0);
1157
1158 pa_sink_ref(s);
1159
1160 pa_sink_render(s, length, result);
1161
1162 if (result->length < length) {
1163 pa_memchunk chunk;
1164
1165 pa_memchunk_make_writable(result, length);
1166
1167 chunk.memblock = result->memblock;
1168 chunk.index = result->index + result->length;
1169 chunk.length = length - result->length;
1170
1171 pa_sink_render_into_full(s, &chunk);
1172
1173 result->length = length;
1174 }
1175
1176 pa_sink_unref(s);
1177 }
1178
1179 /* Called from main thread */
1180 pa_usec_t pa_sink_get_latency(pa_sink *s) {
1181 pa_usec_t usec = 0;
1182
1183 pa_sink_assert_ref(s);
1184 pa_assert_ctl_context();
1185 pa_assert(PA_SINK_IS_LINKED(s->state));
1186
1187 /* The returned value is supposed to be in the time domain of the sound card! */
1188
1189 if (s->state == PA_SINK_SUSPENDED)
1190 return 0;
1191
1192 if (!(s->flags & PA_SINK_LATENCY))
1193 return 0;
1194
1195 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
1196
1197 return usec;
1198 }
1199
1200 /* Called from IO thread */
1201 pa_usec_t pa_sink_get_latency_within_thread(pa_sink *s) {
1202 pa_usec_t usec = 0;
1203 pa_msgobject *o;
1204
1205 pa_sink_assert_ref(s);
1206 pa_sink_assert_io_context(s);
1207 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1208
1209 /* The returned value is supposed to be in the time domain of the sound card! */
1210
1211 if (s->thread_info.state == PA_SINK_SUSPENDED)
1212 return 0;
1213
1214 if (!(s->flags & PA_SINK_LATENCY))
1215 return 0;
1216
1217 o = PA_MSGOBJECT(s);
1218
1219 /* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
1220
1221 if (o->process_msg(o, PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1222 return -1;
1223
1224 return usec;
1225 }
1226
1227 /* Called from the main thread (and also from the IO thread while the main
1228 * thread is waiting).
1229 *
1230 * When a sink uses volume sharing, it never has the PA_SINK_FLAT_VOLUME flag
1231 * set. Instead, flat volume mode is detected by checking whether the root sink
1232 * has the flag set. */
1233 pa_bool_t pa_sink_flat_volume_enabled(pa_sink *s) {
1234 pa_sink_assert_ref(s);
1235
1236 while (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)
1237 s = s->input_to_master->sink;
1238
1239 return (s->flags & PA_SINK_FLAT_VOLUME);
1240 }
1241
1242 /* Called from main context. */
1243 static void compute_reference_ratio(pa_sink_input *i) {
1244 unsigned c = 0;
1245 pa_cvolume remapped;
1246
1247 pa_assert(i);
1248 pa_assert(pa_sink_flat_volume_enabled(i->sink));
1249
1250 /*
1251 * Calculates the reference ratio from the sink's reference
1252 * volume. This basically calculates:
1253 *
1254 * i->reference_ratio = i->volume / i->sink->reference_volume
1255 */
1256
1257 remapped = i->sink->reference_volume;
1258 pa_cvolume_remap(&remapped, &i->sink->channel_map, &i->channel_map);
1259
1260 i->reference_ratio.channels = i->sample_spec.channels;
1261
1262 for (c = 0; c < i->sample_spec.channels; c++) {
1263
1264 /* We don't update when the sink volume is 0 anyway */
1265 if (remapped.values[c] <= PA_VOLUME_MUTED)
1266 continue;
1267
1268 /* Don't update the reference ratio unless necessary */
1269 if (pa_sw_volume_multiply(
1270 i->reference_ratio.values[c],
1271 remapped.values[c]) == i->volume.values[c])
1272 continue;
1273
1274 i->reference_ratio.values[c] = pa_sw_volume_divide(
1275 i->volume.values[c],
1276 remapped.values[c]);
1277 }
1278 }
1279
1280 /* Called from main context. Only called for the root sink in volume sharing
1281 * cases, except for internal recursive calls. */
1282 static void compute_reference_ratios(pa_sink *s) {
1283 uint32_t idx;
1284 pa_sink_input *i;
1285
1286 pa_sink_assert_ref(s);
1287 pa_assert_ctl_context();
1288 pa_assert(PA_SINK_IS_LINKED(s->state));
1289 pa_assert(pa_sink_flat_volume_enabled(s));
1290
1291 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1292 compute_reference_ratio(i);
1293
1294 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1295 compute_reference_ratios(i->origin_sink);
1296 }
1297 }
1298
1299 /* Called from main context. Only called for the root sink in volume sharing
1300 * cases, except for internal recursive calls. */
1301 static void compute_real_ratios(pa_sink *s) {
1302 pa_sink_input *i;
1303 uint32_t idx;
1304
1305 pa_sink_assert_ref(s);
1306 pa_assert_ctl_context();
1307 pa_assert(PA_SINK_IS_LINKED(s->state));
1308 pa_assert(pa_sink_flat_volume_enabled(s));
1309
1310 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1311 unsigned c;
1312 pa_cvolume remapped;
1313
1314 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1315 /* The origin sink uses volume sharing, so this input's real ratio
1316 * is handled as a special case - the real ratio must be 0 dB, and
1317 * as a result i->soft_volume must equal i->volume_factor. */
1318 pa_cvolume_reset(&i->real_ratio, i->real_ratio.channels);
1319 i->soft_volume = i->volume_factor;
1320
1321 compute_real_ratios(i->origin_sink);
1322
1323 continue;
1324 }
1325
1326 /*
1327 * This basically calculates:
1328 *
1329 * i->real_ratio := i->volume / s->real_volume
1330 * i->soft_volume := i->real_ratio * i->volume_factor
1331 */
1332
1333 remapped = s->real_volume;
1334 pa_cvolume_remap(&remapped, &s->channel_map, &i->channel_map);
1335
1336 i->real_ratio.channels = i->sample_spec.channels;
1337 i->soft_volume.channels = i->sample_spec.channels;
1338
1339 for (c = 0; c < i->sample_spec.channels; c++) {
1340
1341 if (remapped.values[c] <= PA_VOLUME_MUTED) {
1342 /* We leave i->real_ratio untouched */
1343 i->soft_volume.values[c] = PA_VOLUME_MUTED;
1344 continue;
1345 }
1346
1347 /* Don't lose accuracy unless necessary */
1348 if (pa_sw_volume_multiply(
1349 i->real_ratio.values[c],
1350 remapped.values[c]) != i->volume.values[c])
1351
1352 i->real_ratio.values[c] = pa_sw_volume_divide(
1353 i->volume.values[c],
1354 remapped.values[c]);
1355
1356 i->soft_volume.values[c] = pa_sw_volume_multiply(
1357 i->real_ratio.values[c],
1358 i->volume_factor.values[c]);
1359 }
1360
1361 /* We don't copy the soft_volume to the thread_info data
1362 * here. That must be done by the caller */
1363 }
1364 }
1365
1366 static pa_cvolume *cvolume_remap_minimal_impact(
1367 pa_cvolume *v,
1368 const pa_cvolume *template,
1369 const pa_channel_map *from,
1370 const pa_channel_map *to) {
1371
1372 pa_cvolume t;
1373
1374 pa_assert(v);
1375 pa_assert(template);
1376 pa_assert(from);
1377 pa_assert(to);
1378 pa_assert(pa_cvolume_compatible_with_channel_map(v, from));
1379 pa_assert(pa_cvolume_compatible_with_channel_map(template, to));
1380
1381 /* Much like pa_cvolume_remap(), but tries to minimize impact when
1382 * mapping from sink input to sink volumes:
1383 *
1384 * If template is a possible remapping from v it is used instead
1385 * of remapping anew.
1386 *
1387 * If the channel maps don't match we set an all-channel volume on
1388 * the sink to ensure that changing a volume on one stream has no
1389 * effect that cannot be compensated for in another stream that
1390 * does not have the same channel map as the sink. */
1391
1392 if (pa_channel_map_equal(from, to))
1393 return v;
1394
1395 t = *template;
1396 if (pa_cvolume_equal(pa_cvolume_remap(&t, to, from), v)) {
1397 *v = *template;
1398 return v;
1399 }
1400
1401 pa_cvolume_set(v, to->channels, pa_cvolume_max(v));
1402 return v;
1403 }
1404
1405 /* Called from main thread. Only called for the root sink in volume sharing
1406 * cases, except for internal recursive calls. */
1407 static void get_maximum_input_volume(pa_sink *s, pa_cvolume *max_volume, const pa_channel_map *channel_map) {
1408 pa_sink_input *i;
1409 uint32_t idx;
1410
1411 pa_sink_assert_ref(s);
1412 pa_assert(max_volume);
1413 pa_assert(channel_map);
1414 pa_assert(pa_sink_flat_volume_enabled(s));
1415
1416 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1417 pa_cvolume remapped;
1418
1419 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1420 get_maximum_input_volume(i->origin_sink, max_volume, channel_map);
1421
1422 /* Ignore this input. The origin sink uses volume sharing, so this
1423 * input's volume will be set to be equal to the root sink's real
1424 * volume. Obviously this input's current volume must not then
1425 * affect what the root sink's real volume will be. */
1426 continue;
1427 }
1428
1429 remapped = i->volume;
1430 cvolume_remap_minimal_impact(&remapped, max_volume, &i->channel_map, channel_map);
1431 pa_cvolume_merge(max_volume, max_volume, &remapped);
1432 }
1433 }
1434
1435 /* Called from main thread. Only called for the root sink in volume sharing
1436 * cases, except for internal recursive calls. */
1437 static pa_bool_t has_inputs(pa_sink *s) {
1438 pa_sink_input *i;
1439 uint32_t idx;
1440
1441 pa_sink_assert_ref(s);
1442
1443 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1444 if (!i->origin_sink || !(i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) || has_inputs(i->origin_sink))
1445 return TRUE;
1446 }
1447
1448 return FALSE;
1449 }
1450
1451 /* Called from main thread. Only called for the root sink in volume sharing
1452 * cases, except for internal recursive calls. */
1453 static void update_real_volume(pa_sink *s, const pa_cvolume *new_volume, pa_channel_map *channel_map) {
1454 pa_sink_input *i;
1455 uint32_t idx;
1456
1457 pa_sink_assert_ref(s);
1458 pa_assert(new_volume);
1459 pa_assert(channel_map);
1460
1461 s->real_volume = *new_volume;
1462 pa_cvolume_remap(&s->real_volume, channel_map, &s->channel_map);
1463
1464 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1465 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1466 if (pa_sink_flat_volume_enabled(s)) {
1467 pa_cvolume old_volume = i->volume;
1468
1469 /* Follow the root sink's real volume. */
1470 i->volume = *new_volume;
1471 pa_cvolume_remap(&i->volume, channel_map, &i->channel_map);
1472 compute_reference_ratio(i);
1473
1474 /* The volume changed, let's tell people so */
1475 if (!pa_cvolume_equal(&old_volume, &i->volume)) {
1476 if (i->volume_changed)
1477 i->volume_changed(i);
1478
1479 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1480 }
1481 }
1482
1483 update_real_volume(i->origin_sink, new_volume, channel_map);
1484 }
1485 }
1486 }
1487
1488 /* Called from main thread. Only called for the root sink in shared volume
1489 * cases. */
1490 static void compute_real_volume(pa_sink *s) {
1491 pa_sink_assert_ref(s);
1492 pa_assert_ctl_context();
1493 pa_assert(PA_SINK_IS_LINKED(s->state));
1494 pa_assert(pa_sink_flat_volume_enabled(s));
1495 pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1496
1497 /* This determines the maximum volume of all streams and sets
1498 * s->real_volume accordingly. */
1499
1500 if (!has_inputs(s)) {
1501 /* In the special case that we have no sink inputs we leave the
1502 * volume unmodified. */
1503 update_real_volume(s, &s->reference_volume, &s->channel_map);
1504 return;
1505 }
1506
1507 pa_cvolume_mute(&s->real_volume, s->channel_map.channels);
1508
1509 /* First let's determine the new maximum volume of all inputs
1510 * connected to this sink */
1511 get_maximum_input_volume(s, &s->real_volume, &s->channel_map);
1512 update_real_volume(s, &s->real_volume, &s->channel_map);
1513
1514 /* Then, let's update the real ratios/soft volumes of all inputs
1515 * connected to this sink */
1516 compute_real_ratios(s);
1517 }
1518
1519 /* Called from main thread. Only called for the root sink in shared volume
1520 * cases, except for internal recursive calls. */
1521 static void propagate_reference_volume(pa_sink *s) {
1522 pa_sink_input *i;
1523 uint32_t idx;
1524
1525 pa_sink_assert_ref(s);
1526 pa_assert_ctl_context();
1527 pa_assert(PA_SINK_IS_LINKED(s->state));
1528 pa_assert(pa_sink_flat_volume_enabled(s));
1529
1530 /* This is called whenever the sink volume changes that is not
1531 * caused by a sink input volume change. We need to fix up the
1532 * sink input volumes accordingly */
1533
1534 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1535 pa_cvolume old_volume;
1536
1537 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1538 propagate_reference_volume(i->origin_sink);
1539
1540 /* Since the origin sink uses volume sharing, this input's volume
1541 * needs to be updated to match the root sink's real volume, but
1542 * that will be done later in update_shared_real_volume(). */
1543 continue;
1544 }
1545
1546 old_volume = i->volume;
1547
1548 /* This basically calculates:
1549 *
1550 * i->volume := s->reference_volume * i->reference_ratio */
1551
1552 i->volume = s->reference_volume;
1553 pa_cvolume_remap(&i->volume, &s->channel_map, &i->channel_map);
1554 pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1555
1556 /* The volume changed, let's tell people so */
1557 if (!pa_cvolume_equal(&old_volume, &i->volume)) {
1558
1559 if (i->volume_changed)
1560 i->volume_changed(i);
1561
1562 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1563 }
1564 }
1565 }
1566
1567 /* Called from main thread. Only called for the root sink in volume sharing
1568 * cases, except for internal recursive calls. The return value indicates
1569 * whether any reference volume actually changed. */
1570 static pa_bool_t update_reference_volume(pa_sink *s, const pa_cvolume *v, const pa_channel_map *channel_map, pa_bool_t save) {
1571 pa_cvolume volume;
1572 pa_bool_t reference_volume_changed;
1573 pa_sink_input *i;
1574 uint32_t idx;
1575
1576 pa_sink_assert_ref(s);
1577 pa_assert(PA_SINK_IS_LINKED(s->state));
1578 pa_assert(v);
1579 pa_assert(channel_map);
1580 pa_assert(pa_cvolume_valid(v));
1581
1582 volume = *v;
1583 pa_cvolume_remap(&volume, channel_map, &s->channel_map);
1584
1585 reference_volume_changed = !pa_cvolume_equal(&volume, &s->reference_volume);
1586 s->reference_volume = volume;
1587
1588 s->save_volume = (!reference_volume_changed && s->save_volume) || save;
1589
1590 if (reference_volume_changed)
1591 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1592 else if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1593 /* If the root sink's volume doesn't change, then there can't be any
1594 * changes in the other sinks in the sink tree either.
1595 *
1596 * It's probably theoretically possible that even if the root sink's
1597 * volume changes slightly, some filter sink doesn't change its volume
1598 * due to rounding errors. If that happens, we still want to propagate
1599 * the changed root sink volume to the sinks connected to the
1600 * intermediate sink that didn't change its volume. This theoretical
1601 * possiblity is the reason why we have that !(s->flags &
1602 * PA_SINK_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
1603 * notice even if we returned here FALSE always if
1604 * reference_volume_changed is FALSE. */
1605 return FALSE;
1606
1607 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1608 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1609 update_reference_volume(i->origin_sink, v, channel_map, FALSE);
1610 }
1611
1612 return TRUE;
1613 }
1614
1615 /* Called from main thread */
1616 void pa_sink_set_volume(
1617 pa_sink *s,
1618 const pa_cvolume *volume,
1619 pa_bool_t send_msg,
1620 pa_bool_t save) {
1621
1622 pa_cvolume new_reference_volume;
1623 pa_sink *root_sink = s;
1624
1625 pa_sink_assert_ref(s);
1626 pa_assert_ctl_context();
1627 pa_assert(PA_SINK_IS_LINKED(s->state));
1628 pa_assert(!volume || pa_cvolume_valid(volume));
1629 pa_assert(volume || pa_sink_flat_volume_enabled(s));
1630 pa_assert(!volume || volume->channels == 1 || pa_cvolume_compatible(volume, &s->sample_spec));
1631
1632 /* make sure we don't change the volume when a PASSTHROUGH input is connected */
1633 if (s->flags & PA_SINK_PASSTHROUGH) {
1634 pa_sink_input *alt_i;
1635 uint32_t idx;
1636
1637 /* one and only one PASSTHROUGH input can possibly be connected */
1638 if (pa_idxset_size(s->inputs) == 1) {
1639
1640 alt_i = pa_idxset_first(s->inputs, &idx);
1641
1642 if (alt_i->flags & PA_SINK_INPUT_PASSTHROUGH) {
1643 /* FIXME: Need to notify client that volume control is disabled */
1644 pa_log_warn("Cannot change volume, Sink is connected to PASSTHROUGH input");
1645 return;
1646 }
1647 }
1648 }
1649
1650 /* In case of volume sharing, the volume is set for the root sink first,
1651 * from which it's then propagated to the sharing sinks. */
1652 while (root_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)
1653 root_sink = root_sink->input_to_master->sink;
1654
1655 /* As a special exception we accept mono volumes on all sinks --
1656 * even on those with more complex channel maps */
1657
1658 if (volume) {
1659 if (pa_cvolume_compatible(volume, &s->sample_spec))
1660 new_reference_volume = *volume;
1661 else {
1662 new_reference_volume = s->reference_volume;
1663 pa_cvolume_scale(&new_reference_volume, pa_cvolume_max(volume));
1664 }
1665
1666 pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_sink->channel_map);
1667 }
1668
1669 /* If volume is NULL we synchronize the sink's real and reference
1670 * volumes with the stream volumes. If it is not NULL we update
1671 * the reference_volume with it. */
1672
1673 if (volume) {
1674 if (update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save)) {
1675 if (pa_sink_flat_volume_enabled(root_sink)) {
1676 /* OK, propagate this volume change back to the inputs */
1677 propagate_reference_volume(root_sink);
1678
1679 /* And now recalculate the real volume */
1680 compute_real_volume(root_sink);
1681 } else
1682 update_real_volume(root_sink, &root_sink->reference_volume, &root_sink->channel_map);
1683 }
1684
1685 } else {
1686 pa_assert(pa_sink_flat_volume_enabled(root_sink));
1687
1688 /* Ok, let's determine the new real volume */
1689 compute_real_volume(root_sink);
1690
1691 /* Let's 'push' the reference volume if necessary */
1692 pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_sink->real_volume);
1693 update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save);
1694
1695 /* Now that the reference volume is updated, we can update the streams'
1696 * reference ratios. */
1697 compute_reference_ratios(root_sink);
1698 }
1699
1700 if (root_sink->set_volume) {
1701 /* If we have a function set_volume(), then we do not apply a
1702 * soft volume by default. However, set_volume() is free to
1703 * apply one to root_sink->soft_volume */
1704
1705 pa_cvolume_reset(&root_sink->soft_volume, root_sink->sample_spec.channels);
1706 if (!(root_sink->flags & PA_SINK_SYNC_VOLUME))
1707 root_sink->set_volume(root_sink);
1708 else
1709 send_msg = TRUE;
1710
1711 } else
1712 /* If we have no function set_volume(), then the soft volume
1713 * becomes the real volume */
1714 root_sink->soft_volume = root_sink->real_volume;
1715
1716 /* This tells the sink that soft volume and/or real volume changed */
1717 if (send_msg)
1718 pa_assert_se(pa_asyncmsgq_send(root_sink->asyncmsgq, PA_MSGOBJECT(root_sink), PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL) == 0);
1719 }
1720
1721 /* Called from the io thread if sync volume is used, otherwise from the main thread.
1722 * Only to be called by sink implementor */
1723 void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
1724 pa_sink_assert_ref(s);
1725 pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1726 if (s->flags & PA_SINK_SYNC_VOLUME)
1727 pa_sink_assert_io_context(s);
1728 else
1729 pa_assert_ctl_context();
1730
1731 if (!volume)
1732 pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
1733 else
1734 s->soft_volume = *volume;
1735
1736 if (PA_SINK_IS_LINKED(s->state) && !(s->flags & PA_SINK_SYNC_VOLUME))
1737 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
1738 else
1739 s->thread_info.soft_volume = s->soft_volume;
1740 }
1741
1742 /* Called from the main thread. Only called for the root sink in volume sharing
1743 * cases, except for internal recursive calls. */
1744 static void propagate_real_volume(pa_sink *s, const pa_cvolume *old_real_volume) {
1745 pa_sink_input *i;
1746 uint32_t idx;
1747
1748 pa_sink_assert_ref(s);
1749 pa_assert(old_real_volume);
1750 pa_assert_ctl_context();
1751 pa_assert(PA_SINK_IS_LINKED(s->state));
1752
1753 /* This is called when the hardware's real volume changes due to
1754 * some external event. We copy the real volume into our
1755 * reference volume and then rebuild the stream volumes based on
1756 * i->real_ratio which should stay fixed. */
1757
1758 if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1759 if (pa_cvolume_equal(old_real_volume, &s->real_volume))
1760 return;
1761
1762 /* 1. Make the real volume the reference volume */
1763 update_reference_volume(s, &s->real_volume, &s->channel_map, TRUE);
1764 }
1765
1766 if (pa_sink_flat_volume_enabled(s)) {
1767
1768 PA_IDXSET_FOREACH(i, s->inputs, idx) {
1769 pa_cvolume old_volume = i->volume;
1770
1771 /* 2. Since the sink's reference and real volumes are equal
1772 * now our ratios should be too. */
1773 i->reference_ratio = i->real_ratio;
1774
1775 /* 3. Recalculate the new stream reference volume based on the
1776 * reference ratio and the sink's reference volume.
1777 *
1778 * This basically calculates:
1779 *
1780 * i->volume = s->reference_volume * i->reference_ratio
1781 *
1782 * This is identical to propagate_reference_volume() */
1783 i->volume = s->reference_volume;
1784 pa_cvolume_remap(&i->volume, &s->channel_map, &i->channel_map);
1785 pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1786
1787 /* Notify if something changed */
1788 if (!pa_cvolume_equal(&old_volume, &i->volume)) {
1789
1790 if (i->volume_changed)
1791 i->volume_changed(i);
1792
1793 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1794 }
1795
1796 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1797 propagate_real_volume(i->origin_sink, old_real_volume);
1798 }
1799 }
1800
1801 /* Something got changed in the hardware. It probably makes sense
1802 * to save changed hw settings given that hw volume changes not
1803 * triggered by PA are almost certainly done by the user. */
1804 if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1805 s->save_volume = TRUE;
1806 }
1807
1808 /* Called from io thread */
1809 void pa_sink_update_volume_and_mute(pa_sink *s) {
1810 pa_assert(s);
1811 pa_sink_assert_io_context(s);
1812
1813 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE, NULL, 0, NULL, NULL);
1814 }
1815
1816 /* Called from main thread */
1817 const pa_cvolume *pa_sink_get_volume(pa_sink *s, pa_bool_t force_refresh) {
1818 pa_sink_assert_ref(s);
1819 pa_assert_ctl_context();
1820 pa_assert(PA_SINK_IS_LINKED(s->state));
1821
1822 if (s->refresh_volume || force_refresh) {
1823 struct pa_cvolume old_real_volume;
1824
1825 pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1826
1827 old_real_volume = s->real_volume;
1828
1829 if (!(s->flags & PA_SINK_SYNC_VOLUME) && s->get_volume)
1830 s->get_volume(s);
1831
1832 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
1833
1834 update_real_volume(s, &s->real_volume, &s->channel_map);
1835 propagate_real_volume(s, &old_real_volume);
1836 }
1837
1838 return &s->reference_volume;
1839 }
1840
1841 /* Called from main thread. In volume sharing cases, only the root sink may
1842 * call this. */
1843 void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_real_volume) {
1844 pa_cvolume old_real_volume;
1845
1846 pa_sink_assert_ref(s);
1847 pa_assert_ctl_context();
1848 pa_assert(PA_SINK_IS_LINKED(s->state));
1849 pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1850
1851 /* The sink implementor may call this if the volume changed to make sure everyone is notified */
1852
1853 old_real_volume = s->real_volume;
1854 update_real_volume(s, new_real_volume, &s->channel_map);
1855 propagate_real_volume(s, &old_real_volume);
1856 }
1857
1858 /* Called from main thread */
1859 void pa_sink_set_mute(pa_sink *s, pa_bool_t mute, pa_bool_t save) {
1860 pa_bool_t old_muted;
1861
1862 pa_sink_assert_ref(s);
1863 pa_assert_ctl_context();
1864 pa_assert(PA_SINK_IS_LINKED(s->state));
1865
1866 old_muted = s->muted;
1867 s->muted = mute;
1868 s->save_muted = (old_muted == s->muted && s->save_muted) || save;
1869
1870 if (!(s->flags & PA_SINK_SYNC_VOLUME) && s->set_mute)
1871 s->set_mute(s);
1872
1873 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1874
1875 if (old_muted != s->muted)
1876 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1877 }
1878
1879 /* Called from main thread */
1880 pa_bool_t pa_sink_get_mute(pa_sink *s, pa_bool_t force_refresh) {
1881
1882 pa_sink_assert_ref(s);
1883 pa_assert_ctl_context();
1884 pa_assert(PA_SINK_IS_LINKED(s->state));
1885
1886 if (s->refresh_muted || force_refresh) {
1887 pa_bool_t old_muted = s->muted;
1888
1889 if (!(s->flags & PA_SINK_SYNC_VOLUME) && s->get_mute)
1890 s->get_mute(s);
1891
1892 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
1893
1894 if (old_muted != s->muted) {
1895 s->save_muted = TRUE;
1896
1897 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1898
1899 /* Make sure the soft mute status stays in sync */
1900 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1901 }
1902 }
1903
1904 return s->muted;
1905 }
1906
1907 /* Called from main thread */
1908 void pa_sink_mute_changed(pa_sink *s, pa_bool_t new_muted) {
1909 pa_sink_assert_ref(s);
1910 pa_assert_ctl_context();
1911 pa_assert(PA_SINK_IS_LINKED(s->state));
1912
1913 /* The sink implementor may call this if the volume changed to make sure everyone is notified */
1914
1915 if (s->muted == new_muted)
1916 return;
1917
1918 s->muted = new_muted;
1919 s->save_muted = TRUE;
1920
1921 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1922 }
1923
1924 /* Called from main thread */
1925 pa_bool_t pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p) {
1926 pa_sink_assert_ref(s);
1927 pa_assert_ctl_context();
1928
1929 if (p)
1930 pa_proplist_update(s->proplist, mode, p);
1931
1932 if (PA_SINK_IS_LINKED(s->state)) {
1933 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
1934 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1935 }
1936
1937 return TRUE;
1938 }
1939
1940 /* Called from main thread */
1941 /* FIXME -- this should be dropped and be merged into pa_sink_update_proplist() */
1942 void pa_sink_set_description(pa_sink *s, const char *description) {
1943 const char *old;
1944 pa_sink_assert_ref(s);
1945 pa_assert_ctl_context();
1946
1947 if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
1948 return;
1949
1950 old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1951
1952 if (old && description && pa_streq(old, description))
1953 return;
1954
1955 if (description)
1956 pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
1957 else
1958 pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1959
1960 if (s->monitor_source) {
1961 char *n;
1962
1963 n = pa_sprintf_malloc("Monitor Source of %s", description ? description : s->name);
1964 pa_source_set_description(s->monitor_source, n);
1965 pa_xfree(n);
1966 }
1967
1968 if (PA_SINK_IS_LINKED(s->state)) {
1969 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1970 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
1971 }
1972 }
1973
1974 /* Called from main thread */
1975 unsigned pa_sink_linked_by(pa_sink *s) {
1976 unsigned ret;
1977
1978 pa_sink_assert_ref(s);
1979 pa_assert_ctl_context();
1980 pa_assert(PA_SINK_IS_LINKED(s->state));
1981
1982 ret = pa_idxset_size(s->inputs);
1983
1984 /* We add in the number of streams connected to us here. Please
1985 * note the asymmmetry to pa_sink_used_by()! */
1986
1987 if (s->monitor_source)
1988 ret += pa_source_linked_by(s->monitor_source);
1989
1990 return ret;
1991 }
1992
1993 /* Called from main thread */
1994 unsigned pa_sink_used_by(pa_sink *s) {
1995 unsigned ret;
1996
1997 pa_sink_assert_ref(s);
1998 pa_assert_ctl_context();
1999 pa_assert(PA_SINK_IS_LINKED(s->state));
2000
2001 ret = pa_idxset_size(s->inputs);
2002 pa_assert(ret >= s->n_corked);
2003
2004 /* Streams connected to our monitor source do not matter for
2005 * pa_sink_used_by()!.*/
2006
2007 return ret - s->n_corked;
2008 }
2009
2010 /* Called from main thread */
2011 unsigned pa_sink_check_suspend(pa_sink *s) {
2012 unsigned ret;
2013 pa_sink_input *i;
2014 uint32_t idx;
2015
2016 pa_sink_assert_ref(s);
2017 pa_assert_ctl_context();
2018
2019 if (!PA_SINK_IS_LINKED(s->state))
2020 return 0;
2021
2022 ret = 0;
2023
2024 PA_IDXSET_FOREACH(i, s->inputs, idx) {
2025 pa_sink_input_state_t st;
2026
2027 st = pa_sink_input_get_state(i);
2028
2029 /* We do not assert here. It is perfectly valid for a sink input to
2030 * be in the INIT state (i.e. created, marked done but not yet put)
2031 * and we should not care if it's unlinked as it won't contribute
2032 * towarards our busy status.
2033 */
2034 if (!PA_SINK_INPUT_IS_LINKED(st))
2035 continue;
2036
2037 if (st == PA_SINK_INPUT_CORKED)
2038 continue;
2039
2040 if (i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND)
2041 continue;
2042
2043 ret ++;
2044 }
2045
2046 if (s->monitor_source)
2047 ret += pa_source_check_suspend(s->monitor_source);
2048
2049 return ret;
2050 }
2051
2052 /* Called from the IO thread */
2053 static void sync_input_volumes_within_thread(pa_sink *s) {
2054 pa_sink_input *i;
2055 void *state = NULL;
2056
2057 pa_sink_assert_ref(s);
2058 pa_sink_assert_io_context(s);
2059
2060 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2061 if (pa_atomic_load(&i->before_ramping_v))
2062 i->thread_info.future_soft_volume = i->soft_volume;
2063
2064 if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume))
2065 continue;
2066
2067 if (!pa_atomic_load(&i->before_ramping_v))
2068 i->thread_info.soft_volume = i->soft_volume;
2069
2070 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
2071 }
2072 }
2073
2074 /* Called from the IO thread. Only called for the root sink in volume sharing
2075 * cases, except for internal recursive calls. */
2076 static void set_shared_volume_within_thread(pa_sink *s) {
2077 pa_sink_input *i = NULL;
2078 void *state = NULL;
2079
2080 pa_sink_assert_ref(s);
2081
2082 PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
2083
2084 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2085 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2086 set_shared_volume_within_thread(i->origin_sink);
2087 }
2088 }
2089
2090 /* Called from IO thread, except when it is not */
2091 int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2092 pa_sink *s = PA_SINK(o);
2093 pa_sink_assert_ref(s);
2094
2095 switch ((pa_sink_message_t) code) {
2096
2097 case PA_SINK_MESSAGE_ADD_INPUT: {
2098 pa_sink_input *i = PA_SINK_INPUT(userdata);
2099
2100 /* If you change anything here, make sure to change the
2101 * sink input handling a few lines down at
2102 * PA_SINK_MESSAGE_FINISH_MOVE, too. */
2103
2104 pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2105
2106 /* Since the caller sleeps in pa_sink_input_put(), we can
2107 * safely access data outside of thread_info even though
2108 * it is mutable */
2109
2110 if ((i->thread_info.sync_prev = i->sync_prev)) {
2111 pa_assert(i->sink == i->thread_info.sync_prev->sink);
2112 pa_assert(i->sync_prev->sync_next == i);
2113 i->thread_info.sync_prev->thread_info.sync_next = i;
2114 }
2115
2116 if ((i->thread_info.sync_next = i->sync_next)) {
2117 pa_assert(i->sink == i->thread_info.sync_next->sink);
2118 pa_assert(i->sync_next->sync_prev == i);
2119 i->thread_info.sync_next->thread_info.sync_prev = i;
2120 }
2121
2122 pa_assert(!i->thread_info.attached);
2123 i->thread_info.attached = TRUE;
2124
2125 if (i->attach)
2126 i->attach(i);
2127
2128 pa_sink_input_set_state_within_thread(i, i->state);
2129
2130 /* The requested latency of the sink input needs to be
2131 * fixed up and then configured on the sink */
2132
2133 if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2134 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2135
2136 pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2137 pa_sink_input_update_max_request(i, s->thread_info.max_request);
2138
2139 /* We don't rewind here automatically. This is left to the
2140 * sink input implementor because some sink inputs need a
2141 * slow start, i.e. need some time to buffer client
2142 * samples before beginning streaming. */
2143
2144 /* In flat volume mode we need to update the volume as
2145 * well */
2146 return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2147 }
2148
2149 case PA_SINK_MESSAGE_REMOVE_INPUT: {
2150 pa_sink_input *i = PA_SINK_INPUT(userdata);
2151
2152 /* If you change anything here, make sure to change the
2153 * sink input handling a few lines down at
2154 * PA_SINK_MESSAGE_PREPAPRE_MOVE, too. */
2155
2156 if (i->detach)
2157 i->detach(i);
2158
2159 pa_sink_input_set_state_within_thread(i, i->state);
2160
2161 pa_assert(i->thread_info.attached);
2162 i->thread_info.attached = FALSE;
2163
2164 /* Since the caller sleeps in pa_sink_input_unlink(),
2165 * we can safely access data outside of thread_info even
2166 * though it is mutable */
2167
2168 pa_assert(!i->sync_prev);
2169 pa_assert(!i->sync_next);
2170
2171 if (i->thread_info.sync_prev) {
2172 i->thread_info.sync_prev->thread_info.sync_next = i->thread_info.sync_prev->sync_next;
2173 i->thread_info.sync_prev = NULL;
2174 }
2175
2176 if (i->thread_info.sync_next) {
2177 i->thread_info.sync_next->thread_info.sync_prev = i->thread_info.sync_next->sync_prev;
2178 i->thread_info.sync_next = NULL;
2179 }
2180
2181 if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
2182 pa_sink_input_unref(i);
2183
2184 pa_sink_invalidate_requested_latency(s, TRUE);
2185 pa_sink_request_rewind(s, (size_t) -1);
2186
2187 /* In flat volume mode we need to update the volume as
2188 * well */
2189 return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2190 }
2191
2192 case PA_SINK_MESSAGE_START_MOVE: {
2193 pa_sink_input *i = PA_SINK_INPUT(userdata);
2194
2195 /* We don't support moving synchronized streams. */
2196 pa_assert(!i->sync_prev);
2197 pa_assert(!i->sync_next);
2198 pa_assert(!i->thread_info.sync_next);
2199 pa_assert(!i->thread_info.sync_prev);
2200
2201 if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2202 pa_usec_t usec = 0;
2203 size_t sink_nbytes, total_nbytes;
2204
2205 /* Get the latency of the sink */
2206 usec = pa_sink_get_latency_within_thread(s);
2207 sink_nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2208 total_nbytes = sink_nbytes + pa_memblockq_get_length(i->thread_info.render_memblockq);
2209
2210 if (total_nbytes > 0) {
2211 i->thread_info.rewrite_nbytes = i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, total_nbytes) : total_nbytes;
2212 i->thread_info.rewrite_flush = TRUE;
2213 pa_sink_input_process_rewind(i, sink_nbytes);
2214 }
2215 }
2216
2217 if (i->detach)
2218 i->detach(i);
2219
2220 pa_assert(i->thread_info.attached);
2221 i->thread_info.attached = FALSE;
2222
2223 /* Let's remove the sink input ...*/
2224 if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
2225 pa_sink_input_unref(i);
2226
2227 pa_sink_invalidate_requested_latency(s, TRUE);
2228
2229 pa_log_debug("Requesting rewind due to started move");
2230 pa_sink_request_rewind(s, (size_t) -1);
2231
2232 /* In flat volume mode we need to update the volume as
2233 * well */
2234 return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2235 }
2236
2237 case PA_SINK_MESSAGE_FINISH_MOVE: {
2238 pa_sink_input *i = PA_SINK_INPUT(userdata);
2239
2240 /* We don't support moving synchronized streams. */
2241 pa_assert(!i->sync_prev);
2242 pa_assert(!i->sync_next);
2243 pa_assert(!i->thread_info.sync_next);
2244 pa_assert(!i->thread_info.sync_prev);
2245
2246 pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2247
2248 pa_assert(!i->thread_info.attached);
2249 i->thread_info.attached = TRUE;
2250
2251 if (i->attach)
2252 i->attach(i);
2253
2254 if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2255 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2256
2257 pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2258 pa_sink_input_update_max_request(i, s->thread_info.max_request);
2259
2260 if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2261 pa_usec_t usec = 0;
2262 size_t nbytes;
2263
2264 /* Get the latency of the sink */
2265 usec = pa_sink_get_latency_within_thread(s);
2266 nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2267
2268 if (nbytes > 0)
2269 pa_sink_input_drop(i, nbytes);
2270
2271 pa_log_debug("Requesting rewind due to finished move");
2272 pa_sink_request_rewind(s, nbytes);
2273 }
2274
2275 return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2276 }
2277
2278 case PA_SINK_MESSAGE_SET_SHARED_VOLUME: {
2279 pa_sink *root_sink = s;
2280
2281 while (root_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)
2282 root_sink = root_sink->input_to_master->sink;
2283
2284 set_shared_volume_within_thread(root_sink);
2285 return 0;
2286 }
2287
2288 case PA_SINK_MESSAGE_SET_VOLUME_SYNCED:
2289
2290 if (s->flags & PA_SINK_SYNC_VOLUME) {
2291 s->set_volume(s);
2292 pa_sink_volume_change_push(s);
2293 }
2294 /* Fall through ... */
2295
2296 case PA_SINK_MESSAGE_SET_VOLUME:
2297
2298 if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2299 s->thread_info.soft_volume = s->soft_volume;
2300 pa_sink_request_rewind(s, (size_t) -1);
2301 }
2302
2303 /* Fall through ... */
2304
2305 case PA_SINK_MESSAGE_SYNC_VOLUMES:
2306 sync_input_volumes_within_thread(s);
2307 return 0;
2308
2309 case PA_SINK_MESSAGE_GET_VOLUME:
2310
2311 if ((s->flags & PA_SINK_SYNC_VOLUME) && s->get_volume) {
2312 s->get_volume(s);
2313 pa_sink_volume_change_flush(s);
2314 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2315 }
2316
2317 /* In case sink implementor reset SW volume. */
2318 if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2319 s->thread_info.soft_volume = s->soft_volume;
2320 pa_sink_request_rewind(s, (size_t) -1);
2321 }
2322
2323 return 0;
2324
2325 case PA_SINK_MESSAGE_SET_MUTE:
2326
2327 if (s->thread_info.soft_muted != s->muted) {
2328 s->thread_info.soft_muted = s->muted;
2329 pa_sink_request_rewind(s, (size_t) -1);
2330 }
2331
2332 if (s->flags & PA_SINK_SYNC_VOLUME && s->set_mute)
2333 s->set_mute(s);
2334
2335 return 0;
2336
2337 case PA_SINK_MESSAGE_GET_MUTE:
2338
2339 if (s->flags & PA_SINK_SYNC_VOLUME && s->get_mute)
2340 s->get_mute(s);
2341
2342 return 0;
2343
2344 case PA_SINK_MESSAGE_SET_STATE: {
2345
2346 pa_bool_t suspend_change =
2347 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
2348 (PA_SINK_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SINK_SUSPENDED);
2349
2350 s->thread_info.state = PA_PTR_TO_UINT(userdata);
2351
2352 if (s->thread_info.state == PA_SINK_SUSPENDED) {
2353 s->thread_info.rewind_nbytes = 0;
2354 s->thread_info.rewind_requested = FALSE;
2355 }
2356
2357 if (suspend_change) {
2358 pa_sink_input *i;
2359 void *state = NULL;
2360
2361 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
2362 if (i->suspend_within_thread)
2363 i->suspend_within_thread(i, s->thread_info.state == PA_SINK_SUSPENDED);
2364 }
2365
2366 return 0;
2367 }
2368
2369 case PA_SINK_MESSAGE_DETACH:
2370
2371 /* Detach all streams */
2372 pa_sink_detach_within_thread(s);
2373 return 0;
2374
2375 case PA_SINK_MESSAGE_ATTACH:
2376
2377 /* Reattach all streams */
2378 pa_sink_attach_within_thread(s);
2379 return 0;
2380
2381 case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY: {
2382
2383 pa_usec_t *usec = userdata;
2384 *usec = pa_sink_get_requested_latency_within_thread(s);
2385
2386 /* Yes, that's right, the IO thread will see -1 when no
2387 * explicit requested latency is configured, the main
2388 * thread will see max_latency */
2389 if (*usec == (pa_usec_t) -1)
2390 *usec = s->thread_info.max_latency;
2391
2392 return 0;
2393 }
2394
2395 case PA_SINK_MESSAGE_SET_LATENCY_RANGE: {
2396 pa_usec_t *r = userdata;
2397
2398 pa_sink_set_latency_range_within_thread(s, r[0], r[1]);
2399
2400 return 0;
2401 }
2402
2403 case PA_SINK_MESSAGE_GET_LATENCY_RANGE: {
2404 pa_usec_t *r = userdata;
2405
2406 r[0] = s->thread_info.min_latency;
2407 r[1] = s->thread_info.max_latency;
2408
2409 return 0;
2410 }
2411
2412 case PA_SINK_MESSAGE_GET_FIXED_LATENCY:
2413
2414 *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2415 return 0;
2416
2417 case PA_SINK_MESSAGE_SET_FIXED_LATENCY:
2418
2419 pa_sink_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2420 return 0;
2421
2422 case PA_SINK_MESSAGE_GET_MAX_REWIND:
2423
2424 *((size_t*) userdata) = s->thread_info.max_rewind;
2425 return 0;
2426
2427 case PA_SINK_MESSAGE_GET_MAX_REQUEST:
2428
2429 *((size_t*) userdata) = s->thread_info.max_request;
2430 return 0;
2431
2432 case PA_SINK_MESSAGE_SET_MAX_REWIND:
2433
2434 pa_sink_set_max_rewind_within_thread(s, (size_t) offset);
2435 return 0;
2436
2437 case PA_SINK_MESSAGE_SET_MAX_REQUEST:
2438
2439 pa_sink_set_max_request_within_thread(s, (size_t) offset);
2440 return 0;
2441
2442 case PA_SINK_MESSAGE_SET_PORT:
2443
2444 pa_assert(userdata);
2445 if (s->set_port) {
2446 struct sink_message_set_port *msg_data = userdata;
2447 msg_data->ret = s->set_port(s, msg_data->port);
2448 }
2449 return 0;
2450
2451 case PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2452 /* This message is sent from IO-thread and handled in main thread. */
2453 pa_assert_ctl_context();
2454
2455 pa_sink_get_volume(s, TRUE);
2456 pa_sink_get_mute(s, TRUE);
2457 return 0;
2458
2459 case PA_SINK_MESSAGE_GET_LATENCY:
2460 case PA_SINK_MESSAGE_MAX:
2461 ;
2462 }
2463
2464 return -1;
2465 }
2466
2467 /* Called from main thread */
2468 int pa_sink_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause) {
2469 pa_sink *sink;
2470 uint32_t idx;
2471 int ret = 0;
2472
2473 pa_core_assert_ref(c);
2474 pa_assert_ctl_context();
2475 pa_assert(cause != 0);
2476
2477 PA_IDXSET_FOREACH(sink, c->sinks, idx) {
2478 int r;
2479
2480 if ((r = pa_sink_suspend(sink, suspend, cause)) < 0)
2481 ret = r;
2482 }
2483
2484 return ret;
2485 }
2486
2487 /* Called from main thread */
2488 void pa_sink_detach(pa_sink *s) {
2489 pa_sink_assert_ref(s);
2490 pa_assert_ctl_context();
2491 pa_assert(PA_SINK_IS_LINKED(s->state));
2492
2493 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_DETACH, NULL, 0, NULL) == 0);
2494 }
2495
2496 /* Called from main thread */
2497 void pa_sink_attach(pa_sink *s) {
2498 pa_sink_assert_ref(s);
2499 pa_assert_ctl_context();
2500 pa_assert(PA_SINK_IS_LINKED(s->state));
2501
2502 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_ATTACH, NULL, 0, NULL) == 0);
2503 }
2504
2505 /* Called from IO thread */
2506 void pa_sink_detach_within_thread(pa_sink *s) {
2507 pa_sink_input *i;
2508 void *state = NULL;
2509
2510 pa_sink_assert_ref(s);
2511 pa_sink_assert_io_context(s);
2512 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2513
2514 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2515 if (i->detach)
2516 i->detach(i);
2517
2518 if (s->monitor_source)
2519 pa_source_detach_within_thread(s->monitor_source);
2520 }
2521
2522 /* Called from IO thread */
2523 void pa_sink_attach_within_thread(pa_sink *s) {
2524 pa_sink_input *i;
2525 void *state = NULL;
2526
2527 pa_sink_assert_ref(s);
2528 pa_sink_assert_io_context(s);
2529 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2530
2531 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2532 if (i->attach)
2533 i->attach(i);
2534
2535 if (s->monitor_source)
2536 pa_source_attach_within_thread(s->monitor_source);
2537 }
2538
2539 /* Called from IO thread */
2540 void pa_sink_request_rewind(pa_sink*s, size_t nbytes) {
2541 pa_sink_assert_ref(s);
2542 pa_sink_assert_io_context(s);
2543 pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2544
2545 if (s->thread_info.state == PA_SINK_SUSPENDED)
2546 return;
2547
2548 if (nbytes == (size_t) -1)
2549 nbytes = s->thread_info.max_rewind;
2550
2551 nbytes = PA_MIN(nbytes, s->thread_info.max_rewind);
2552
2553 if (s->thread_info.rewind_requested &&
2554 nbytes <= s->thread_info.rewind_nbytes)
2555 return;
2556
2557 s->thread_info.rewind_nbytes = nbytes;
2558 s->thread_info.rewind_requested = TRUE;
2559
2560 if (s->request_rewind)
2561 s->request_rewind(s);
2562 }
2563
2564 /* Called from IO thread */
2565 pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s) {
2566 pa_usec_t result = (pa_usec_t) -1;
2567 pa_sink_input *i;
2568 void *state = NULL;
2569 pa_usec_t monitor_latency;
2570
2571 pa_sink_assert_ref(s);
2572 pa_sink_assert_io_context(s);
2573
2574 if (!(s->flags & PA_SINK_DYNAMIC_LATENCY))
2575 return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
2576
2577 if (s->thread_info.requested_latency_valid)
2578 return s->thread_info.requested_latency;
2579
2580 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2581 if (i->thread_info.requested_sink_latency != (pa_usec_t) -1 &&
2582 (result == (pa_usec_t) -1 || result > i->thread_info.requested_sink_latency))
2583 result = i->thread_info.requested_sink_latency;
2584
2585 monitor_latency = pa_source_get_requested_latency_within_thread(s->monitor_source);
2586
2587 if (monitor_latency != (pa_usec_t) -1 &&
2588 (result == (pa_usec_t) -1 || result > monitor_latency))
2589 result = monitor_latency;
2590
2591 if (result != (pa_usec_t) -1)
2592 result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
2593
2594 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2595 /* Only cache if properly initialized */
2596 s->thread_info.requested_latency = result;
2597 s->thread_info.requested_latency_valid = TRUE;
2598 }
2599
2600 return result;
2601 }
2602
2603 /* Called from main thread */
2604 pa_usec_t pa_sink_get_requested_latency(pa_sink *s) {
2605 pa_usec_t usec = 0;
2606
2607 pa_sink_assert_ref(s);
2608 pa_assert_ctl_context();
2609 pa_assert(PA_SINK_IS_LINKED(s->state));
2610
2611 if (s->state == PA_SINK_SUSPENDED)
2612 return 0;
2613
2614 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
2615 return usec;
2616 }
2617
2618 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2619 void pa_sink_set_max_rewind_within_thread(pa_sink *s, size_t max_rewind) {
2620 pa_sink_input *i;
2621 void *state = NULL;
2622
2623 pa_sink_assert_ref(s);
2624 pa_sink_assert_io_context(s);
2625
2626 if (max_rewind == s->thread_info.max_rewind)
2627 return;
2628
2629 s->thread_info.max_rewind = max_rewind;
2630
2631 if (PA_SINK_IS_LINKED(s->thread_info.state))
2632 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2633 pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2634
2635 if (s->monitor_source)
2636 pa_source_set_max_rewind_within_thread(s->monitor_source, s->thread_info.max_rewind);
2637 }
2638
2639 /* Called from main thread */
2640 void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind) {
2641 pa_sink_assert_ref(s);
2642 pa_assert_ctl_context();
2643
2644 if (PA_SINK_IS_LINKED(s->state))
2645 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
2646 else
2647 pa_sink_set_max_rewind_within_thread(s, max_rewind);
2648 }
2649
2650 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2651 void pa_sink_set_max_request_within_thread(pa_sink *s, size_t max_request) {
2652 void *state = NULL;
2653
2654 pa_sink_assert_ref(s);
2655 pa_sink_assert_io_context(s);
2656
2657 if (max_request == s->thread_info.max_request)
2658 return;
2659
2660 s->thread_info.max_request = max_request;
2661
2662 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2663 pa_sink_input *i;
2664
2665 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2666 pa_sink_input_update_max_request(i, s->thread_info.max_request);
2667 }
2668 }
2669
2670 /* Called from main thread */
2671 void pa_sink_set_max_request(pa_sink *s, size_t max_request) {
2672 pa_sink_assert_ref(s);
2673 pa_assert_ctl_context();
2674
2675 if (PA_SINK_IS_LINKED(s->state))
2676 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REQUEST, NULL, max_request, NULL) == 0);
2677 else
2678 pa_sink_set_max_request_within_thread(s, max_request);
2679 }
2680
2681 /* Called from IO thread */
2682 void pa_sink_invalidate_requested_latency(pa_sink *s, pa_bool_t dynamic) {
2683 pa_sink_input *i;
2684 void *state = NULL;
2685
2686 pa_sink_assert_ref(s);
2687 pa_sink_assert_io_context(s);
2688
2689 if ((s->flags & PA_SINK_DYNAMIC_LATENCY))
2690 s->thread_info.requested_latency_valid = FALSE;
2691 else if (dynamic)
2692 return;
2693
2694 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2695
2696 if (s->update_requested_latency)
2697 s->update_requested_latency(s);
2698
2699 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2700 if (i->update_sink_requested_latency)
2701 i->update_sink_requested_latency(i);
2702 }
2703 }
2704
2705 /* Called from main thread */
2706 void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2707 pa_sink_assert_ref(s);
2708 pa_assert_ctl_context();
2709
2710 /* min_latency == 0: no limit
2711 * min_latency anything else: specified limit
2712 *
2713 * Similar for max_latency */
2714
2715 if (min_latency < ABSOLUTE_MIN_LATENCY)
2716 min_latency = ABSOLUTE_MIN_LATENCY;
2717
2718 if (max_latency <= 0 ||
2719 max_latency > ABSOLUTE_MAX_LATENCY)
2720 max_latency = ABSOLUTE_MAX_LATENCY;
2721
2722 pa_assert(min_latency <= max_latency);
2723
2724 /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2725 pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2726 max_latency == ABSOLUTE_MAX_LATENCY) ||
2727 (s->flags & PA_SINK_DYNAMIC_LATENCY));
2728
2729 if (PA_SINK_IS_LINKED(s->state)) {
2730 pa_usec_t r[2];
2731
2732 r[0] = min_latency;
2733 r[1] = max_latency;
2734
2735 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
2736 } else
2737 pa_sink_set_latency_range_within_thread(s, min_latency, max_latency);
2738 }
2739
2740 /* Called from main thread */
2741 void pa_sink_get_latency_range(pa_sink *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
2742 pa_sink_assert_ref(s);
2743 pa_assert_ctl_context();
2744 pa_assert(min_latency);
2745 pa_assert(max_latency);
2746
2747 if (PA_SINK_IS_LINKED(s->state)) {
2748 pa_usec_t r[2] = { 0, 0 };
2749
2750 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
2751
2752 *min_latency = r[0];
2753 *max_latency = r[1];
2754 } else {
2755 *min_latency = s->thread_info.min_latency;
2756 *max_latency = s->thread_info.max_latency;
2757 }
2758 }
2759
2760 /* Called from IO thread */
2761 void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2762 pa_sink_assert_ref(s);
2763 pa_sink_assert_io_context(s);
2764
2765 pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
2766 pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
2767 pa_assert(min_latency <= max_latency);
2768
2769 /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2770 pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2771 max_latency == ABSOLUTE_MAX_LATENCY) ||
2772 (s->flags & PA_SINK_DYNAMIC_LATENCY));
2773
2774 if (s->thread_info.min_latency == min_latency &&
2775 s->thread_info.max_latency == max_latency)
2776 return;
2777
2778 s->thread_info.min_latency = min_latency;
2779 s->thread_info.max_latency = max_latency;
2780
2781 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2782 pa_sink_input *i;
2783 void *state = NULL;
2784
2785 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2786 if (i->update_sink_latency_range)
2787 i->update_sink_latency_range(i);
2788 }
2789
2790 pa_sink_invalidate_requested_latency(s, FALSE);
2791
2792 pa_source_set_latency_range_within_thread(s->monitor_source, min_latency, max_latency);
2793 }
2794
2795 /* Called from main thread */
2796 void pa_sink_set_fixed_latency(pa_sink *s, pa_usec_t latency) {
2797 pa_sink_assert_ref(s);
2798 pa_assert_ctl_context();
2799
2800 if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
2801 pa_assert(latency == 0);
2802 return;
2803 }
2804
2805 if (latency < ABSOLUTE_MIN_LATENCY)
2806 latency = ABSOLUTE_MIN_LATENCY;
2807
2808 if (latency > ABSOLUTE_MAX_LATENCY)
2809 latency = ABSOLUTE_MAX_LATENCY;
2810
2811 if (PA_SINK_IS_LINKED(s->state))
2812 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
2813 else
2814 s->thread_info.fixed_latency = latency;
2815
2816 pa_source_set_fixed_latency(s->monitor_source, latency);
2817 }
2818
2819 /* Called from main thread */
2820 pa_usec_t pa_sink_get_fixed_latency(pa_sink *s) {
2821 pa_usec_t latency;
2822
2823 pa_sink_assert_ref(s);
2824 pa_assert_ctl_context();
2825
2826 if (s->flags & PA_SINK_DYNAMIC_LATENCY)
2827 return 0;
2828
2829 if (PA_SINK_IS_LINKED(s->state))
2830 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
2831 else
2832 latency = s->thread_info.fixed_latency;
2833
2834 return latency;
2835 }
2836
2837 /* Called from IO thread */
2838 void pa_sink_set_fixed_latency_within_thread(pa_sink *s, pa_usec_t latency) {
2839 pa_sink_assert_ref(s);
2840 pa_sink_assert_io_context(s);
2841
2842 if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
2843 pa_assert(latency == 0);
2844 return;
2845 }
2846
2847 pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
2848 pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
2849
2850 if (s->thread_info.fixed_latency == latency)
2851 return;
2852
2853 s->thread_info.fixed_latency = latency;
2854
2855 if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2856 pa_sink_input *i;
2857 void *state = NULL;
2858
2859 PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2860 if (i->update_sink_fixed_latency)
2861 i->update_sink_fixed_latency(i);
2862 }
2863
2864 pa_sink_invalidate_requested_latency(s, FALSE);
2865
2866 pa_source_set_fixed_latency_within_thread(s->monitor_source, latency);
2867 }
2868
2869 /* Called from main context */
2870 size_t pa_sink_get_max_rewind(pa_sink *s) {
2871 size_t r;
2872 pa_sink_assert_ref(s);
2873 pa_assert_ctl_context();
2874
2875 if (!PA_SINK_IS_LINKED(s->state))
2876 return s->thread_info.max_rewind;
2877
2878 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
2879
2880 return r;
2881 }
2882
2883 /* Called from main context */
2884 size_t pa_sink_get_max_request(pa_sink *s) {
2885 size_t r;
2886 pa_sink_assert_ref(s);
2887 pa_assert_ctl_context();
2888
2889 if (!PA_SINK_IS_LINKED(s->state))
2890 return s->thread_info.max_request;
2891
2892 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REQUEST, &r, 0, NULL) == 0);
2893
2894 return r;
2895 }
2896
2897 /* Called from main context */
2898 int pa_sink_set_port(pa_sink *s, const char *name, pa_bool_t save) {
2899 pa_device_port *port;
2900 int ret;
2901 pa_sink_assert_ref(s);
2902 pa_assert_ctl_context();
2903
2904 if (!s->set_port) {
2905 pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name);
2906 return -PA_ERR_NOTIMPLEMENTED;
2907 }
2908
2909 if (!s->ports)
2910 return -PA_ERR_NOENTITY;
2911
2912 if (!(port = pa_hashmap_get(s->ports, name)))
2913 return -PA_ERR_NOENTITY;
2914
2915 if (s->active_port == port) {
2916 s->save_port = s->save_port || save;
2917 return 0;
2918 }
2919
2920 if (s->flags & PA_SINK_SYNC_VOLUME) {
2921 struct sink_message_set_port msg = { .port = port, .ret = 0 };
2922 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
2923 ret = msg.ret;
2924 }
2925 else
2926 ret = s->set_port(s, port);
2927
2928 if (ret < 0)
2929 return -PA_ERR_NOENTITY;
2930
2931 pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2932
2933 pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name);
2934
2935 s->active_port = port;
2936 s->save_port = save;
2937
2938 pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_CHANGED], s);
2939
2940 return 0;
2941 }
2942
2943 pa_bool_t pa_device_init_icon(pa_proplist *p, pa_bool_t is_sink) {
2944 const char *ff, *c, *t = NULL, *s = "", *profile, *bus;
2945
2946 pa_assert(p);
2947
2948 if (pa_proplist_contains(p, PA_PROP_DEVICE_ICON_NAME))
2949 return TRUE;
2950
2951 if ((ff = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
2952
2953 if (pa_streq(ff, "microphone"))
2954 t = "audio-input-microphone";
2955 else if (pa_streq(ff, "webcam"))
2956 t = "camera-web";
2957 else if (pa_streq(ff, "computer"))
2958 t = "computer";
2959 else if (pa_streq(ff, "handset"))
2960 t = "phone";
2961 else if (pa_streq(ff, "portable"))
2962 t = "multimedia-player";
2963 else if (pa_streq(ff, "tv"))
2964 t = "video-display";
2965
2966 /*
2967 * The following icons are not part of the icon naming spec,
2968 * because Rodney Dawes sucks as the maintainer of that spec.
2969 *
2970 * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
2971 */
2972 else if (pa_streq(ff, "headset"))
2973 t = "audio-headset";
2974 else if (pa_streq(ff, "headphone"))
2975 t = "audio-headphones";
2976 else if (pa_streq(ff, "speaker"))
2977 t = "audio-speakers";
2978 else if (pa_streq(ff, "hands-free"))
2979 t = "audio-handsfree";
2980 }
2981
2982 if (!t)
2983 if ((c = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
2984 if (pa_streq(c, "modem"))
2985 t = "modem";
2986
2987 if (!t) {
2988 if (is_sink)
2989 t = "audio-card";
2990 else
2991 t = "audio-input-microphone";
2992 }
2993
2994 if ((profile = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
2995 if (strstr(profile, "analog"))
2996 s = "-analog";
2997 else if (strstr(profile, "iec958"))
2998 s = "-iec958";
2999 else if (strstr(profile, "hdmi"))
3000 s = "-hdmi";
3001 }
3002
3003 bus = pa_proplist_gets(p, PA_PROP_DEVICE_BUS);
3004
3005 pa_proplist_setf(p, PA_PROP_DEVICE_ICON_NAME, "%s%s%s%s", t, pa_strempty(s), bus ? "-" : "", pa_strempty(bus));
3006
3007 return TRUE;
3008 }
3009
3010 pa_bool_t pa_device_init_description(pa_proplist *p) {
3011 const char *s, *d = NULL, *k;
3012 pa_assert(p);
3013
3014 if (pa_proplist_contains(p, PA_PROP_DEVICE_DESCRIPTION))
3015 return TRUE;
3016
3017 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3018 if (pa_streq(s, "internal"))
3019 d = _("Internal Audio");
3020
3021 if (!d)
3022 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3023 if (pa_streq(s, "modem"))
3024 d = _("Modem");
3025
3026 if (!d)
3027 d = pa_proplist_gets(p, PA_PROP_DEVICE_PRODUCT_NAME);
3028
3029 if (!d)
3030 return FALSE;
3031
3032 k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
3033
3034 if (d && k)
3035 pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, _("%s %s"), d, k);
3036 else if (d)
3037 pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
3038
3039 return TRUE;
3040 }
3041
3042 pa_bool_t pa_device_init_intended_roles(pa_proplist *p) {
3043 const char *s;
3044 pa_assert(p);
3045
3046 if (pa_proplist_contains(p, PA_PROP_DEVICE_INTENDED_ROLES))
3047 return TRUE;
3048
3049 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3050 if (pa_streq(s, "handset") || pa_streq(s, "hands-free")
3051 || pa_streq(s, "headset")) {
3052 pa_proplist_sets(p, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
3053 return TRUE;
3054 }
3055
3056 return FALSE;
3057 }
3058
3059 unsigned pa_device_init_priority(pa_proplist *p) {
3060 const char *s;
3061 unsigned priority = 0;
3062
3063 pa_assert(p);
3064
3065 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS))) {
3066
3067 if (pa_streq(s, "sound"))
3068 priority += 9000;
3069 else if (!pa_streq(s, "modem"))
3070 priority += 1000;
3071 }
3072
3073 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3074
3075 if (pa_streq(s, "internal"))
3076 priority += 900;
3077 else if (pa_streq(s, "speaker"))
3078 priority += 500;
3079 else if (pa_streq(s, "headphone"))
3080 priority += 400;
3081 }
3082
3083 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_BUS))) {
3084
3085 if (pa_streq(s, "pci"))
3086 priority += 50;
3087 else if (pa_streq(s, "usb"))
3088 priority += 40;
3089 else if (pa_streq(s, "bluetooth"))
3090 priority += 30;
3091 }
3092
3093 if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3094
3095 if (pa_startswith(s, "analog-"))
3096 priority += 9;
3097 else if (pa_startswith(s, "iec958-"))
3098 priority += 8;
3099 }
3100
3101 return priority;
3102 }
3103
3104 PA_STATIC_FLIST_DECLARE(pa_sink_volume_change, 0, pa_xfree);
3105
3106 /* Called from the IO thread. */
3107 static pa_sink_volume_change *pa_sink_volume_change_new(pa_sink *s) {
3108 pa_sink_volume_change *c;
3109 if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_sink_volume_change))))
3110 c = pa_xnew(pa_sink_volume_change, 1);
3111
3112 PA_LLIST_INIT(pa_sink_volume_change, c);
3113 c->at = 0;
3114 pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
3115 return c;
3116 }
3117
3118 /* Called from the IO thread. */
3119 static void pa_sink_volume_change_free(pa_sink_volume_change *c) {
3120 pa_assert(c);
3121 if (pa_flist_push(PA_STATIC_FLIST_GET(pa_sink_volume_change), c) < 0)
3122 pa_xfree(c);
3123 }
3124
3125 /* Called from the IO thread. */
3126 void pa_sink_volume_change_push(pa_sink *s) {
3127 pa_sink_volume_change *c = NULL;
3128 pa_sink_volume_change *nc = NULL;
3129 uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
3130
3131 const char *direction = NULL;
3132
3133 pa_assert(s);
3134 nc = pa_sink_volume_change_new(s);
3135
3136 /* NOTE: There is already more different volumes in pa_sink that I can remember.
3137 * Adding one more volume for HW would get us rid of this, but I am trying
3138 * to survive with the ones we already have. */
3139 pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
3140
3141 if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
3142 pa_log_debug("Volume not changing");
3143 pa_sink_volume_change_free(nc);
3144 return;
3145 }
3146
3147 nc->at = pa_sink_get_latency_within_thread(s);
3148 nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3149
3150 if (s->thread_info.volume_changes_tail) {
3151 for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
3152 /* If volume is going up let's do it a bit late. If it is going
3153 * down let's do it a bit early. */
3154 if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
3155 if (nc->at + safety_margin > c->at) {
3156 nc->at += safety_margin;
3157 direction = "up";
3158 break;
3159 }
3160 }
3161 else if (nc->at - safety_margin > c->at) {
3162 nc->at -= safety_margin;
3163 direction = "down";
3164 break;
3165 }
3166 }
3167 }
3168
3169 if (c == NULL) {
3170 if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
3171 nc->at += safety_margin;
3172 direction = "up";
3173 } else {
3174 nc->at -= safety_margin;
3175 direction = "down";
3176 }
3177 PA_LLIST_PREPEND(pa_sink_volume_change, s->thread_info.volume_changes, nc);
3178 }
3179 else {
3180 PA_LLIST_INSERT_AFTER(pa_sink_volume_change, s->thread_info.volume_changes, c, nc);
3181 }
3182
3183 pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), nc->at);
3184
3185 /* We can ignore volume events that came earlier but should happen later than this. */
3186 PA_LLIST_FOREACH(c, nc->next) {
3187 pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), c->at);
3188 pa_sink_volume_change_free(c);
3189 }
3190 nc->next = NULL;
3191 s->thread_info.volume_changes_tail = nc;
3192 }
3193
3194 /* Called from the IO thread. */
3195 static void pa_sink_volume_change_flush(pa_sink *s) {
3196 pa_sink_volume_change *c = s->thread_info.volume_changes;
3197 pa_assert(s);
3198 s->thread_info.volume_changes = NULL;
3199 s->thread_info.volume_changes_tail = NULL;
3200 while (c) {
3201 pa_sink_volume_change *next = c->next;
3202 pa_sink_volume_change_free(c);
3203 c = next;
3204 }
3205 }
3206
3207 /* Called from the IO thread. */
3208 pa_bool_t pa_sink_volume_change_apply(pa_sink *s, pa_usec_t *usec_to_next) {
3209 pa_usec_t now = pa_rtclock_now();
3210 pa_bool_t ret = FALSE;
3211
3212 pa_assert(s);
3213 pa_assert(s->write_volume);
3214
3215 while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
3216 pa_sink_volume_change *c = s->thread_info.volume_changes;
3217 PA_LLIST_REMOVE(pa_sink_volume_change, s->thread_info.volume_changes, c);
3218 pa_log_debug("Volume change to %d at %llu was written %llu usec late", pa_cvolume_avg(&c->hw_volume), c->at, now - c->at);
3219 ret = TRUE;
3220 s->thread_info.current_hw_volume = c->hw_volume;
3221 pa_sink_volume_change_free(c);
3222 }
3223
3224 if (s->write_volume && ret)
3225 s->write_volume(s);
3226
3227 if (s->thread_info.volume_changes) {
3228 if (usec_to_next)
3229 *usec_to_next = s->thread_info.volume_changes->at - now;
3230 if (pa_log_ratelimit(PA_LOG_DEBUG))
3231 pa_log_debug("Next volume change in %lld usec", s->thread_info.volume_changes->at - now);
3232 }
3233 else {
3234 if (usec_to_next)
3235 *usec_to_next = 0;
3236 s->thread_info.volume_changes_tail = NULL;
3237 }
3238 return ret;
3239 }
3240
3241 /* Called from the IO thread. */
3242 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes) {
3243 /* All the queued volume events later than current latency are shifted to happen earlier. */
3244 pa_sink_volume_change *c;
3245 pa_volume_t prev_vol = pa_cvolume_avg(&s->thread_info.current_hw_volume);
3246 pa_usec_t rewound = pa_bytes_to_usec(nbytes, &s->sample_spec);
3247 pa_usec_t limit = pa_sink_get_latency_within_thread(s);
3248
3249 pa_log_debug("latency = %lld", limit);
3250 limit += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3251
3252 PA_LLIST_FOREACH(c, s->thread_info.volume_changes) {
3253 pa_usec_t modified_limit = limit;
3254 if (prev_vol > pa_cvolume_avg(&c->hw_volume))
3255 modified_limit -= s->thread_info.volume_change_safety_margin;
3256 else
3257 modified_limit += s->thread_info.volume_change_safety_margin;
3258 if (c->at > modified_limit) {
3259 c->at -= rewound;
3260 if (c->at < modified_limit)
3261 c->at = modified_limit;
3262 }
3263 prev_vol = pa_cvolume_avg(&c->hw_volume);
3264 }
3265 pa_sink_volume_change_apply(s, NULL);
3266 }
ALAC Integration into pulseaudio RAOP module