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