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