]> code.delx.au - pulseaudio/blob - src/modules/alsa/alsa-mixer.c
delx.au / code / pulseaudio / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
alsa: rework mixer logic
[pulseaudio] / src / modules / alsa / alsa-mixer.c
1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2004-2009 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 <sys/types.h>
28 #include <limits.h>
29 #include <asoundlib.h>
30
31 #ifdef HAVE_VALGRIND_MEMCHECK_H
32 #include <valgrind/memcheck.h>
33 #endif
34
35 #include <pulse/sample.h>
36 #include <pulse/xmalloc.h>
37 #include <pulse/timeval.h>
38 #include <pulse/util.h>
39 #include <pulse/i18n.h>
40 #include <pulse/utf8.h>
41
42 #include <pulsecore/log.h>
43 #include <pulsecore/macro.h>
44 #include <pulsecore/core-util.h>
45 #include <pulsecore/atomic.h>
46 #include <pulsecore/core-error.h>
47 #include <pulsecore/once.h>
48 #include <pulsecore/thread.h>
49 #include <pulsecore/conf-parser.h>
50 #include <pulsecore/strbuf.h>
51
52 #include "alsa-mixer.h"
53 #include "alsa-util.h"
54
55 struct description_map {
56 const char *name;
57 const char *description;
58 };
59
60 static const char *lookup_description(const char *name, const struct description_map dm[], unsigned n) {
61 unsigned i;
62
63 for (i = 0; i < n; i++)
64 if (pa_streq(dm[i].name, name))
65 return dm[i].description;
66
67 return NULL;
68 }
69
70 struct pa_alsa_fdlist {
71 unsigned num_fds;
72 struct pollfd *fds;
73 /* This is a temporary buffer used to avoid lots of mallocs */
74 struct pollfd *work_fds;
75
76 snd_mixer_t *mixer;
77
78 pa_mainloop_api *m;
79 pa_defer_event *defer;
80 pa_io_event **ios;
81
82 pa_bool_t polled;
83
84 void (*cb)(void *userdata);
85 void *userdata;
86 };
87
88 static void io_cb(pa_mainloop_api*a, pa_io_event* e, int fd, pa_io_event_flags_t events, void *userdata) {
89
90 struct pa_alsa_fdlist *fdl = userdata;
91 int err;
92 unsigned i;
93 unsigned short revents;
94
95 pa_assert(a);
96 pa_assert(fdl);
97 pa_assert(fdl->mixer);
98 pa_assert(fdl->fds);
99 pa_assert(fdl->work_fds);
100
101 if (fdl->polled)
102 return;
103
104 fdl->polled = TRUE;
105
106 memcpy(fdl->work_fds, fdl->fds, sizeof(struct pollfd) * fdl->num_fds);
107
108 for (i = 0; i < fdl->num_fds; i++) {
109 if (e == fdl->ios[i]) {
110 if (events & PA_IO_EVENT_INPUT)
111 fdl->work_fds[i].revents |= POLLIN;
112 if (events & PA_IO_EVENT_OUTPUT)
113 fdl->work_fds[i].revents |= POLLOUT;
114 if (events & PA_IO_EVENT_ERROR)
115 fdl->work_fds[i].revents |= POLLERR;
116 if (events & PA_IO_EVENT_HANGUP)
117 fdl->work_fds[i].revents |= POLLHUP;
118 break;
119 }
120 }
121
122 pa_assert(i != fdl->num_fds);
123
124 if ((err = snd_mixer_poll_descriptors_revents(fdl->mixer, fdl->work_fds, fdl->num_fds, &revents)) < 0) {
125 pa_log_error("Unable to get poll revent: %s", pa_alsa_strerror(err));
126 return;
127 }
128
129 a->defer_enable(fdl->defer, 1);
130
131 if (revents)
132 snd_mixer_handle_events(fdl->mixer);
133 }
134
135 static void defer_cb(pa_mainloop_api*a, pa_defer_event* e, void *userdata) {
136 struct pa_alsa_fdlist *fdl = userdata;
137 unsigned num_fds, i;
138 int err, n;
139 struct pollfd *temp;
140
141 pa_assert(a);
142 pa_assert(fdl);
143 pa_assert(fdl->mixer);
144
145 a->defer_enable(fdl->defer, 0);
146
147 if ((n = snd_mixer_poll_descriptors_count(fdl->mixer)) < 0) {
148 pa_log("snd_mixer_poll_descriptors_count() failed: %s", pa_alsa_strerror(n));
149 return;
150 }
151 num_fds = (unsigned) n;
152
153 if (num_fds != fdl->num_fds) {
154 if (fdl->fds)
155 pa_xfree(fdl->fds);
156 if (fdl->work_fds)
157 pa_xfree(fdl->work_fds);
158 fdl->fds = pa_xnew0(struct pollfd, num_fds);
159 fdl->work_fds = pa_xnew(struct pollfd, num_fds);
160 }
161
162 memset(fdl->work_fds, 0, sizeof(struct pollfd) * num_fds);
163
164 if ((err = snd_mixer_poll_descriptors(fdl->mixer, fdl->work_fds, num_fds)) < 0) {
165 pa_log_error("Unable to get poll descriptors: %s", pa_alsa_strerror(err));
166 return;
167 }
168
169 fdl->polled = FALSE;
170
171 if (memcmp(fdl->fds, fdl->work_fds, sizeof(struct pollfd) * num_fds) == 0)
172 return;
173
174 if (fdl->ios) {
175 for (i = 0; i < fdl->num_fds; i++)
176 a->io_free(fdl->ios[i]);
177
178 if (num_fds != fdl->num_fds) {
179 pa_xfree(fdl->ios);
180 fdl->ios = NULL;
181 }
182 }
183
184 if (!fdl->ios)
185 fdl->ios = pa_xnew(pa_io_event*, num_fds);
186
187 /* Swap pointers */
188 temp = fdl->work_fds;
189 fdl->work_fds = fdl->fds;
190 fdl->fds = temp;
191
192 fdl->num_fds = num_fds;
193
194 for (i = 0;i < num_fds;i++)
195 fdl->ios[i] = a->io_new(a, fdl->fds[i].fd,
196 ((fdl->fds[i].events & POLLIN) ? PA_IO_EVENT_INPUT : 0) |
197 ((fdl->fds[i].events & POLLOUT) ? PA_IO_EVENT_OUTPUT : 0),
198 io_cb, fdl);
199 }
200
201 struct pa_alsa_fdlist *pa_alsa_fdlist_new(void) {
202 struct pa_alsa_fdlist *fdl;
203
204 fdl = pa_xnew0(struct pa_alsa_fdlist, 1);
205
206 return fdl;
207 }
208
209 void pa_alsa_fdlist_free(struct pa_alsa_fdlist *fdl) {
210 pa_assert(fdl);
211
212 if (fdl->defer) {
213 pa_assert(fdl->m);
214 fdl->m->defer_free(fdl->defer);
215 }
216
217 if (fdl->ios) {
218 unsigned i;
219 pa_assert(fdl->m);
220 for (i = 0; i < fdl->num_fds; i++)
221 fdl->m->io_free(fdl->ios[i]);
222 pa_xfree(fdl->ios);
223 }
224
225 if (fdl->fds)
226 pa_xfree(fdl->fds);
227 if (fdl->work_fds)
228 pa_xfree(fdl->work_fds);
229
230 pa_xfree(fdl);
231 }
232
233 int pa_alsa_fdlist_set_mixer(struct pa_alsa_fdlist *fdl, snd_mixer_t *mixer_handle, pa_mainloop_api* m) {
234 pa_assert(fdl);
235 pa_assert(mixer_handle);
236 pa_assert(m);
237 pa_assert(!fdl->m);
238
239 fdl->mixer = mixer_handle;
240 fdl->m = m;
241 fdl->defer = m->defer_new(m, defer_cb, fdl);
242
243 return 0;
244 }
245
246 static int prepare_mixer(snd_mixer_t *mixer, const char *dev) {
247 int err;
248
249 pa_assert(mixer);
250 pa_assert(dev);
251
252 if ((err = snd_mixer_attach(mixer, dev)) < 0) {
253 pa_log_info("Unable to attach to mixer %s: %s", dev, pa_alsa_strerror(err));
254 return -1;
255 }
256
257 if ((err = snd_mixer_selem_register(mixer, NULL, NULL)) < 0) {
258 pa_log_warn("Unable to register mixer: %s", pa_alsa_strerror(err));
259 return -1;
260 }
261
262 if ((err = snd_mixer_load(mixer)) < 0) {
263 pa_log_warn("Unable to load mixer: %s", pa_alsa_strerror(err));
264 return -1;
265 }
266
267 pa_log_info("Successfully attached to mixer '%s'", dev);
268 return 0;
269 }
270
271 snd_mixer_t *pa_alsa_open_mixer_for_pcm(snd_pcm_t *pcm, char **ctl_device) {
272 int err;
273 snd_mixer_t *m;
274 const char *dev;
275 snd_pcm_info_t* info;
276 snd_pcm_info_alloca(&info);
277
278 pa_assert(pcm);
279
280 if ((err = snd_mixer_open(&m, 0)) < 0) {
281 pa_log("Error opening mixer: %s", pa_alsa_strerror(err));
282 return NULL;
283 }
284
285 /* First, try by name */
286 if ((dev = snd_pcm_name(pcm)))
287 if (prepare_mixer(m, dev) >= 0) {
288 if (ctl_device)
289 *ctl_device = pa_xstrdup(dev);
290
291 return m;
292 }
293
294 /* Then, try by card index */
295 if (snd_pcm_info(pcm, info) >= 0) {
296 char *md;
297 int card_idx;
298
299 if ((card_idx = snd_pcm_info_get_card(info)) >= 0) {
300
301 md = pa_sprintf_malloc("hw:%i", card_idx);
302
303 if (!dev || !pa_streq(dev, md))
304 if (prepare_mixer(m, md) >= 0) {
305
306 if (ctl_device)
307 *ctl_device = md;
308 else
309 pa_xfree(md);
310
311 return m;
312 }
313
314 pa_xfree(md);
315 }
316 }
317
318 snd_mixer_close(m);
319 return NULL;
320 }
321
322 static const snd_mixer_selem_channel_id_t alsa_channel_ids[PA_CHANNEL_POSITION_MAX] = {
323 [PA_CHANNEL_POSITION_MONO] = SND_MIXER_SCHN_MONO, /* The ALSA name is just an alias! */
324
325 [PA_CHANNEL_POSITION_FRONT_CENTER] = SND_MIXER_SCHN_FRONT_CENTER,
326 [PA_CHANNEL_POSITION_FRONT_LEFT] = SND_MIXER_SCHN_FRONT_LEFT,
327 [PA_CHANNEL_POSITION_FRONT_RIGHT] = SND_MIXER_SCHN_FRONT_RIGHT,
328
329 [PA_CHANNEL_POSITION_REAR_CENTER] = SND_MIXER_SCHN_REAR_CENTER,
330 [PA_CHANNEL_POSITION_REAR_LEFT] = SND_MIXER_SCHN_REAR_LEFT,
331 [PA_CHANNEL_POSITION_REAR_RIGHT] = SND_MIXER_SCHN_REAR_RIGHT,
332
333 [PA_CHANNEL_POSITION_LFE] = SND_MIXER_SCHN_WOOFER,
334
335 [PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER] = SND_MIXER_SCHN_UNKNOWN,
336 [PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER] = SND_MIXER_SCHN_UNKNOWN,
337
338 [PA_CHANNEL_POSITION_SIDE_LEFT] = SND_MIXER_SCHN_SIDE_LEFT,
339 [PA_CHANNEL_POSITION_SIDE_RIGHT] = SND_MIXER_SCHN_SIDE_RIGHT,
340
341 [PA_CHANNEL_POSITION_AUX0] = SND_MIXER_SCHN_UNKNOWN,
342 [PA_CHANNEL_POSITION_AUX1] = SND_MIXER_SCHN_UNKNOWN,
343 [PA_CHANNEL_POSITION_AUX2] = SND_MIXER_SCHN_UNKNOWN,
344 [PA_CHANNEL_POSITION_AUX3] = SND_MIXER_SCHN_UNKNOWN,
345 [PA_CHANNEL_POSITION_AUX4] = SND_MIXER_SCHN_UNKNOWN,
346 [PA_CHANNEL_POSITION_AUX5] = SND_MIXER_SCHN_UNKNOWN,
347 [PA_CHANNEL_POSITION_AUX6] = SND_MIXER_SCHN_UNKNOWN,
348 [PA_CHANNEL_POSITION_AUX7] = SND_MIXER_SCHN_UNKNOWN,
349 [PA_CHANNEL_POSITION_AUX8] = SND_MIXER_SCHN_UNKNOWN,
350 [PA_CHANNEL_POSITION_AUX9] = SND_MIXER_SCHN_UNKNOWN,
351 [PA_CHANNEL_POSITION_AUX10] = SND_MIXER_SCHN_UNKNOWN,
352 [PA_CHANNEL_POSITION_AUX11] = SND_MIXER_SCHN_UNKNOWN,
353 [PA_CHANNEL_POSITION_AUX12] = SND_MIXER_SCHN_UNKNOWN,
354 [PA_CHANNEL_POSITION_AUX13] = SND_MIXER_SCHN_UNKNOWN,
355 [PA_CHANNEL_POSITION_AUX14] = SND_MIXER_SCHN_UNKNOWN,
356 [PA_CHANNEL_POSITION_AUX15] = SND_MIXER_SCHN_UNKNOWN,
357 [PA_CHANNEL_POSITION_AUX16] = SND_MIXER_SCHN_UNKNOWN,
358 [PA_CHANNEL_POSITION_AUX17] = SND_MIXER_SCHN_UNKNOWN,
359 [PA_CHANNEL_POSITION_AUX18] = SND_MIXER_SCHN_UNKNOWN,
360 [PA_CHANNEL_POSITION_AUX19] = SND_MIXER_SCHN_UNKNOWN,
361 [PA_CHANNEL_POSITION_AUX20] = SND_MIXER_SCHN_UNKNOWN,
362 [PA_CHANNEL_POSITION_AUX21] = SND_MIXER_SCHN_UNKNOWN,
363 [PA_CHANNEL_POSITION_AUX22] = SND_MIXER_SCHN_UNKNOWN,
364 [PA_CHANNEL_POSITION_AUX23] = SND_MIXER_SCHN_UNKNOWN,
365 [PA_CHANNEL_POSITION_AUX24] = SND_MIXER_SCHN_UNKNOWN,
366 [PA_CHANNEL_POSITION_AUX25] = SND_MIXER_SCHN_UNKNOWN,
367 [PA_CHANNEL_POSITION_AUX26] = SND_MIXER_SCHN_UNKNOWN,
368 [PA_CHANNEL_POSITION_AUX27] = SND_MIXER_SCHN_UNKNOWN,
369 [PA_CHANNEL_POSITION_AUX28] = SND_MIXER_SCHN_UNKNOWN,
370 [PA_CHANNEL_POSITION_AUX29] = SND_MIXER_SCHN_UNKNOWN,
371 [PA_CHANNEL_POSITION_AUX30] = SND_MIXER_SCHN_UNKNOWN,
372 [PA_CHANNEL_POSITION_AUX31] = SND_MIXER_SCHN_UNKNOWN,
373
374 [PA_CHANNEL_POSITION_TOP_CENTER] = SND_MIXER_SCHN_UNKNOWN,
375
376 [PA_CHANNEL_POSITION_TOP_FRONT_CENTER] = SND_MIXER_SCHN_UNKNOWN,
377 [PA_CHANNEL_POSITION_TOP_FRONT_LEFT] = SND_MIXER_SCHN_UNKNOWN,
378 [PA_CHANNEL_POSITION_TOP_FRONT_RIGHT] = SND_MIXER_SCHN_UNKNOWN,
379
380 [PA_CHANNEL_POSITION_TOP_REAR_CENTER] = SND_MIXER_SCHN_UNKNOWN,
381 [PA_CHANNEL_POSITION_TOP_REAR_LEFT] = SND_MIXER_SCHN_UNKNOWN,
382 [PA_CHANNEL_POSITION_TOP_REAR_RIGHT] = SND_MIXER_SCHN_UNKNOWN
383 };
384
385 static void setting_free(pa_alsa_setting *s) {
386 pa_assert(s);
387
388 if (s->options)
389 pa_idxset_free(s->options, NULL, NULL);
390
391 pa_xfree(s->name);
392 pa_xfree(s->description);
393 pa_xfree(s);
394 }
395
396 static void option_free(pa_alsa_option *o) {
397 pa_assert(o);
398
399 pa_xfree(o->alsa_name);
400 pa_xfree(o->name);
401 pa_xfree(o->description);
402 pa_xfree(o);
403 }
404
405 static void element_free(pa_alsa_element *e) {
406 pa_alsa_option *o;
407 pa_assert(e);
408
409 while ((o = e->options)) {
410 PA_LLIST_REMOVE(pa_alsa_option, e->options, o);
411 option_free(o);
412 }
413
414 pa_xfree(e->alsa_name);
415 pa_xfree(e);
416 }
417
418 void pa_alsa_path_free(pa_alsa_path *p) {
419 pa_alsa_element *e;
420 pa_alsa_setting *s;
421
422 pa_assert(p);
423
424 while ((e = p->elements)) {
425 PA_LLIST_REMOVE(pa_alsa_element, p->elements, e);
426 element_free(e);
427 }
428
429 while ((s = p->settings)) {
430 PA_LLIST_REMOVE(pa_alsa_setting, p->settings, s);
431 setting_free(s);
432 }
433
434 pa_xfree(p->name);
435 pa_xfree(p->description);
436 pa_xfree(p);
437 }
438
439 void pa_alsa_path_set_free(pa_alsa_path_set *ps) {
440 pa_alsa_path *p;
441 pa_assert(ps);
442
443 while ((p = ps->paths)) {
444 PA_LLIST_REMOVE(pa_alsa_path, ps->paths, p);
445 pa_alsa_path_free(p);
446 }
447
448 pa_xfree(ps);
449 }
450
451 static long to_alsa_dB(pa_volume_t v) {
452 return (long) (pa_sw_volume_to_dB(v) * 100.0);
453 }
454
455 static pa_volume_t from_alsa_dB(long v) {
456 return pa_sw_volume_from_dB((double) v / 100.0);
457 }
458
459 static long to_alsa_volume(pa_volume_t v, long min, long max) {
460 long w;
461
462 w = (long) round(((double) v * (double) (max - min)) / PA_VOLUME_NORM) + min;
463 return PA_CLAMP_UNLIKELY(w, min, max);
464 }
465
466 static pa_volume_t from_alsa_volume(long v, long min, long max) {
467 return (pa_volume_t) round(((double) (v - min) * PA_VOLUME_NORM) / (double) (max - min));
468 }
469
470 #define SELEM_INIT(sid, name) \
471 do { \
472 snd_mixer_selem_id_alloca(&(sid)); \
473 snd_mixer_selem_id_set_name((sid), (name)); \
474 snd_mixer_selem_id_set_index((sid), 0); \
475 } while(FALSE)
476
477 static int element_get_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v) {
478 snd_mixer_selem_id_t *sid;
479 snd_mixer_elem_t *me;
480 snd_mixer_selem_channel_id_t c;
481 pa_channel_position_mask_t mask = 0;
482 unsigned k;
483
484 pa_assert(m);
485 pa_assert(e);
486 pa_assert(cm);
487 pa_assert(v);
488
489 SELEM_INIT(sid, e->alsa_name);
490 if (!(me = snd_mixer_find_selem(m, sid))) {
491 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
492 return -1;
493 }
494
495 pa_cvolume_mute(v, cm->channels);
496
497 /* We take the highest volume of all channels that match */
498
499 for (c = 0; c <= SND_MIXER_SCHN_LAST; c++) {
500 int r;
501 pa_volume_t f;
502
503 if (e->has_dB) {
504 long value = 0;
505
506 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
507 if (snd_mixer_selem_has_playback_channel(me, c))
508 r = snd_mixer_selem_get_playback_dB(me, c, &value);
509 else
510 r = -1;
511 } else {
512 if (snd_mixer_selem_has_capture_channel(me, c))
513 r = snd_mixer_selem_get_capture_dB(me, c, &value);
514 else
515 r = -1;
516 }
517
518 if (r < 0)
519 continue;
520
521 #ifdef HAVE_VALGRIND_MEMCHECK_H
522 VALGRIND_MAKE_MEM_DEFINED(&value, sizeof(value));
523 #endif
524
525 f = from_alsa_dB(value);
526
527 } else {
528 long value = 0;
529
530 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
531 if (snd_mixer_selem_has_playback_channel(me, c))
532 r = snd_mixer_selem_get_playback_volume(me, c, &value);
533 else
534 r = -1;
535 } else {
536 if (snd_mixer_selem_has_capture_channel(me, c))
537 r = snd_mixer_selem_get_capture_volume(me, c, &value);
538 else
539 r = -1;
540 }
541
542 if (r < 0)
543 continue;
544
545 f = from_alsa_volume(value, e->min_volume, e->max_volume);
546 }
547
548 for (k = 0; k < cm->channels; k++)
549 if (e->masks[c][e->n_channels-1] & PA_CHANNEL_POSITION_MASK(cm->map[k]))
550 if (v->values[k] < f)
551 v->values[k] = f;
552
553 mask |= e->masks[c][e->n_channels-1];
554 }
555
556 for (k = 0; k < cm->channels; k++)
557 if (!(mask & PA_CHANNEL_POSITION_MASK(cm->map[k])))
558 v->values[k] = PA_VOLUME_NORM;
559
560 return 0;
561 }
562
563 int pa_alsa_path_get_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v) {
564 pa_alsa_element *e;
565
566 pa_assert(m);
567 pa_assert(p);
568 pa_assert(cm);
569 pa_assert(v);
570
571 if (!p->has_volume)
572 return -1;
573
574 pa_cvolume_reset(v, cm->channels);
575
576 PA_LLIST_FOREACH(e, p->elements) {
577 pa_cvolume ev;
578
579 if (e->volume_use != PA_ALSA_VOLUME_MERGE)
580 continue;
581
582 pa_assert(!p->has_dB || e->has_dB);
583
584 if (element_get_volume(e, m, cm, &ev) < 0)
585 return -1;
586
587 /* If we have no dB information all we can do is take the first element and leave */
588 if (!p->has_dB) {
589 *v = ev;
590 return 0;
591 }
592
593 pa_sw_cvolume_multiply(v, v, &ev);
594 }
595
596 return 0;
597 }
598
599 static int element_get_switch(pa_alsa_element *e, snd_mixer_t *m, pa_bool_t *b) {
600 snd_mixer_selem_id_t *sid;
601 snd_mixer_elem_t *me;
602 snd_mixer_selem_channel_id_t c;
603
604 pa_assert(m);
605 pa_assert(e);
606 pa_assert(b);
607
608 SELEM_INIT(sid, e->alsa_name);
609 if (!(me = snd_mixer_find_selem(m, sid))) {
610 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
611 return -1;
612 }
613
614 /* We return muted if at least one channel is muted */
615
616 for (c = 0; c <= SND_MIXER_SCHN_LAST; c++) {
617 int r;
618 int value = 0;
619
620 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
621 if (snd_mixer_selem_has_playback_channel(me, c))
622 r = snd_mixer_selem_get_playback_switch(me, c, &value);
623 else
624 r = -1;
625 } else {
626 if (snd_mixer_selem_has_capture_channel(me, c))
627 r = snd_mixer_selem_get_capture_switch(me, c, &value);
628 else
629 r = -1;
630 }
631
632 if (r < 0)
633 continue;
634
635 if (!value) {
636 *b = FALSE;
637 return 0;
638 }
639 }
640
641 *b = TRUE;
642 return 0;
643 }
644
645 int pa_alsa_path_get_mute(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t *muted) {
646 pa_alsa_element *e;
647
648 pa_assert(m);
649 pa_assert(p);
650 pa_assert(muted);
651
652 if (!p->has_mute)
653 return -1;
654
655 PA_LLIST_FOREACH(e, p->elements) {
656 pa_bool_t b;
657
658 if (e->switch_use != PA_ALSA_SWITCH_MUTE)
659 continue;
660
661 if (element_get_switch(e, m, &b) < 0)
662 return -1;
663
664 if (!b) {
665 *muted = TRUE;
666 return 0;
667 }
668 }
669
670 *muted = FALSE;
671 return 0;
672 }
673
674 static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v) {
675 snd_mixer_selem_id_t *sid;
676 pa_cvolume rv;
677 snd_mixer_elem_t *me;
678 snd_mixer_selem_channel_id_t c;
679 pa_channel_position_mask_t mask = 0;
680 unsigned k;
681
682 pa_assert(m);
683 pa_assert(e);
684 pa_assert(cm);
685 pa_assert(v);
686 pa_assert(pa_cvolume_compatible_with_channel_map(v, cm));
687
688 SELEM_INIT(sid, e->alsa_name);
689 if (!(me = snd_mixer_find_selem(m, sid))) {
690 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
691 return -1;
692 }
693
694 pa_cvolume_mute(&rv, cm->channels);
695
696 for (c = 0; c <= SND_MIXER_SCHN_LAST; c++) {
697 int r;
698 pa_volume_t f = PA_VOLUME_MUTED;
699
700 for (k = 0; k < cm->channels; k++)
701 if (e->masks[c][e->n_channels-1] & PA_CHANNEL_POSITION_MASK(cm->map[k]))
702 if (v->values[k] > f)
703 f = v->values[k];
704
705 if (e->has_dB) {
706 long value = to_alsa_dB(f);
707
708 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
709 /* If we call set_play_volume() without checking first
710 * if the channel is available, ALSA behaves ver
711 * strangely and doesn't fail the call */
712 if (snd_mixer_selem_has_playback_channel(me, c)) {
713 if ((r = snd_mixer_selem_set_playback_dB(me, c, value, +1)) >= 0)
714 r = snd_mixer_selem_get_playback_dB(me, c, &value);
715 } else
716 r = -1;
717 } else {
718 if (snd_mixer_selem_has_capture_channel(me, c)) {
719 if ((r = snd_mixer_selem_set_capture_dB(me, c, value, +1)) >= 0)
720 r = snd_mixer_selem_get_capture_dB(me, c, &value);
721 } else
722 r = -1;
723 }
724
725 if (r < 0)
726 continue;
727
728 #ifdef HAVE_VALGRIND_MEMCHECK_H
729 VALGRIND_MAKE_MEM_DEFINED(&value, sizeof(value));
730 #endif
731
732 f = from_alsa_dB(value);
733
734 } else {
735 long value;
736
737 value = to_alsa_volume(f, e->min_volume, e->max_volume);
738
739 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
740 if (snd_mixer_selem_has_playback_channel(me, c)) {
741 if ((r = snd_mixer_selem_set_playback_volume(me, c, value)) >= 0)
742 r = snd_mixer_selem_get_playback_volume(me, c, &value);
743 } else
744 r = -1;
745 } else {
746 if (snd_mixer_selem_has_capture_channel(me, c)) {
747 if ((r = snd_mixer_selem_set_capture_volume(me, c, value)) >= 0)
748 r = snd_mixer_selem_get_capture_volume(me, c, &value);
749 } else
750 r = -1;
751 }
752
753 if (r < 0)
754 continue;
755
756 f = from_alsa_volume(value, e->min_volume, e->max_volume);
757 }
758
759 for (k = 0; k < cm->channels; k++)
760 if (e->masks[c][e->n_channels-1] & PA_CHANNEL_POSITION_MASK(cm->map[k]))
761 if (rv.values[k] < f)
762 rv.values[k] = f;
763
764 mask |= e->masks[c][e->n_channels-1];
765 }
766
767 for (k = 0; k < cm->channels; k++)
768 if (!(mask & PA_CHANNEL_POSITION_MASK(cm->map[k])))
769 rv.values[k] = PA_VOLUME_NORM;
770
771 *v = rv;
772 return 0;
773 }
774
775 int pa_alsa_path_set_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v) {
776 pa_alsa_element *e;
777 pa_cvolume rv;
778
779 pa_assert(m);
780 pa_assert(p);
781 pa_assert(cm);
782 pa_assert(v);
783 pa_assert(pa_cvolume_compatible_with_channel_map(v, cm));
784
785 if (!p->has_volume)
786 return -1;
787
788 rv = *v; /* Remaining adjustment */
789 pa_cvolume_reset(v, cm->channels); /* Adjustment done */
790
791 PA_LLIST_FOREACH(e, p->elements) {
792 pa_cvolume ev;
793
794 if (e->volume_use != PA_ALSA_VOLUME_MERGE)
795 continue;
796
797 pa_assert(!p->has_dB || e->has_dB);
798
799 ev = rv;
800 if (element_set_volume(e, m, cm, &ev) < 0)
801 return -1;
802
803 if (!p->has_dB) {
804 *v = ev;
805 return 0;
806 }
807
808 pa_sw_cvolume_multiply(v, v, &ev);
809 pa_sw_cvolume_divide(&rv, &rv, &ev);
810 }
811
812 return 0;
813 }
814
815 static int element_set_switch(pa_alsa_element *e, snd_mixer_t *m, pa_bool_t b) {
816 snd_mixer_elem_t *me;
817 snd_mixer_selem_id_t *sid;
818 int r;
819
820 pa_assert(m);
821 pa_assert(e);
822
823 SELEM_INIT(sid, e->alsa_name);
824 if (!(me = snd_mixer_find_selem(m, sid))) {
825 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
826 return -1;
827 }
828
829 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
830 r = snd_mixer_selem_set_playback_switch_all(me, b);
831 else
832 r = snd_mixer_selem_set_capture_switch_all(me, b);
833
834 if (r < 0)
835 pa_log_warn("Failed to set switch of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
836
837 return r;
838 }
839
840 int pa_alsa_path_set_mute(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t muted) {
841 pa_alsa_element *e;
842
843 pa_assert(m);
844 pa_assert(p);
845
846 if (!p->has_mute)
847 return -1;
848
849 PA_LLIST_FOREACH(e, p->elements) {
850
851 if (e->switch_use != PA_ALSA_SWITCH_MUTE)
852 continue;
853
854 if (element_set_switch(e, m, !muted) < 0)
855 return -1;
856 }
857
858 return 0;
859 }
860
861 static int element_mute_volume(pa_alsa_element *e, snd_mixer_t *m) {
862 snd_mixer_elem_t *me;
863 snd_mixer_selem_id_t *sid;
864 int r;
865
866 pa_assert(m);
867 pa_assert(e);
868
869 SELEM_INIT(sid, e->alsa_name);
870 if (!(me = snd_mixer_find_selem(m, sid))) {
871 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
872 return -1;
873 }
874
875 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
876 r = snd_mixer_selem_set_playback_volume_all(me, e->min_volume);
877 else
878 r = snd_mixer_selem_set_capture_volume_all(me, e->min_volume);
879
880 if (r < 0)
881 pa_log_warn("Faile to set volume to muted of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
882
883 return r;
884 }
885
886 /* The volume to 0dB */
887 static int element_zero_volume(pa_alsa_element *e, snd_mixer_t *m) {
888 snd_mixer_elem_t *me;
889 snd_mixer_selem_id_t *sid;
890 int r;
891
892 pa_assert(m);
893 pa_assert(e);
894
895 SELEM_INIT(sid, e->alsa_name);
896 if (!(me = snd_mixer_find_selem(m, sid))) {
897 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
898 return -1;
899 }
900
901 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
902 r = snd_mixer_selem_set_playback_dB_all(me, 0, +1);
903 else
904 r = snd_mixer_selem_set_capture_dB_all(me, 0, +1);
905
906 if (r < 0)
907 pa_log_warn("Faile to set volume to 0dB of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
908
909 return r;
910 }
911
912 int pa_alsa_path_select(pa_alsa_path *p, snd_mixer_t *m) {
913 pa_alsa_element *e;
914 int r;
915
916 pa_assert(m);
917 pa_assert(p);
918
919 pa_log_debug("Activating path %s", p->name);
920 pa_alsa_path_dump(p);
921
922 PA_LLIST_FOREACH(e, p->elements) {
923
924 switch (e->switch_use) {
925 case PA_ALSA_SWITCH_MUTE:
926 case PA_ALSA_SWITCH_OFF:
927 r = element_set_switch(e, m, FALSE);
928 break;
929
930 case PA_ALSA_SWITCH_ON:
931 r = element_set_switch(e, m, TRUE);
932 break;
933
934 case PA_ALSA_SWITCH_IGNORE:
935 case PA_ALSA_SWITCH_SELECT:
936 r = 0;
937 break;
938 }
939
940 if (r < 0)
941 return -1;
942
943 switch (e->volume_use) {
944 case PA_ALSA_VOLUME_OFF:
945 case PA_ALSA_VOLUME_MERGE:
946 r = element_mute_volume(e, m);
947 break;
948
949 case PA_ALSA_VOLUME_ZERO:
950 r = element_zero_volume(e, m);
951 break;
952
953 case PA_ALSA_VOLUME_IGNORE:
954 r = 0;
955 break;
956 }
957
958 if (r < 0)
959 return -1;
960 }
961
962 return 0;
963 }
964
965 static int check_required(pa_alsa_element *e, snd_mixer_elem_t *me) {
966 pa_bool_t has_switch;
967 pa_bool_t has_enumeration;
968 pa_bool_t has_volume;
969
970 pa_assert(e);
971 pa_assert(me);
972
973 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
974 has_switch =
975 snd_mixer_selem_has_playback_switch(me) ||
976 (e->direction_try_other && snd_mixer_selem_has_capture_switch(me));
977 } else {
978 has_switch =
979 snd_mixer_selem_has_capture_switch(me) ||
980 (e->direction_try_other && snd_mixer_selem_has_playback_switch(me));
981 }
982
983 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
984 has_volume =
985 snd_mixer_selem_has_playback_volume(me) ||
986 (e->direction_try_other && snd_mixer_selem_has_capture_volume(me));
987 } else {
988 has_volume =
989 snd_mixer_selem_has_capture_volume(me) ||
990 (e->direction_try_other && snd_mixer_selem_has_playback_volume(me));
991 }
992
993 has_enumeration = snd_mixer_selem_is_enumerated(me);
994
995 if ((e->required == PA_ALSA_REQUIRED_SWITCH && !has_switch) ||
996 (e->required == PA_ALSA_REQUIRED_VOLUME && !has_volume) ||
997 (e->required == PA_ALSA_REQUIRED_ENUMERATION && !has_enumeration))
998 return -1;
999
1000 if (e->required == PA_ALSA_REQUIRED_ANY && !(has_switch || has_volume || has_enumeration))
1001 return -1;
1002
1003 if ((e->required_absent == PA_ALSA_REQUIRED_SWITCH && has_switch) ||
1004 (e->required_absent == PA_ALSA_REQUIRED_VOLUME && has_volume) ||
1005 (e->required_absent == PA_ALSA_REQUIRED_ENUMERATION && has_enumeration))
1006 return -1;
1007
1008 if (e->required_absent == PA_ALSA_REQUIRED_ANY && (has_switch || has_volume || has_enumeration))
1009 return -1;
1010
1011 return 0;
1012 }
1013
1014 static int element_probe(pa_alsa_element *e, snd_mixer_t *m) {
1015 snd_mixer_selem_id_t *sid;
1016 snd_mixer_elem_t *me;
1017
1018 pa_assert(m);
1019 pa_assert(e);
1020
1021 SELEM_INIT(sid, e->alsa_name);
1022
1023 if (!(me = snd_mixer_find_selem(m, sid))) {
1024
1025 if (e->required != PA_ALSA_REQUIRED_IGNORE)
1026 return -1;
1027
1028 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1029 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1030 e->enumeration_use = PA_ALSA_VOLUME_IGNORE;
1031
1032 return 0;
1033 }
1034
1035 if (e->switch_use != PA_ALSA_SWITCH_IGNORE) {
1036 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
1037
1038 if (!snd_mixer_selem_has_playback_switch(me)) {
1039 if (e->direction_try_other && snd_mixer_selem_has_capture_switch(me))
1040 e->direction = PA_ALSA_DIRECTION_INPUT;
1041 else
1042 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1043 }
1044
1045 } else {
1046
1047 if (!snd_mixer_selem_has_capture_switch(me)) {
1048 if (e->direction_try_other && snd_mixer_selem_has_playback_switch(me))
1049 e->direction = PA_ALSA_DIRECTION_OUTPUT;
1050 else
1051 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1052 }
1053 }
1054
1055 if (e->switch_use != PA_ALSA_SWITCH_IGNORE)
1056 e->direction_try_other = FALSE;
1057 }
1058
1059 if (e->volume_use != PA_ALSA_VOLUME_IGNORE) {
1060
1061 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
1062
1063 if (!snd_mixer_selem_has_playback_volume(me)) {
1064 if (e->direction_try_other && snd_mixer_selem_has_capture_volume(me))
1065 e->direction = PA_ALSA_DIRECTION_INPUT;
1066 else
1067 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1068 }
1069
1070 } else {
1071
1072 if (!snd_mixer_selem_has_capture_volume(me)) {
1073 if (e->direction_try_other && snd_mixer_selem_has_playback_volume(me))
1074 e->direction = PA_ALSA_DIRECTION_OUTPUT;
1075 else
1076 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1077 }
1078 }
1079
1080 if (e->volume_use != PA_ALSA_VOLUME_IGNORE) {
1081 long min_dB = 0, max_dB = 0;
1082 int r;
1083
1084 e->direction_try_other = FALSE;
1085
1086 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1087 e->has_dB = snd_mixer_selem_get_playback_dB_range(me, &min_dB, &max_dB) >= 0;
1088 else
1089 e->has_dB = snd_mixer_selem_get_capture_dB_range(me, &min_dB, &max_dB) >= 0;
1090
1091 if (e->has_dB) {
1092 #ifdef HAVE_VALGRIND_MEMCHECK_H
1093 VALGRIND_MAKE_MEM_DEFINED(&min_dB, sizeof(min_dB));
1094 VALGRIND_MAKE_MEM_DEFINED(&max_dB, sizeof(max_dB));
1095 #endif
1096
1097 e->min_dB = ((double) min_dB) / 100.0;
1098 e->max_dB = ((double) max_dB) / 100.0;
1099
1100 if (min_dB >= max_dB) {
1101 pa_log_warn("Your kernel driver is broken: it reports a volume range from %0.2f dB to %0.2f dB which makes no sense.", e->min_dB, e->max_dB);
1102 e->has_dB = FALSE;
1103 }
1104 }
1105
1106 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1107 r = snd_mixer_selem_get_playback_volume_range(me, &e->min_volume, &e->max_volume);
1108 else
1109 r = snd_mixer_selem_get_capture_volume_range(me, &e->min_volume, &e->max_volume);
1110
1111 if (r < 0) {
1112 pa_log_warn("Failed to get volume range of %s: %s", e->alsa_name, pa_alsa_strerror(r));
1113 return -1;
1114 }
1115
1116
1117 if (e->min_volume >= e->max_volume) {
1118 pa_log_warn("Your kernel driver is broken: it reports a volume range from %li to %li which makes no sense.", e->min_volume, e->max_volume);
1119 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1120
1121 } else {
1122 pa_bool_t is_mono;
1123 pa_channel_position_t p;
1124
1125 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1126 is_mono = snd_mixer_selem_is_playback_mono(me) > 0;
1127 else
1128 is_mono = snd_mixer_selem_is_capture_mono(me) > 0;
1129
1130 if (is_mono) {
1131 e->n_channels = 1;
1132
1133 if (!e->override_map) {
1134 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++)
1135 e->masks[alsa_channel_ids[p]][e->n_channels-1] = 0;
1136 e->masks[SND_MIXER_SCHN_MONO][e->n_channels-1] = PA_CHANNEL_POSITION_MASK_ALL;
1137 }
1138
1139 e->merged_mask = e->masks[SND_MIXER_SCHN_MONO][e->n_channels-1];
1140 } else {
1141 e->n_channels = 0;
1142 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++) {
1143
1144 if (alsa_channel_ids[p] == SND_MIXER_SCHN_UNKNOWN)
1145 continue;
1146
1147 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1148 e->n_channels += snd_mixer_selem_has_playback_channel(me, alsa_channel_ids[p]) > 0;
1149 else
1150 e->n_channels += snd_mixer_selem_has_capture_channel(me, alsa_channel_ids[p]) > 0;
1151 }
1152
1153 if (e->n_channels <= 0) {
1154 pa_log_warn("Volume element %s with no channels?", e->alsa_name);
1155 return -1;
1156 }
1157
1158 if (!e->override_map) {
1159 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++) {
1160 pa_bool_t has_channel;
1161
1162 if (alsa_channel_ids[p] == SND_MIXER_SCHN_UNKNOWN)
1163 continue;
1164
1165 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1166 has_channel = snd_mixer_selem_has_playback_channel(me, alsa_channel_ids[p]) > 0;
1167 else
1168 has_channel = snd_mixer_selem_has_capture_channel(me, alsa_channel_ids[p]) > 0;
1169
1170 e->masks[alsa_channel_ids[p]][e->n_channels-1] = has_channel ? PA_CHANNEL_POSITION_MASK(p) : 0;
1171 }
1172 }
1173
1174 e->merged_mask = 0;
1175 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++)
1176 e->merged_mask |= e->masks[alsa_channel_ids[p]][e->n_channels-1];
1177 }
1178 }
1179 }
1180
1181 }
1182
1183 if (check_required(e, me) < 0)
1184 return -1;
1185
1186 if (e->switch_use == PA_ALSA_SWITCH_SELECT) {
1187 pa_alsa_option *o;
1188
1189 PA_LLIST_FOREACH(o, e->options)
1190 o->alsa_idx = pa_streq(o->alsa_name, "on") ? 1 : 0;
1191 } else if (e->enumeration_use == PA_ALSA_ENUMERATION_SELECT) {
1192 int n;
1193 pa_alsa_option *o;
1194
1195 if ((n = snd_mixer_selem_get_enum_items(me)) < 0) {
1196 pa_log("snd_mixer_selem_get_enum_items() failed: %s", pa_alsa_strerror(n));
1197 return -1;
1198 }
1199
1200 PA_LLIST_FOREACH(o, e->options) {
1201 int i;
1202
1203 for (i = 0; i < n; i++) {
1204 char buf[128];
1205
1206 if (snd_mixer_selem_get_enum_item_name(me, i, sizeof(buf), buf) < 0)
1207 continue;
1208
1209 if (!pa_streq(buf, o->alsa_name))
1210 continue;
1211
1212 o->alsa_idx = i;
1213 }
1214 }
1215 }
1216
1217 return 0;
1218 }
1219
1220 static pa_alsa_element* element_get(pa_alsa_path *p, const char *section, pa_bool_t prefixed) {
1221 pa_alsa_element *e;
1222
1223 pa_assert(p);
1224 pa_assert(section);
1225
1226 if (prefixed) {
1227 if (!pa_startswith(section, "Element "))
1228 return NULL;
1229
1230 section += 8;
1231 }
1232
1233 /* This is not an element section, but an enum section? */
1234 if (strchr(section, ':'))
1235 return NULL;
1236
1237 if (p->last_element && pa_streq(p->last_element->alsa_name, section))
1238 return p->last_element;
1239
1240 PA_LLIST_FOREACH(e, p->elements)
1241 if (pa_streq(e->alsa_name, section))
1242 goto finish;
1243
1244 e = pa_xnew0(pa_alsa_element, 1);
1245 e->path = p;
1246 e->alsa_name = pa_xstrdup(section);
1247 e->direction = p->direction;
1248
1249 PA_LLIST_INSERT_AFTER(pa_alsa_element, p->elements, p->last_element, e);
1250
1251 finish:
1252 p->last_element = e;
1253 return e;
1254 }
1255
1256 static pa_alsa_option* option_get(pa_alsa_path *p, const char *section) {
1257 char *en;
1258 const char *on;
1259 pa_alsa_option *o;
1260 pa_alsa_element *e;
1261
1262 if (!pa_startswith(section, "Option "))
1263 return NULL;
1264
1265 section += 7;
1266
1267 /* This is not an enum section, but an element section? */
1268 if (!(on = strchr(section, ':')))
1269 return NULL;
1270
1271 en = pa_xstrndup(section, on - section);
1272 on++;
1273
1274 if (p->last_option &&
1275 pa_streq(p->last_option->element->alsa_name, en) &&
1276 pa_streq(p->last_option->alsa_name, on)) {
1277 pa_xfree(en);
1278 return p->last_option;
1279 }
1280
1281 pa_assert_se(e = element_get(p, en, FALSE));
1282 pa_xfree(en);
1283
1284 PA_LLIST_FOREACH(o, e->options)
1285 if (pa_streq(o->alsa_name, on))
1286 goto finish;
1287
1288 o = pa_xnew0(pa_alsa_option, 1);
1289 o->element = e;
1290 o->alsa_name = pa_xstrdup(on);
1291 o->alsa_idx = -1;
1292
1293 if (p->last_option && p->last_option->element == e)
1294 PA_LLIST_INSERT_AFTER(pa_alsa_option, e->options, p->last_option, o);
1295 else
1296 PA_LLIST_PREPEND(pa_alsa_option, e->options, o);
1297
1298 finish:
1299 p->last_option = o;
1300 return o;
1301 }
1302
1303 static int element_parse_switch(
1304 const char *filename,
1305 unsigned line,
1306 const char *section,
1307 const char *lvalue,
1308 const char *rvalue,
1309 void *data,
1310 void *userdata) {
1311
1312 pa_alsa_path *p = userdata;
1313 pa_alsa_element *e;
1314
1315 pa_assert(p);
1316
1317 if (!(e = element_get(p, section, TRUE))) {
1318 pa_log("[%s:%u] Switch makes no sense in '%s'", filename, line, section);
1319 return -1;
1320 }
1321
1322 if (pa_streq(rvalue, "ignore"))
1323 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1324 else if (pa_streq(rvalue, "mute"))
1325 e->switch_use = PA_ALSA_SWITCH_MUTE;
1326 else if (pa_streq(rvalue, "off"))
1327 e->switch_use = PA_ALSA_SWITCH_OFF;
1328 else if (pa_streq(rvalue, "on"))
1329 e->switch_use = PA_ALSA_SWITCH_ON;
1330 else if (pa_streq(rvalue, "select"))
1331 e->switch_use = PA_ALSA_SWITCH_SELECT;
1332 else {
1333 pa_log("[%s:%u] Switch invalid of '%s'", filename, line, section);
1334 return -1;
1335 }
1336
1337 return 0;
1338 }
1339
1340 static int element_parse_volume(
1341 const char *filename,
1342 unsigned line,
1343 const char *section,
1344 const char *lvalue,
1345 const char *rvalue,
1346 void *data,
1347 void *userdata) {
1348
1349 pa_alsa_path *p = userdata;
1350 pa_alsa_element *e;
1351
1352 pa_assert(p);
1353
1354 if (!(e = element_get(p, section, TRUE))) {
1355 pa_log("[%s:%u] Volume makes no sense in '%s'", filename, line, section);
1356 return -1;
1357 }
1358
1359 if (pa_streq(rvalue, "ignore"))
1360 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1361 else if (pa_streq(rvalue, "merge"))
1362 e->volume_use = PA_ALSA_VOLUME_MERGE;
1363 else if (pa_streq(rvalue, "off"))
1364 e->volume_use = PA_ALSA_VOLUME_OFF;
1365 else if (pa_streq(rvalue, "zero"))
1366 e->volume_use = PA_ALSA_VOLUME_ZERO;
1367 else {
1368 pa_log("[%s:%u] Volume invalid of '%s'", filename, line, section);
1369 return -1;
1370 }
1371
1372 return 0;
1373 }
1374
1375 static int element_parse_enumeration(
1376 const char *filename,
1377 unsigned line,
1378 const char *section,
1379 const char *lvalue,
1380 const char *rvalue,
1381 void *data,
1382 void *userdata) {
1383
1384 pa_alsa_path *p = userdata;
1385 pa_alsa_element *e;
1386
1387 pa_assert(p);
1388
1389 if (!(e = element_get(p, section, TRUE))) {
1390 pa_log("[%s:%u] Enumeration makes no sense in '%s'", filename, line, section);
1391 return -1;
1392 }
1393
1394 if (pa_streq(rvalue, "ignore"))
1395 e->enumeration_use = PA_ALSA_ENUMERATION_IGNORE;
1396 else if (pa_streq(rvalue, "select"))
1397 e->enumeration_use = PA_ALSA_ENUMERATION_SELECT;
1398 else {
1399 pa_log("[%s:%u] Enumeration invalid of '%s'", filename, line, section);
1400 return -1;
1401 }
1402
1403 return 0;
1404 }
1405
1406 static int option_parse_priority(
1407 const char *filename,
1408 unsigned line,
1409 const char *section,
1410 const char *lvalue,
1411 const char *rvalue,
1412 void *data,
1413 void *userdata) {
1414
1415 pa_alsa_path *p = userdata;
1416 pa_alsa_option *o;
1417 uint32_t prio;
1418
1419 pa_assert(p);
1420
1421 if (!(o = option_get(p, section))) {
1422 pa_log("[%s:%u] Priority makes no sense in '%s'", filename, line, section);
1423 return -1;
1424 }
1425
1426 if (pa_atou(rvalue, &prio) < 0) {
1427 pa_log("[%s:%u] Priority invalid of '%s'", filename, line, section);
1428 return -1;
1429 }
1430
1431 o->priority = prio;
1432 return 0;
1433 }
1434
1435 static int option_parse_name(
1436 const char *filename,
1437 unsigned line,
1438 const char *section,
1439 const char *lvalue,
1440 const char *rvalue,
1441 void *data,
1442 void *userdata) {
1443
1444 pa_alsa_path *p = userdata;
1445 pa_alsa_option *o;
1446
1447 pa_assert(p);
1448
1449 if (!(o = option_get(p, section))) {
1450 pa_log("[%s:%u] Name makes no sense in '%s'", filename, line, section);
1451 return -1;
1452 }
1453
1454 pa_xfree(o->name);
1455 o->name = pa_xstrdup(rvalue);
1456
1457 return 0;
1458 }
1459
1460 static int element_parse_required(
1461 const char *filename,
1462 unsigned line,
1463 const char *section,
1464 const char *lvalue,
1465 const char *rvalue,
1466 void *data,
1467 void *userdata) {
1468
1469 pa_alsa_path *p = userdata;
1470 pa_alsa_element *e;
1471 pa_alsa_required_t req;
1472
1473 pa_assert(p);
1474
1475 if (!(e = element_get(p, section, TRUE))) {
1476 pa_log("[%s:%u] Required makes no sense in '%s'", filename, line, section);
1477 return -1;
1478 }
1479
1480 if (pa_streq(rvalue, "ignore"))
1481 req = PA_ALSA_REQUIRED_IGNORE;
1482 else if (pa_streq(rvalue, "switch"))
1483 req = PA_ALSA_REQUIRED_SWITCH;
1484 else if (pa_streq(rvalue, "volume"))
1485 req = PA_ALSA_REQUIRED_VOLUME;
1486 else if (pa_streq(rvalue, "enumeration"))
1487 req = PA_ALSA_REQUIRED_ENUMERATION;
1488 else if (pa_streq(rvalue, "any"))
1489 req = PA_ALSA_REQUIRED_ANY;
1490 else {
1491 pa_log("[%s:%u] Required invalid of '%s'", filename, line, section);
1492 return -1;
1493 }
1494
1495 if (pa_streq(lvalue, "required-absent"))
1496 e->required_absent = req;
1497 else
1498 e->required = req;
1499
1500 return 0;
1501 }
1502
1503 static int element_parse_direction(
1504 const char *filename,
1505 unsigned line,
1506 const char *section,
1507 const char *lvalue,
1508 const char *rvalue,
1509 void *data,
1510 void *userdata) {
1511
1512 pa_alsa_path *p = userdata;
1513 pa_alsa_element *e;
1514
1515 pa_assert(p);
1516
1517 if (!(e = element_get(p, section, TRUE))) {
1518 pa_log("[%s:%u] Direction makes no sense in '%s'", filename, line, section);
1519 return -1;
1520 }
1521
1522 if (pa_streq(rvalue, "playback"))
1523 e->direction = PA_ALSA_DIRECTION_OUTPUT;
1524 else if (pa_streq(rvalue, "capture"))
1525 e->direction = PA_ALSA_DIRECTION_INPUT;
1526 else {
1527 pa_log("[%s:%u] Direction invalid of '%s'", filename, line, section);
1528 return -1;
1529 }
1530
1531 return 0;
1532 }
1533
1534 static int element_parse_direction_try_other(
1535 const char *filename,
1536 unsigned line,
1537 const char *section,
1538 const char *lvalue,
1539 const char *rvalue,
1540 void *data,
1541 void *userdata) {
1542
1543 pa_alsa_path *p = userdata;
1544 pa_alsa_element *e;
1545 int yes;
1546
1547 if (!(e = element_get(p, section, TRUE))) {
1548 pa_log("[%s:%u] Direction makes no sense in '%s'", filename, line, section);
1549 return -1;
1550 }
1551
1552 if ((yes = pa_parse_boolean(rvalue)) < 0) {
1553 pa_log("[%s:%u] Direction invalid of '%s'", filename, line, section);
1554 return -1;
1555 }
1556
1557 e->direction_try_other = !!yes;
1558 return 0;
1559 }
1560
1561 static pa_channel_position_mask_t parse_mask(const char *m) {
1562 pa_channel_position_mask_t v;
1563
1564 if (pa_streq(m, "all-left"))
1565 v = PA_CHANNEL_POSITION_MASK_LEFT;
1566 else if (pa_streq(m, "all-right"))
1567 v = PA_CHANNEL_POSITION_MASK_RIGHT;
1568 else if (pa_streq(m, "all-center"))
1569 v = PA_CHANNEL_POSITION_MASK_CENTER;
1570 else if (pa_streq(m, "all-front"))
1571 v = PA_CHANNEL_POSITION_MASK_FRONT;
1572 else if (pa_streq(m, "all-rear"))
1573 v = PA_CHANNEL_POSITION_MASK_REAR;
1574 else if (pa_streq(m, "all-side"))
1575 v = PA_CHANNEL_POSITION_MASK_SIDE_OR_TOP_CENTER;
1576 else if (pa_streq(m, "all-top"))
1577 v = PA_CHANNEL_POSITION_MASK_TOP;
1578 else if (pa_streq(m, "all-no-lfe"))
1579 v = PA_CHANNEL_POSITION_MASK_ALL ^ PA_CHANNEL_POSITION_MASK(PA_CHANNEL_POSITION_LFE);
1580 else if (pa_streq(m, "all"))
1581 v = PA_CHANNEL_POSITION_MASK_ALL;
1582 else {
1583 pa_channel_position_t p;
1584
1585 if ((p = pa_channel_position_from_string(m)) == PA_CHANNEL_POSITION_INVALID)
1586 return 0;
1587
1588 v = PA_CHANNEL_POSITION_MASK(p);
1589 }
1590
1591 return v;
1592 }
1593
1594 static int element_parse_override_map(
1595 const char *filename,
1596 unsigned line,
1597 const char *section,
1598 const char *lvalue,
1599 const char *rvalue,
1600 void *data,
1601 void *userdata) {
1602
1603 pa_alsa_path *p = userdata;
1604 pa_alsa_element *e;
1605 const char *state = NULL;
1606 unsigned i = 0;
1607 char *n;
1608
1609 if (!(e = element_get(p, section, TRUE))) {
1610 pa_log("[%s:%u] Override map makes no sense in '%s'", filename, line, section);
1611 return -1;
1612 }
1613
1614 while ((n = pa_split(rvalue, ",", &state))) {
1615 pa_channel_position_mask_t m;
1616
1617 if (!*n)
1618 m = 0;
1619 else {
1620 if ((m = parse_mask(n)) == 0) {
1621 pa_log("[%s:%u] Override map '%s' invalid in '%s'", filename, line, n, section);
1622 pa_xfree(n);
1623 return -1;
1624 }
1625 }
1626
1627 if (pa_streq(lvalue, "override-map.1"))
1628 e->masks[i++][0] = m;
1629 else
1630 e->masks[i++][1] = m;
1631
1632 /* Later on we might add override-map.3 and so on here ... */
1633
1634 pa_xfree(n);
1635 }
1636
1637 e->override_map = TRUE;
1638
1639 return 0;
1640 }
1641
1642 static int element_set_option(pa_alsa_element *e, snd_mixer_t *m, int alsa_idx) {
1643 snd_mixer_selem_id_t *sid;
1644 snd_mixer_elem_t *me;
1645 int r;
1646
1647 pa_assert(e);
1648 pa_assert(m);
1649
1650 SELEM_INIT(sid, e->alsa_name);
1651 if (!(me = snd_mixer_find_selem(m, sid))) {
1652 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
1653 return -1;
1654 }
1655
1656 if (e->switch_use == PA_ALSA_SWITCH_SELECT) {
1657
1658 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1659 r = snd_mixer_selem_set_playback_switch_all(me, alsa_idx);
1660 else
1661 r = snd_mixer_selem_set_capture_switch_all(me, alsa_idx);
1662
1663 if (r < 0)
1664 pa_log_warn("Faile to set switch of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
1665
1666 } else {
1667 pa_assert(e->enumeration_use == PA_ALSA_ENUMERATION_SELECT);
1668
1669 if ((r = snd_mixer_selem_set_enum_item(me, 0, alsa_idx)) < 0)
1670 pa_log_warn("Faile to set enumeration of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
1671 }
1672
1673 return r;
1674 }
1675
1676 int pa_alsa_setting_select(pa_alsa_setting *s, snd_mixer_t *m) {
1677 pa_alsa_option *o;
1678 uint32_t idx;
1679
1680 pa_assert(s);
1681 pa_assert(m);
1682
1683 PA_IDXSET_FOREACH(o, s->options, idx)
1684 element_set_option(o->element, m, o->alsa_idx);
1685
1686 return 0;
1687 }
1688
1689 static int option_verify(pa_alsa_option *o) {
1690 static const struct description_map well_known_descriptions[] = {
1691 { "input", N_("Input") },
1692 { "input-docking", N_("Docking Station Input") },
1693 { "input-docking-microphone", N_("Docking Station Microphone") },
1694 { "input-linein", N_("Line-In") },
1695 { "input-microphone", N_("Microphone") },
1696 { "input-microphone-external", N_("External Microphone") },
1697 { "input-microphone-internal", N_("Internal Microphone") },
1698 { "input-radio", N_("Radio") },
1699 { "input-video", N_("Video") },
1700 { "input-agc-on", N_("Automatic Gain Control") },
1701 { "input-agc-off", "" },
1702 { "input-boost-on", N_("Boost") },
1703 { "input-boost-off", "" },
1704 { "output-amplifier-on", N_("Amplifier") },
1705 { "output-amplifier-off", "" }
1706 };
1707
1708 pa_assert(o);
1709
1710 if (!o->name) {
1711 pa_log("No name set for option %s", o->alsa_name);
1712 return -1;
1713 }
1714
1715 if (o->element->enumeration_use != PA_ALSA_ENUMERATION_SELECT &&
1716 o->element->switch_use != PA_ALSA_SWITCH_SELECT) {
1717 pa_log("Element %s of option %s not set for select.", o->element->alsa_name, o->name);
1718 return -1;
1719 }
1720
1721 if (o->element->switch_use == PA_ALSA_SWITCH_SELECT &&
1722 !pa_streq(o->alsa_name, "on") &&
1723 !pa_streq(o->alsa_name, "off")) {
1724 pa_log("Switch %s options need be named off or on ", o->element->alsa_name);
1725 return -1;
1726 }
1727
1728 if (!o->description)
1729 o->description = pa_xstrdup(lookup_description(o->name,
1730 well_known_descriptions,
1731 PA_ELEMENTSOF(well_known_descriptions)));
1732 if (!o->description)
1733 o->description = pa_xstrdup(o->name);
1734
1735 return 0;
1736 }
1737
1738 static int element_verify(pa_alsa_element *e) {
1739 pa_alsa_option *o;
1740
1741 pa_assert(e);
1742
1743 if ((e->required != PA_ALSA_REQUIRED_IGNORE && e->required == e->required_absent) ||
1744 (e->required_absent == PA_ALSA_REQUIRED_ANY && e->required != PA_ALSA_REQUIRED_IGNORE)) {
1745 pa_log("Element %s cannot be required and absent at the same time.", e->alsa_name);
1746 return -1;
1747 }
1748
1749 if (e->switch_use == PA_ALSA_SWITCH_SELECT && e->enumeration_use == PA_ALSA_ENUMERATION_SELECT) {
1750 pa_log("Element %s cannot set select for both switch and enumeration.", e->alsa_name);
1751 return -1;
1752 }
1753
1754 PA_LLIST_FOREACH(o, e->options)
1755 if (option_verify(o) < 0)
1756 return -1;
1757
1758 return 0;
1759 }
1760
1761 static int path_verify(pa_alsa_path *p) {
1762 static const struct description_map well_known_descriptions[] = {
1763 { "analog-input", N_("Analog Input") },
1764 { "analog-input-microphone", N_("Analog Microphone") },
1765 { "analog-input-linein", N_("Analog Line-In") },
1766 { "analog-input-radio", N_("Analog Radio") },
1767 { "analog-input-video", N_("Analog Video") },
1768 { "analog-output", N_("Analog Output") },
1769 { "analog-output-headphones", N_("Analog Headphones") },
1770 { "analog-output-lfe-on-mono", N_("Analog Output (LFE)") },
1771 { "analog-output-mono", N_("Analog Mono Output") }
1772 };
1773
1774 pa_alsa_element *e;
1775
1776 pa_assert(p);
1777
1778 PA_LLIST_FOREACH(e, p->elements)
1779 if (element_verify(e) < 0)
1780 return -1;
1781
1782 if (!p->description)
1783 p->description = pa_xstrdup(lookup_description(p->name,
1784 well_known_descriptions,
1785 PA_ELEMENTSOF(well_known_descriptions)));
1786
1787 if (!p->description)
1788 p->description = pa_xstrdup(p->name);
1789
1790 return 0;
1791 }
1792
1793 pa_alsa_path* pa_alsa_path_new(const char *fname, pa_alsa_direction_t direction) {
1794 pa_alsa_path *p;
1795 char *fn;
1796 int r;
1797 const char *n;
1798
1799 pa_config_item items[] = {
1800 /* [General] */
1801 { "priority", pa_config_parse_unsigned, NULL, "General" },
1802 { "description", pa_config_parse_string, NULL, "General" },
1803 { "name", pa_config_parse_string, NULL, "General" },
1804
1805 /* [Option ...] */
1806 { "priority", option_parse_priority, NULL, NULL },
1807 { "name", option_parse_name, NULL, NULL },
1808
1809 /* [Element ...] */
1810 { "switch", element_parse_switch, NULL, NULL },
1811 { "volume", element_parse_volume, NULL, NULL },
1812 { "enumeration", element_parse_enumeration, NULL, NULL },
1813 { "override-map.1", element_parse_override_map, NULL, NULL },
1814 { "override-map.2", element_parse_override_map, NULL, NULL },
1815 /* ... later on we might add override-map.3 and so on here ... */
1816 { "required", element_parse_required, NULL, NULL },
1817 { "required-absent", element_parse_required, NULL, NULL },
1818 { "direction", element_parse_direction, NULL, NULL },
1819 { "direction-try-other", element_parse_direction_try_other, NULL, NULL },
1820 { NULL, NULL, NULL, NULL }
1821 };
1822
1823 pa_assert(fname);
1824
1825 p = pa_xnew0(pa_alsa_path, 1);
1826 n = pa_path_get_filename(fname);
1827 p->name = pa_xstrndup(n, strcspn(n, "."));
1828 p->direction = direction;
1829
1830 items[0].data = &p->priority;
1831 items[1].data = &p->description;
1832 items[2].data = &p->name;
1833
1834 fn = pa_maybe_prefix_path(fname, PA_ALSA_PATHS_DIR);
1835 r = pa_config_parse(fn, NULL, items, p);
1836 pa_xfree(fn);
1837
1838 if (r < 0)
1839 goto fail;
1840
1841 if (path_verify(p) < 0)
1842 goto fail;
1843
1844 return p;
1845
1846 fail:
1847 pa_alsa_path_free(p);
1848 return NULL;
1849 }
1850
1851 pa_alsa_path* pa_alsa_path_synthesize(const char*element, pa_alsa_direction_t direction) {
1852 pa_alsa_path *p;
1853 pa_alsa_element *e;
1854
1855 pa_assert(element);
1856
1857 p = pa_xnew0(pa_alsa_path, 1);
1858 p->name = pa_xstrdup(element);
1859 p->direction = direction;
1860
1861 e = pa_xnew0(pa_alsa_element, 1);
1862 e->path = p;
1863 e->alsa_name = pa_xstrdup(element);
1864 e->direction = direction;
1865
1866 e->switch_use = PA_ALSA_SWITCH_MUTE;
1867 e->volume_use = PA_ALSA_VOLUME_MERGE;
1868
1869 PA_LLIST_PREPEND(pa_alsa_element, p->elements, e);
1870 return p;
1871 }
1872
1873 static pa_bool_t element_drop_unsupported(pa_alsa_element *e) {
1874 pa_alsa_option *o, *n;
1875
1876 pa_assert(e);
1877
1878 for (o = e->options; o; o = n) {
1879 n = o->next;
1880
1881 if (o->alsa_idx < 0) {
1882 PA_LLIST_REMOVE(pa_alsa_option, e->options, o);
1883 option_free(o);
1884 }
1885 }
1886
1887 return
1888 e->switch_use != PA_ALSA_SWITCH_IGNORE ||
1889 e->volume_use != PA_ALSA_VOLUME_IGNORE ||
1890 e->enumeration_use != PA_ALSA_ENUMERATION_IGNORE;
1891 }
1892
1893 static void path_drop_unsupported(pa_alsa_path *p) {
1894 pa_alsa_element *e, *n;
1895
1896 pa_assert(p);
1897
1898 for (e = p->elements; e; e = n) {
1899 n = e->next;
1900
1901 if (!element_drop_unsupported(e)) {
1902 PA_LLIST_REMOVE(pa_alsa_element, p->elements, e);
1903 element_free(e);
1904 }
1905 }
1906 }
1907
1908 static void path_make_options_unique(pa_alsa_path *p) {
1909 pa_alsa_element *e;
1910 pa_alsa_option *o, *u;
1911
1912 PA_LLIST_FOREACH(e, p->elements) {
1913 PA_LLIST_FOREACH(o, e->options) {
1914 unsigned i;
1915 char *m;
1916
1917 for (u = o->next; u; u = u->next)
1918 if (pa_streq(u->name, o->name))
1919 break;
1920
1921 if (!u)
1922 continue;
1923
1924 m = pa_xstrdup(o->name);
1925
1926 /* OK, this name is not unique, hence let's rename */
1927 for (i = 1, u = o; u; u = u->next) {
1928 char *nn, *nd;
1929
1930 if (!pa_streq(u->name, m))
1931 continue;
1932
1933 nn = pa_sprintf_malloc("%s-%u", m, i);
1934 pa_xfree(u->name);
1935 u->name = nn;
1936
1937 nd = pa_sprintf_malloc("%s %u", u->description, i);
1938 pa_xfree(u->description);
1939 u->description = nd;
1940
1941 i++;
1942 }
1943
1944 pa_xfree(m);
1945 }
1946 }
1947 }
1948
1949 static pa_bool_t element_create_settings(pa_alsa_element *e, pa_alsa_setting *template) {
1950 pa_alsa_option *o;
1951
1952 for (; e; e = e->next)
1953 if (e->switch_use == PA_ALSA_SWITCH_SELECT ||
1954 e->enumeration_use == PA_ALSA_ENUMERATION_SELECT)
1955 break;
1956
1957 if (!e)
1958 return FALSE;
1959
1960 for (o = e->options; o; o = o->next) {
1961 pa_alsa_setting *s;
1962
1963 if (template) {
1964 s = pa_xnewdup(pa_alsa_setting, template, 1);
1965 s->options = pa_idxset_copy(template->options);
1966 s->name = pa_sprintf_malloc(_("%s+%s"), template->name, o->name);
1967 s->description =
1968 (template->description[0] && o->description[0])
1969 ? pa_sprintf_malloc(_("%s / %s"), template->description, o->description)
1970 : (template->description[0]
1971 ? pa_xstrdup(template->description)
1972 : pa_xstrdup(o->description));
1973
1974 s->priority = PA_MAX(template->priority, o->priority);
1975 } else {
1976 s = pa_xnew0(pa_alsa_setting, 1);
1977 s->options = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1978 s->name = pa_xstrdup(o->name);
1979 s->description = pa_xstrdup(o->description);
1980 s->priority = o->priority;
1981 }
1982
1983 pa_idxset_put(s->options, o, NULL);
1984
1985 if (element_create_settings(e->next, s))
1986 /* This is not a leaf, so let's get rid of it */
1987 setting_free(s);
1988 else {
1989 /* This is a leaf, so let's add it */
1990 PA_LLIST_INSERT_AFTER(pa_alsa_setting, e->path->settings, e->path->last_setting, s);
1991
1992 e->path->last_setting = s;
1993 }
1994 }
1995
1996 return TRUE;
1997 }
1998
1999 static void path_create_settings(pa_alsa_path *p) {
2000 pa_assert(p);
2001
2002 element_create_settings(p->elements, NULL);
2003 }
2004
2005 int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t ignore_dB) {
2006 pa_alsa_element *e;
2007 double min_dB[PA_CHANNEL_POSITION_MAX], max_dB[PA_CHANNEL_POSITION_MAX];
2008 pa_channel_position_t t;
2009
2010 pa_assert(p);
2011 pa_assert(m);
2012
2013 if (p->probed)
2014 return 0;
2015
2016 pa_zero(min_dB);
2017 pa_zero(max_dB);
2018
2019 pa_log_debug("Probing path '%s'", p->name);
2020
2021 PA_LLIST_FOREACH(e, p->elements) {
2022 if (element_probe(e, m) < 0) {
2023 p->supported = FALSE;
2024 pa_log_debug("Probe of element '%s' failed.", e->alsa_name);
2025 return -1;
2026 }
2027
2028 if (ignore_dB)
2029 e->has_dB = FALSE;
2030
2031 if (e->volume_use == PA_ALSA_VOLUME_MERGE) {
2032
2033 if (!p->has_volume) {
2034 p->min_volume = e->min_volume;
2035 p->max_volume = e->max_volume;
2036 }
2037
2038 if (e->has_dB) {
2039 if (!p->has_volume) {
2040 for (t = 0; t < PA_CHANNEL_POSITION_MAX; t++)
2041 if (PA_CHANNEL_POSITION_MASK(t) & e->merged_mask) {
2042 min_dB[t] = e->min_dB;
2043 max_dB[t] = e->max_dB;
2044 }
2045
2046 p->has_dB = TRUE;
2047 } else {
2048
2049 if (p->has_dB) {
2050 for (t = 0; t < PA_CHANNEL_POSITION_MAX; t++)
2051 if (PA_CHANNEL_POSITION_MASK(t) & e->merged_mask) {
2052 min_dB[t] += e->min_dB;
2053 max_dB[t] += e->max_dB;
2054 }
2055 } else
2056 /* Hmm, there's another element before us
2057 * which cannot do dB volumes, so we we need
2058 * to 'neutralize' this slider */
2059 e->volume_use = PA_ALSA_VOLUME_ZERO;
2060 }
2061 } else if (p->has_volume)
2062 /* We can't use this volume, so let's ignore it */
2063 e->volume_use = PA_ALSA_VOLUME_IGNORE;
2064
2065 p->has_volume = TRUE;
2066 }
2067
2068 if (e->switch_use == PA_ALSA_SWITCH_MUTE)
2069 p->has_mute = TRUE;
2070 }
2071
2072 path_drop_unsupported(p);
2073 path_make_options_unique(p);
2074 path_create_settings(p);
2075
2076 p->supported = TRUE;
2077 p->probed = TRUE;
2078
2079 p->min_dB = INFINITY;
2080 p->max_dB = -INFINITY;
2081
2082 for (t = 0; t < PA_CHANNEL_POSITION_MAX; t++) {
2083 if (p->min_dB > min_dB[t])
2084 p->min_dB = min_dB[t];
2085
2086 if (p->max_dB < max_dB[t])
2087 p->max_dB = max_dB[t];
2088 }
2089
2090 return 0;
2091 }
2092
2093 void pa_alsa_setting_dump(pa_alsa_setting *s) {
2094 pa_assert(s);
2095
2096 pa_log_debug("Setting %s (%s) priority=%u",
2097 s->name,
2098 pa_strnull(s->description),
2099 s->priority);
2100 }
2101
2102 void pa_alsa_option_dump(pa_alsa_option *o) {
2103 pa_assert(o);
2104
2105 pa_log_debug("Option %s (%s/%s) index=%i, priority=%u",
2106 o->alsa_name,
2107 pa_strnull(o->name),
2108 pa_strnull(o->description),
2109 o->alsa_idx,
2110 o->priority);
2111 }
2112
2113 void pa_alsa_element_dump(pa_alsa_element *e) {
2114 pa_alsa_option *o;
2115 pa_assert(e);
2116
2117 pa_log_debug("Element %s, direction=%i, switch=%i, volume=%i, enumeration=%i, required=%i, required_absent=%i, mask=0x%llx, n_channels=%u, override_map=%s",
2118 e->alsa_name,
2119 e->direction,
2120 e->switch_use,
2121 e->volume_use,
2122 e->enumeration_use,
2123 e->required,
2124 e->required_absent,
2125 (long long unsigned) e->merged_mask,
2126 e->n_channels,
2127 pa_yes_no(e->override_map));
2128
2129 PA_LLIST_FOREACH(o, e->options)
2130 pa_alsa_option_dump(o);
2131 }
2132
2133 void pa_alsa_path_dump(pa_alsa_path *p) {
2134 pa_alsa_element *e;
2135 pa_alsa_setting *s;
2136 pa_assert(p);
2137
2138 pa_log_debug("Path %s (%s), direction=%i, priority=%u, probed=%s, supported=%s, has_mute=%s, has_volume=%s, "
2139 "has_dB=%s, min_volume=%li, max_volume=%li, min_dB=%g, max_dB=%g",
2140 p->name,
2141 pa_strnull(p->description),
2142 p->direction,
2143 p->priority,
2144 pa_yes_no(p->probed),
2145 pa_yes_no(p->supported),
2146 pa_yes_no(p->has_mute),
2147 pa_yes_no(p->has_volume),
2148 pa_yes_no(p->has_dB),
2149 p->min_volume, p->max_volume,
2150 p->min_dB, p->max_dB);
2151
2152 PA_LLIST_FOREACH(e, p->elements)
2153 pa_alsa_element_dump(e);
2154
2155 PA_LLIST_FOREACH(s, p->settings)
2156 pa_alsa_setting_dump(s);
2157 }
2158
2159 static void element_set_callback(pa_alsa_element *e, snd_mixer_t *m, snd_mixer_elem_callback_t cb, void *userdata) {
2160 snd_mixer_selem_id_t *sid;
2161 snd_mixer_elem_t *me;
2162
2163 pa_assert(e);
2164 pa_assert(m);
2165 pa_assert(cb);
2166
2167 SELEM_INIT(sid, e->alsa_name);
2168 if (!(me = snd_mixer_find_selem(m, sid))) {
2169 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
2170 return;
2171 }
2172
2173 snd_mixer_elem_set_callback(me, cb);
2174 snd_mixer_elem_set_callback_private(me, userdata);
2175 }
2176
2177 void pa_alsa_path_set_callback(pa_alsa_path *p, snd_mixer_t *m, snd_mixer_elem_callback_t cb, void *userdata) {
2178 pa_alsa_element *e;
2179
2180 pa_assert(p);
2181 pa_assert(m);
2182 pa_assert(cb);
2183
2184 PA_LLIST_FOREACH(e, p->elements)
2185 element_set_callback(e, m, cb, userdata);
2186 }
2187
2188 void pa_alsa_path_set_set_callback(pa_alsa_path_set *ps, snd_mixer_t *m, snd_mixer_elem_callback_t cb, void *userdata) {
2189 pa_alsa_path *p;
2190
2191 pa_assert(ps);
2192 pa_assert(m);
2193 pa_assert(cb);
2194
2195 PA_LLIST_FOREACH(p, ps->paths)
2196 pa_alsa_path_set_callback(p, m, cb, userdata);
2197 }
2198
2199 pa_alsa_path_set *pa_alsa_path_set_new(pa_alsa_mapping *m, pa_alsa_direction_t direction) {
2200 pa_alsa_path_set *ps;
2201 char **pn = NULL, **en = NULL, **ie;
2202
2203 pa_assert(m);
2204 pa_assert(direction == PA_ALSA_DIRECTION_OUTPUT || direction == PA_ALSA_DIRECTION_INPUT);
2205
2206 if (m->direction != PA_ALSA_DIRECTION_ANY && m->direction != direction)
2207 return NULL;
2208
2209 ps = pa_xnew0(pa_alsa_path_set, 1);
2210 ps->direction = direction;
2211
2212 if (direction == PA_ALSA_DIRECTION_OUTPUT)
2213 pn = m->output_path_names;
2214 else if (direction == PA_ALSA_DIRECTION_INPUT)
2215 pn = m->input_path_names;
2216
2217 if (pn) {
2218 char **in;
2219
2220 for (in = pn; *in; in++) {
2221 pa_alsa_path *p;
2222 pa_bool_t duplicate = FALSE;
2223 char **kn, *fn;
2224
2225 for (kn = pn; kn != in; kn++)
2226 if (pa_streq(*kn, *in)) {
2227 duplicate = TRUE;
2228 break;
2229 }
2230
2231 if (duplicate)
2232 continue;
2233
2234 fn = pa_sprintf_malloc("%s.conf", *in);
2235
2236 if ((p = pa_alsa_path_new(fn, direction))) {
2237 p->path_set = ps;
2238 PA_LLIST_INSERT_AFTER(pa_alsa_path, ps->paths, ps->last_path, p);
2239 ps->last_path = p;
2240 }
2241
2242 pa_xfree(fn);
2243 }
2244
2245 return ps;
2246 }
2247
2248 if (direction == PA_ALSA_DIRECTION_OUTPUT)
2249 en = m->output_element;
2250 else if (direction == PA_ALSA_DIRECTION_INPUT)
2251 en = m->input_element;
2252
2253 if (!en) {
2254 pa_alsa_path_set_free(ps);
2255 return NULL;
2256 }
2257
2258 for (ie = en; *ie; ie++) {
2259 char **je;
2260 pa_alsa_path *p;
2261
2262 p = pa_alsa_path_synthesize(*ie, direction);
2263 p->path_set = ps;
2264
2265 /* Mark all other passed elements for require-absent */
2266 for (je = en; *je; je++) {
2267 pa_alsa_element *e;
2268 e = pa_xnew0(pa_alsa_element, 1);
2269 e->path = p;
2270 e->alsa_name = pa_xstrdup(*je);
2271 e->direction = direction;
2272 e->required_absent = PA_ALSA_REQUIRED_ANY;
2273
2274 PA_LLIST_INSERT_AFTER(pa_alsa_element, p->elements, p->last_element, e);
2275 p->last_element = e;
2276 }
2277
2278 PA_LLIST_INSERT_AFTER(pa_alsa_path, ps->paths, ps->last_path, p);
2279 ps->last_path = p;
2280 }
2281
2282 return ps;
2283 }
2284
2285 void pa_alsa_path_set_dump(pa_alsa_path_set *ps) {
2286 pa_alsa_path *p;
2287 pa_assert(ps);
2288
2289 pa_log_debug("Path Set %p, direction=%i, probed=%s",
2290 (void*) ps,
2291 ps->direction,
2292 pa_yes_no(ps->probed));
2293
2294 PA_LLIST_FOREACH(p, ps->paths)
2295 pa_alsa_path_dump(p);
2296 }
2297
2298 static void path_set_unify(pa_alsa_path_set *ps) {
2299 pa_alsa_path *p;
2300 pa_bool_t has_dB = TRUE, has_volume = TRUE, has_mute = TRUE;
2301 pa_assert(ps);
2302
2303 /* We have issues dealing with paths that vary too wildly. That
2304 * means for now we have to have all paths support volume/mute/dB
2305 * or none. */
2306
2307 PA_LLIST_FOREACH(p, ps->paths) {
2308 pa_assert(p->probed);
2309
2310 if (!p->has_volume)
2311 has_volume = FALSE;
2312 else if (!p->has_dB)
2313 has_dB = FALSE;
2314
2315 if (!p->has_mute)
2316 has_mute = FALSE;
2317 }
2318
2319 if (!has_volume || !has_dB || !has_mute) {
2320
2321 if (!has_volume)
2322 pa_log_debug("Some paths of the device lack hardware volume control, disabling hardware control altogether.");
2323 else if (!has_dB)
2324 pa_log_debug("Some paths of the device lack dB information, disabling dB logic altogether.");
2325
2326 if (!has_mute)
2327 pa_log_debug("Some paths of the device lack hardware mute control, disabling hardware control altogether.");
2328
2329 PA_LLIST_FOREACH(p, ps->paths) {
2330 if (!has_volume)
2331 p->has_volume = FALSE;
2332 else if (!has_dB)
2333 p->has_dB = FALSE;
2334
2335 if (!has_mute)
2336 p->has_mute = FALSE;
2337 }
2338 }
2339 }
2340
2341 static void path_set_make_paths_unique(pa_alsa_path_set *ps) {
2342 pa_alsa_path *p, *q;
2343
2344 PA_LLIST_FOREACH(p, ps->paths) {
2345 unsigned i;
2346 char *m;
2347
2348 for (q = p->next; q; q = q->next)
2349 if (pa_streq(q->name, p->name))
2350 break;
2351
2352 if (!q)
2353 continue;
2354
2355 m = pa_xstrdup(p->name);
2356
2357 /* OK, this name is not unique, hence let's rename */
2358 for (i = 1, q = p; q; q = q->next) {
2359 char *nn, *nd;
2360
2361 if (!pa_streq(q->name, m))
2362 continue;
2363
2364 nn = pa_sprintf_malloc("%s-%u", m, i);
2365 pa_xfree(q->name);
2366 q->name = nn;
2367
2368 nd = pa_sprintf_malloc("%s %u", q->description, i);
2369 pa_xfree(q->description);
2370 q->description = nd;
2371
2372 i++;
2373 }
2374
2375 pa_xfree(m);
2376 }
2377 }
2378
2379 void pa_alsa_path_set_probe(pa_alsa_path_set *ps, snd_mixer_t *m, pa_bool_t ignore_dB) {
2380 pa_alsa_path *p, *n;
2381
2382 pa_assert(ps);
2383
2384 if (ps->probed)
2385 return;
2386
2387 for (p = ps->paths; p; p = n) {
2388 n = p->next;
2389
2390 if (pa_alsa_path_probe(p, m, ignore_dB) < 0) {
2391 PA_LLIST_REMOVE(pa_alsa_path, ps->paths, p);
2392 pa_alsa_path_free(p);
2393 }
2394 }
2395
2396 path_set_unify(ps);
2397 path_set_make_paths_unique(ps);
2398 ps->probed = TRUE;
2399 }
2400
2401 static void mapping_free(pa_alsa_mapping *m) {
2402 pa_assert(m);
2403
2404 pa_xfree(m->name);
2405 pa_xfree(m->description);
2406
2407 pa_xstrfreev(m->device_strings);
2408 pa_xstrfreev(m->input_path_names);
2409 pa_xstrfreev(m->output_path_names);
2410 pa_xstrfreev(m->input_element);
2411 pa_xstrfreev(m->output_element);
2412
2413 pa_assert(!m->input_pcm);
2414 pa_assert(!m->output_pcm);
2415
2416 pa_xfree(m);
2417 }
2418
2419 static void profile_free(pa_alsa_profile *p) {
2420 pa_assert(p);
2421
2422 pa_xfree(p->name);
2423 pa_xfree(p->description);
2424
2425 pa_xstrfreev(p->input_mapping_names);
2426 pa_xstrfreev(p->output_mapping_names);
2427
2428 if (p->input_mappings)
2429 pa_idxset_free(p->input_mappings, NULL, NULL);
2430
2431 if (p->output_mappings)
2432 pa_idxset_free(p->output_mappings, NULL, NULL);
2433
2434 pa_xfree(p);
2435 }
2436
2437 void pa_alsa_profile_set_free(pa_alsa_profile_set *ps) {
2438 pa_assert(ps);
2439
2440 if (ps->profiles) {
2441 pa_alsa_profile *p;
2442
2443 while ((p = pa_hashmap_steal_first(ps->profiles)))
2444 profile_free(p);
2445
2446 pa_hashmap_free(ps->profiles, NULL, NULL);
2447 }
2448
2449 if (ps->mappings) {
2450 pa_alsa_mapping *m;
2451
2452 while ((m = pa_hashmap_steal_first(ps->mappings)))
2453 mapping_free(m);
2454
2455 pa_hashmap_free(ps->mappings, NULL, NULL);
2456 }
2457
2458 pa_xfree(ps);
2459 }
2460
2461 static pa_alsa_mapping *mapping_get(pa_alsa_profile_set *ps, const char *name) {
2462 pa_alsa_mapping *m;
2463
2464 if (!pa_startswith(name, "Mapping "))
2465 return NULL;
2466
2467 name += 8;
2468
2469 if ((m = pa_hashmap_get(ps->mappings, name)))
2470 return m;
2471
2472 m = pa_xnew0(pa_alsa_mapping, 1);
2473 m->profile_set = ps;
2474 m->name = pa_xstrdup(name);
2475 pa_channel_map_init(&m->channel_map);
2476
2477 pa_hashmap_put(ps->mappings, m->name, m);
2478
2479 return m;
2480 }
2481
2482 static pa_alsa_profile *profile_get(pa_alsa_profile_set *ps, const char *name) {
2483 pa_alsa_profile *p;
2484
2485 if (!pa_startswith(name, "Profile "))
2486 return NULL;
2487
2488 name += 8;
2489
2490 if ((p = pa_hashmap_get(ps->profiles, name)))
2491 return p;
2492
2493 p = pa_xnew0(pa_alsa_profile, 1);
2494 p->profile_set = ps;
2495 p->name = pa_xstrdup(name);
2496
2497 pa_hashmap_put(ps->profiles, p->name, p);
2498
2499 return p;
2500 }
2501
2502 static int mapping_parse_device_strings(
2503 const char *filename,
2504 unsigned line,
2505 const char *section,
2506 const char *lvalue,
2507 const char *rvalue,
2508 void *data,
2509 void *userdata) {
2510
2511 pa_alsa_profile_set *ps = userdata;
2512 pa_alsa_mapping *m;
2513
2514 pa_assert(ps);
2515
2516 if (!(m = mapping_get(ps, section))) {
2517 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
2518 return -1;
2519 }
2520
2521 pa_xstrfreev(m->device_strings);
2522 if (!(m->device_strings = pa_split_spaces_strv(rvalue))) {
2523 pa_log("[%s:%u] Device string list empty of '%s'", filename, line, section);
2524 return -1;
2525 }
2526
2527 return 0;
2528 }
2529
2530 static int mapping_parse_channel_map(
2531 const char *filename,
2532 unsigned line,
2533 const char *section,
2534 const char *lvalue,
2535 const char *rvalue,
2536 void *data,
2537 void *userdata) {
2538
2539 pa_alsa_profile_set *ps = userdata;
2540 pa_alsa_mapping *m;
2541
2542 pa_assert(ps);
2543
2544 if (!(m = mapping_get(ps, section))) {
2545 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
2546 return -1;
2547 }
2548
2549 if (!(pa_channel_map_parse(&m->channel_map, rvalue))) {
2550 pa_log("[%s:%u] Channel map invalid of '%s'", filename, line, section);
2551 return -1;
2552 }
2553
2554 return 0;
2555 }
2556
2557 static int mapping_parse_paths(
2558 const char *filename,
2559 unsigned line,
2560 const char *section,
2561 const char *lvalue,
2562 const char *rvalue,
2563 void *data,
2564 void *userdata) {
2565
2566 pa_alsa_profile_set *ps = userdata;
2567 pa_alsa_mapping *m;
2568
2569 pa_assert(ps);
2570
2571 if (!(m = mapping_get(ps, section))) {
2572 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
2573 return -1;
2574 }
2575
2576 if (pa_streq(lvalue, "paths-input")) {
2577 pa_xstrfreev(m->input_path_names);
2578 m->input_path_names = pa_split_spaces_strv(rvalue);
2579 } else {
2580 pa_xstrfreev(m->output_path_names);
2581 m->output_path_names = pa_split_spaces_strv(rvalue);
2582 }
2583
2584 return 0;
2585 }
2586
2587 static int mapping_parse_element(
2588 const char *filename,
2589 unsigned line,
2590 const char *section,
2591 const char *lvalue,
2592 const char *rvalue,
2593 void *data,
2594 void *userdata) {
2595
2596 pa_alsa_profile_set *ps = userdata;
2597 pa_alsa_mapping *m;
2598
2599 pa_assert(ps);
2600
2601 if (!(m = mapping_get(ps, section))) {
2602 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
2603 return -1;
2604 }
2605
2606 if (pa_streq(lvalue, "element-input")) {
2607 pa_xstrfreev(m->input_element);
2608 m->input_element = pa_split_spaces_strv(rvalue);
2609 } else {
2610 pa_xstrfreev(m->output_element);
2611 m->output_element = pa_split_spaces_strv(rvalue);
2612 }
2613
2614 return 0;
2615 }
2616
2617 static int mapping_parse_direction(
2618 const char *filename,
2619 unsigned line,
2620 const char *section,
2621 const char *lvalue,
2622 const char *rvalue,
2623 void *data,
2624 void *userdata) {
2625
2626 pa_alsa_profile_set *ps = userdata;
2627 pa_alsa_mapping *m;
2628
2629 pa_assert(ps);
2630
2631 if (!(m = mapping_get(ps, section))) {
2632 pa_log("[%s:%u] Section name %s invalid.", filename, line, section);
2633 return -1;
2634 }
2635
2636 if (pa_streq(rvalue, "input"))
2637 m->direction = PA_ALSA_DIRECTION_INPUT;
2638 else if (pa_streq(rvalue, "output"))
2639 m->direction = PA_ALSA_DIRECTION_OUTPUT;
2640 else if (pa_streq(rvalue, "any"))
2641 m->direction = PA_ALSA_DIRECTION_ANY;
2642 else {
2643 pa_log("[%s:%u] Direction %s invalid.", filename, line, rvalue);
2644 return -1;
2645 }
2646
2647 return 0;
2648 }
2649
2650 static int mapping_parse_description(
2651 const char *filename,
2652 unsigned line,
2653 const char *section,
2654 const char *lvalue,
2655 const char *rvalue,
2656 void *data,
2657 void *userdata) {
2658
2659 pa_alsa_profile_set *ps = userdata;
2660 pa_alsa_profile *p;
2661 pa_alsa_mapping *m;
2662
2663 pa_assert(ps);
2664
2665 if ((m = mapping_get(ps, section))) {
2666 pa_xstrdup(m->description);
2667 m->description = pa_xstrdup(rvalue);
2668 } else if ((p = profile_get(ps, section))) {
2669 pa_xfree(p->description);
2670 p->description = pa_xstrdup(rvalue);
2671 } else {
2672 pa_log("[%s:%u] Section name %s invalid.", filename, line, section);
2673 return -1;
2674 }
2675
2676 return 0;
2677 }
2678
2679 static int mapping_parse_priority(
2680 const char *filename,
2681 unsigned line,
2682 const char *section,
2683 const char *lvalue,
2684 const char *rvalue,
2685 void *data,
2686 void *userdata) {
2687
2688 pa_alsa_profile_set *ps = userdata;
2689 pa_alsa_profile *p;
2690 pa_alsa_mapping *m;
2691 uint32_t prio;
2692
2693 pa_assert(ps);
2694
2695 if (pa_atou(rvalue, &prio) < 0) {
2696 pa_log("[%s:%u] Priority invalid of '%s'", filename, line, section);
2697 return -1;
2698 }
2699
2700 if ((m = mapping_get(ps, section)))
2701 m->priority = prio;
2702 else if ((p = profile_get(ps, section)))
2703 p->priority = prio;
2704 else {
2705 pa_log("[%s:%u] Section name %s invalid.", filename, line, section);
2706 return -1;
2707 }
2708
2709 return 0;
2710 }
2711
2712 static int profile_parse_mappings(
2713 const char *filename,
2714 unsigned line,
2715 const char *section,
2716 const char *lvalue,
2717 const char *rvalue,
2718 void *data,
2719 void *userdata) {
2720
2721 pa_alsa_profile_set *ps = userdata;
2722 pa_alsa_profile *p;
2723
2724 pa_assert(ps);
2725
2726 if (!(p = profile_get(ps, section))) {
2727 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
2728 return -1;
2729 }
2730
2731 if (pa_streq(lvalue, "input-mappings")) {
2732 pa_xstrfreev(p->input_mapping_names);
2733 p->input_mapping_names = pa_split_spaces_strv(rvalue);
2734 } else {
2735 pa_xstrfreev(p->output_mapping_names);
2736 p->output_mapping_names = pa_split_spaces_strv(rvalue);
2737 }
2738
2739 return 0;
2740 }
2741
2742 static int profile_parse_skip_probe(
2743 const char *filename,
2744 unsigned line,
2745 const char *section,
2746 const char *lvalue,
2747 const char *rvalue,
2748 void *data,
2749 void *userdata) {
2750
2751 pa_alsa_profile_set *ps = userdata;
2752 pa_alsa_profile *p;
2753 int b;
2754
2755 pa_assert(ps);
2756
2757 if (!(p = profile_get(ps, section))) {
2758 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
2759 return -1;
2760 }
2761
2762 if ((b = pa_parse_boolean(rvalue)) < 0) {
2763 pa_log("[%s:%u] Skip probe invalid of '%s'", filename, line, section);
2764 return -1;
2765 }
2766
2767 p->supported = b;
2768
2769 return 0;
2770 }
2771
2772 static int mapping_verify(pa_alsa_mapping *m, const pa_channel_map *bonus) {
2773
2774 static const struct description_map well_known_descriptions[] = {
2775 { "analog-mono", N_("Analog Mono") },
2776 { "analog-stereo", N_("Analog Stereo") },
2777 { "analog-surround-21", N_("Analog Surround 2.1") },
2778 { "analog-surround-30", N_("Analog Surround 3.0") },
2779 { "analog-surround-31", N_("Analog Surround 3.1") },
2780 { "analog-surround-40", N_("Analog Surround 4.0") },
2781 { "analog-surround-41", N_("Analog Surround 4.1") },
2782 { "analog-surround-50", N_("Analog Surround 5.0") },
2783 { "analog-surround-51", N_("Analog Surround 5.1") },
2784 { "analog-surround-61", N_("Analog Surround 6.0") },
2785 { "analog-surround-61", N_("Analog Surround 6.1") },
2786 { "analog-surround-70", N_("Analog Surround 7.0") },
2787 { "analog-surround-71", N_("Analog Surround 7.1") },
2788 { "iec958-stereo", N_("Digital Stereo (IEC958)") },
2789 { "iec958-surround-40", N_("Digital Surround 4.0 (IEC958)") },
2790 { "iec958-ac3-surround-40", N_("Digital Surround 4.0 (IEC958/AC3)") },
2791 { "iec958-ac3-surround-51", N_("Digital Surround 5.1 (IEC958/AC3)") },
2792 { "hdmi-stereo", N_("Digital Stereo (HDMI)") }
2793 };
2794
2795 pa_assert(m);
2796
2797 if (!pa_channel_map_valid(&m->channel_map)) {
2798 pa_log("Mapping %s is missing channel map.", m->name);
2799 return -1;
2800 }
2801
2802 if (!m->device_strings) {
2803 pa_log("Mapping %s is missing device strings.", m->name);
2804 return -1;
2805 }
2806
2807 if ((m->input_path_names && m->input_element) ||
2808 (m->output_path_names && m->output_element)) {
2809 pa_log("Mapping %s must have either mixer path or mixer elment, not both.", m->name);
2810 return -1;
2811 }
2812
2813 if (!m->description)
2814 m->description = pa_xstrdup(lookup_description(m->name,
2815 well_known_descriptions,
2816 PA_ELEMENTSOF(well_known_descriptions)));
2817
2818 if (!m->description)
2819 m->description = pa_xstrdup(m->name);
2820
2821 if (bonus) {
2822 if (pa_channel_map_equal(&m->channel_map, bonus))
2823 m->priority += 5000;
2824 else if (m->channel_map.channels == bonus->channels)
2825 m->priority += 4000;
2826 }
2827
2828 return 0;
2829 }
2830
2831 void pa_alsa_mapping_dump(pa_alsa_mapping *m) {
2832 char cm[PA_CHANNEL_MAP_SNPRINT_MAX];
2833
2834 pa_assert(m);
2835
2836 pa_log_debug("Mapping %s (%s), priority=%u, channel_map=%s, supported=%s, direction=%i",
2837 m->name,
2838 pa_strnull(m->description),
2839 m->priority,
2840 pa_channel_map_snprint(cm, sizeof(cm), &m->channel_map),
2841 pa_yes_no(m->supported),
2842 m->direction);
2843 }
2844
2845 static void profile_set_add_auto_pair(
2846 pa_alsa_profile_set *ps,
2847 pa_alsa_mapping *m, /* output */
2848 pa_alsa_mapping *n /* input */) {
2849
2850 char *name;
2851 pa_alsa_profile *p;
2852
2853 pa_assert(ps);
2854 pa_assert(m || n);
2855
2856 if (m && m->direction == PA_ALSA_DIRECTION_INPUT)
2857 return;
2858
2859 if (n && n->direction == PA_ALSA_DIRECTION_OUTPUT)
2860 return;
2861
2862 if (m && n)
2863 name = pa_sprintf_malloc("output:%s+input:%s", m->name, n->name);
2864 else if (m)
2865 name = pa_sprintf_malloc("output:%s", m->name);
2866 else
2867 name = pa_sprintf_malloc("input:%s", n->name);
2868
2869 if ((p = pa_hashmap_get(ps->profiles, name))) {
2870 pa_xfree(name);
2871 return;
2872 }
2873
2874 p = pa_xnew0(pa_alsa_profile, 1);
2875 p->profile_set = ps;
2876 p->name = name;
2877
2878 if (m) {
2879 p->output_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2880 pa_idxset_put(p->output_mappings, m, NULL);
2881 p->priority += m->priority * 100;
2882 }
2883
2884 if (n) {
2885 p->input_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2886 pa_idxset_put(p->input_mappings, n, NULL);
2887 p->priority += n->priority;
2888 }
2889
2890 pa_hashmap_put(ps->profiles, p->name, p);
2891 }
2892
2893 static void profile_set_add_auto(pa_alsa_profile_set *ps) {
2894 pa_alsa_mapping *m, *n;
2895 void *m_state, *n_state;
2896
2897 pa_assert(ps);
2898
2899 PA_HASHMAP_FOREACH(m, ps->mappings, m_state) {
2900 profile_set_add_auto_pair(ps, m, NULL);
2901
2902 PA_HASHMAP_FOREACH(n, ps->mappings, n_state)
2903 profile_set_add_auto_pair(ps, m, n);
2904 }
2905
2906 PA_HASHMAP_FOREACH(n, ps->mappings, n_state)
2907 profile_set_add_auto_pair(ps, NULL, n);
2908 }
2909
2910 static int profile_verify(pa_alsa_profile *p) {
2911
2912 static const struct description_map well_known_descriptions[] = {
2913 { "output:analog-mono+input:analog-mono", N_("Analog Mono Duplex") },
2914 { "output:analog-stereo+input:analog-stereo", N_("Analog Stereo Duplex") },
2915 { "output:iec958-stereo", N_("Digital Stereo Duplex (IEC958)") },
2916 { "off", N_("Off") }
2917 };
2918
2919 pa_assert(p);
2920
2921 /* Replace the output mapping names by the actual mappings */
2922 if (p->output_mapping_names) {
2923 char **name;
2924
2925 pa_assert(!p->output_mappings);
2926 p->output_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2927
2928 for (name = p->output_mapping_names; *name; name++) {
2929 pa_alsa_mapping *m;
2930 char **in;
2931 pa_bool_t duplicate = FALSE;
2932
2933 for (in = p->output_mapping_names; *in; in++)
2934 if (pa_streq(*name, *in)) {
2935 duplicate = TRUE;
2936 break;
2937 }
2938
2939 if (duplicate)
2940 continue;
2941
2942 if (!(m = pa_hashmap_get(p->profile_set->mappings, *name)) || m->direction == PA_ALSA_DIRECTION_INPUT) {
2943 pa_log("Profile '%s' refers to unexistant mapping '%s'.", p->name, *name);
2944 return -1;
2945 }
2946
2947 pa_idxset_put(p->output_mappings, m, NULL);
2948 }
2949
2950 pa_xstrfreev(p->output_mapping_names);
2951 p->output_mapping_names = NULL;
2952 }
2953
2954 /* Replace the input mapping names by the actual mappings */
2955 if (p->input_mapping_names) {
2956 char **name;
2957
2958 pa_assert(!p->input_mappings);
2959 p->input_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2960
2961 for (name = p->input_mapping_names; *name; name++) {
2962 pa_alsa_mapping *m;
2963 char **in;
2964 pa_bool_t duplicate = FALSE;
2965
2966 for (in = p->input_mapping_names; *in; in++)
2967 if (pa_streq(*name, *in)) {
2968 duplicate = TRUE;
2969 break;
2970 }
2971
2972 if (duplicate)
2973 continue;
2974
2975 if (!(m = pa_hashmap_get(p->profile_set->mappings, *name)) || m->direction == PA_ALSA_DIRECTION_OUTPUT) {
2976 pa_log("Profile '%s' refers to unexistant mapping '%s'.", p->name, *name);
2977 return -1;
2978 }
2979
2980 pa_idxset_put(p->input_mappings, m, NULL);
2981 }
2982
2983 pa_xstrfreev(p->input_mapping_names);
2984 p->input_mapping_names = NULL;
2985 }
2986
2987 if (!p->input_mappings && !p->output_mappings) {
2988 pa_log("Profile '%s' lacks mappings.", p->name);
2989 return -1;
2990 }
2991
2992 if (!p->description)
2993 p->description = pa_xstrdup(lookup_description(p->name,
2994 well_known_descriptions,
2995 PA_ELEMENTSOF(well_known_descriptions)));
2996
2997 if (!p->description) {
2998 pa_strbuf *sb;
2999 uint32_t idx;
3000 pa_alsa_mapping *m;
3001
3002 sb = pa_strbuf_new();
3003
3004 if (p->output_mappings)
3005 PA_IDXSET_FOREACH(m, p->output_mappings, idx) {
3006 if (!pa_strbuf_isempty(sb))
3007 pa_strbuf_puts(sb, " + ");
3008
3009 pa_strbuf_printf(sb, "%s Output", m->description);
3010 }
3011
3012 if (p->input_mappings)
3013 PA_IDXSET_FOREACH(m, p->input_mappings, idx) {
3014 if (!pa_strbuf_isempty(sb))
3015 pa_strbuf_puts(sb, " + ");
3016
3017 pa_strbuf_printf(sb, "%s Input", m->description);
3018 }
3019
3020 p->description = pa_strbuf_tostring_free(sb);
3021 }
3022
3023 return 0;
3024 }
3025
3026 void pa_alsa_profile_dump(pa_alsa_profile *p) {
3027 uint32_t idx;
3028 pa_alsa_mapping *m;
3029 pa_assert(p);
3030
3031 pa_log_debug("Profile %s (%s), priority=%u, supported=%s n_input_mappings=%u, n_output_mappings=%u",
3032 p->name,
3033 pa_strnull(p->description),
3034 p->priority,
3035 pa_yes_no(p->supported),
3036 p->input_mappings ? pa_idxset_size(p->input_mappings) : 0,
3037 p->output_mappings ? pa_idxset_size(p->output_mappings) : 0);
3038
3039 if (p->input_mappings)
3040 PA_IDXSET_FOREACH(m, p->input_mappings, idx)
3041 pa_log_debug("Input %s", m->name);
3042
3043 if (p->output_mappings)
3044 PA_IDXSET_FOREACH(m, p->output_mappings, idx)
3045 pa_log_debug("Output %s", m->name);
3046 }
3047
3048 pa_alsa_profile_set* pa_alsa_profile_set_new(const char *fname, const pa_channel_map *bonus) {
3049 pa_alsa_profile_set *ps;
3050 pa_alsa_profile *p;
3051 pa_alsa_mapping *m;
3052 char *fn;
3053 int r;
3054 void *state;
3055
3056 static pa_config_item items[] = {
3057 /* [General] */
3058 { "auto-profiles", pa_config_parse_bool, NULL, "General" },
3059
3060 /* [Mapping ...] */
3061 { "device-strings", mapping_parse_device_strings, NULL, NULL },
3062 { "channel-map", mapping_parse_channel_map, NULL, NULL },
3063 { "paths-input", mapping_parse_paths, NULL, NULL },
3064 { "paths-output", mapping_parse_paths, NULL, NULL },
3065 { "element-input", mapping_parse_element, NULL, NULL },
3066 { "element-output", mapping_parse_element, NULL, NULL },
3067 { "direction", mapping_parse_direction, NULL, NULL },
3068
3069 /* Shared by [Mapping ...] and [Profile ...] */
3070 { "description", mapping_parse_description, NULL, NULL },
3071 { "priority", mapping_parse_priority, NULL, NULL },
3072
3073 /* [Profile ...] */
3074 { "input-mappings", profile_parse_mappings, NULL, NULL },
3075 { "output-mappings", profile_parse_mappings, NULL, NULL },
3076 { "skip-probe", profile_parse_skip_probe, NULL, NULL },
3077 { NULL, NULL, NULL, NULL }
3078 };
3079
3080 ps = pa_xnew0(pa_alsa_profile_set, 1);
3081 ps->mappings = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
3082 ps->profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
3083
3084 items[0].data = &ps->auto_profiles;
3085
3086 if (!fname)
3087 fname = "default.conf";
3088
3089 fn = pa_maybe_prefix_path(fname, PA_ALSA_PROFILE_SETS_DIR);
3090 r = pa_config_parse(fn, NULL, items, ps);
3091 pa_xfree(fn);
3092
3093 if (r < 0)
3094 goto fail;
3095
3096 PA_HASHMAP_FOREACH(m, ps->mappings, state)
3097 if (mapping_verify(m, bonus) < 0)
3098 goto fail;
3099
3100 if (ps->auto_profiles)
3101 profile_set_add_auto(ps);
3102
3103 PA_HASHMAP_FOREACH(p, ps->profiles, state)
3104 if (profile_verify(p) < 0)
3105 goto fail;
3106
3107 return ps;
3108
3109 fail:
3110 pa_alsa_profile_set_free(ps);
3111 return NULL;
3112 }
3113
3114 void pa_alsa_profile_set_probe(pa_alsa_profile_set *ps, const char *dev_id, const pa_sample_spec *ss) {
3115 void *state;
3116 pa_alsa_profile *p, *last = NULL;
3117 pa_alsa_mapping *m;
3118
3119 pa_assert(ps);
3120 pa_assert(dev_id);
3121 pa_assert(ss);
3122
3123 if (ps->probed)
3124 return;
3125
3126 PA_HASHMAP_FOREACH(p, ps->profiles, state) {
3127 pa_sample_spec try_ss;
3128 pa_channel_map try_map;
3129 uint32_t idx;
3130
3131 /* Is this already marked that it is supported? (i.e. from the config file) */
3132 if (p->supported)
3133 continue;
3134
3135 pa_log_debug("Looking at profile %s", p->name);
3136
3137 /* Close PCMs from the last iteration we don't need anymore */
3138 if (last && last->output_mappings)
3139 PA_IDXSET_FOREACH(m, last->output_mappings, idx) {
3140
3141 if (!m->output_pcm)
3142 break;
3143
3144 if (last->supported)
3145 m->supported++;
3146
3147 if (!p->output_mappings || !pa_idxset_get_by_data(p->output_mappings, m, NULL)) {
3148 snd_pcm_close(m->output_pcm);
3149 m->output_pcm = NULL;
3150 }
3151 }
3152
3153 if (last && last->input_mappings)
3154 PA_IDXSET_FOREACH(m, last->input_mappings, idx) {
3155
3156 if (!m->input_pcm)
3157 break;
3158
3159 if (last->supported)
3160 m->supported++;
3161
3162 if (!p->input_mappings || !pa_idxset_get_by_data(p->input_mappings, m, NULL)) {
3163 snd_pcm_close(m->input_pcm);
3164 m->input_pcm = NULL;
3165 }
3166 }
3167
3168 p->supported = TRUE;
3169
3170 /* Check if we can open all new ones */
3171 if (p->output_mappings)
3172 PA_IDXSET_FOREACH(m, p->output_mappings, idx) {
3173
3174 if (m->output_pcm)
3175 continue;
3176
3177 pa_log_debug("Checking for playback on %s (%s)", m->description, m->name);
3178 try_map = m->channel_map;
3179 try_ss = *ss;
3180 try_ss.channels = try_map.channels;
3181
3182 if (!(m ->output_pcm = pa_alsa_open_by_device_string_strv(
3183 m->device_strings,
3184 dev_id,
3185 NULL,
3186 &try_ss, &try_map,
3187 SND_PCM_STREAM_PLAYBACK,
3188 NULL, NULL, 0, NULL, NULL,
3189 TRUE))) {
3190 p->supported = FALSE;
3191 break;
3192 }
3193 }
3194
3195 if (p->input_mappings && p->supported)
3196 PA_IDXSET_FOREACH(m, p->input_mappings, idx) {
3197
3198 if (m->input_pcm)
3199 continue;
3200
3201 pa_log_debug("Checking for recording on %s (%s)", m->description, m->name);
3202 try_map = m->channel_map;
3203 try_ss = *ss;
3204 try_ss.channels = try_map.channels;
3205
3206 if (!(m ->input_pcm = pa_alsa_open_by_device_string_strv(
3207 m->device_strings,
3208 dev_id,
3209 NULL,
3210 &try_ss, &try_map,
3211 SND_PCM_STREAM_CAPTURE,
3212 NULL, NULL, 0, NULL, NULL,
3213 TRUE))) {
3214 p->supported = FALSE;
3215 break;
3216 }
3217 }
3218
3219 last = p;
3220
3221 if (p->supported)
3222 pa_log_debug("Profile %s supported.", p->name);
3223 }
3224
3225 /* Clean up */
3226 if (last) {
3227 uint32_t idx;
3228
3229 if (last->output_mappings)
3230 PA_IDXSET_FOREACH(m, last->output_mappings, idx)
3231 if (m->output_pcm) {
3232
3233 if (last->supported)
3234 m->supported++;
3235
3236 snd_pcm_close(m->output_pcm);
3237 m->output_pcm = NULL;
3238 }
3239
3240 if (last->input_mappings)
3241 PA_IDXSET_FOREACH(m, last->input_mappings, idx)
3242 if (m->input_pcm) {
3243
3244 if (last->supported)
3245 m->supported++;
3246
3247 snd_pcm_close(m->input_pcm);
3248 m->input_pcm = NULL;
3249 }
3250 }
3251
3252 PA_HASHMAP_FOREACH(p, ps->profiles, state)
3253 if (!p->supported) {
3254 pa_hashmap_remove(ps->profiles, p->name);
3255 profile_free(p);
3256 }
3257
3258 PA_HASHMAP_FOREACH(m, ps->mappings, state)
3259 if (m->supported <= 0) {
3260 pa_hashmap_remove(ps->mappings, m->name);
3261 mapping_free(m);
3262 }
3263
3264 ps->probed = TRUE;
3265 }
3266
3267 void pa_alsa_profile_set_dump(pa_alsa_profile_set *ps) {
3268 pa_alsa_profile *p;
3269 pa_alsa_mapping *m;
3270 void *state;
3271
3272 pa_assert(ps);
3273
3274 pa_log_debug("Profile set %p, auto_profiles=%s, probed=%s, n_mappings=%u, n_profiles=%u",
3275 (void*)
3276 ps,
3277 pa_yes_no(ps->auto_profiles),
3278 pa_yes_no(ps->probed),
3279 pa_hashmap_size(ps->mappings),
3280 pa_hashmap_size(ps->profiles));
3281
3282 PA_HASHMAP_FOREACH(m, ps->mappings, state)
3283 pa_alsa_mapping_dump(m);
3284
3285 PA_HASHMAP_FOREACH(p, ps->profiles, state)
3286 pa_alsa_profile_dump(p);
3287 }
3288
3289 void pa_alsa_add_ports(pa_hashmap **p, pa_alsa_path_set *ps) {
3290 pa_alsa_path *path;
3291
3292 pa_assert(p);
3293 pa_assert(!*p);
3294 pa_assert(ps);
3295
3296 /* if there is no path, we don't want a port list */
3297 if (!ps->paths)
3298 return;
3299
3300 if (!ps->paths->next){
3301 pa_alsa_setting *s;
3302
3303 /* If there is only one path, but no or only one setting, then
3304 * we want a port list either */
3305 if (!ps->paths->settings || !ps->paths->settings->next)
3306 return;
3307
3308 /* Ok, there is only one path, however with multiple settings,
3309 * so let's create a port for each setting */
3310 *p = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
3311
3312 PA_LLIST_FOREACH(s, ps->paths->settings) {
3313 pa_device_port *port;
3314 pa_alsa_port_data *data;
3315
3316 port = pa_device_port_new(s->name, s->description, sizeof(pa_alsa_port_data));
3317 port->priority = s->priority;
3318
3319 data = PA_DEVICE_PORT_DATA(port);
3320 data->path = ps->paths;
3321 data->setting = s;
3322
3323 pa_hashmap_put(*p, port->name, port);
3324 }
3325
3326 } else {
3327
3328 /* We have multiple paths, so let's create a port for each
3329 * one, and each of each settings */
3330 *p = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
3331
3332 PA_LLIST_FOREACH(path, ps->paths) {
3333
3334 if (!path->settings || !path->settings->next) {
3335 pa_device_port *port;
3336 pa_alsa_port_data *data;
3337
3338 /* If there is no or just one setting we only need a
3339 * single entry */
3340
3341 port = pa_device_port_new(path->name, path->description, sizeof(pa_alsa_port_data));
3342 port->priority = path->priority * 100;
3343
3344
3345 data = PA_DEVICE_PORT_DATA(port);
3346 data->path = path;
3347 data->setting = path->settings;
3348
3349 pa_hashmap_put(*p, port->name, port);
3350 } else {
3351 pa_alsa_setting *s;
3352
3353 PA_LLIST_FOREACH(s, path->settings) {
3354 pa_device_port *port;
3355 pa_alsa_port_data *data;
3356 char *n, *d;
3357
3358 n = pa_sprintf_malloc("%s;%s", path->name, s->name);
3359
3360 if (s->description[0])
3361 d = pa_sprintf_malloc(_("%s / %s"), path->description, s->description);
3362 else
3363 d = pa_xstrdup(path->description);
3364
3365 port = pa_device_port_new(n, d, sizeof(pa_alsa_port_data));
3366 port->priority = path->priority * 100 + s->priority;
3367
3368 pa_xfree(n);
3369 pa_xfree(d);
3370
3371 data = PA_DEVICE_PORT_DATA(port);
3372 data->path = path;
3373 data->setting = s;
3374
3375 pa_hashmap_put(*p, port->name, port);
3376 }
3377 }
3378 }
3379 }
3380
3381 pa_log_debug("Added %u ports", pa_hashmap_size(*p));
3382 }