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