]> 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-mixer: Make probing elements with more than two volume channels fail.
[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 struct pa_alsa_mixer_pdata {
247 pa_rtpoll *rtpoll;
248 pa_rtpoll_item *poll_item;
249 snd_mixer_t *mixer;
250 };
251
252
253 struct pa_alsa_mixer_pdata *pa_alsa_mixer_pdata_new(void) {
254 struct pa_alsa_mixer_pdata *pd;
255
256 pd = pa_xnew0(struct pa_alsa_mixer_pdata, 1);
257
258 return pd;
259 }
260
261 void pa_alsa_mixer_pdata_free(struct pa_alsa_mixer_pdata *pd) {
262 pa_assert(pd);
263
264 if (pd->poll_item) {
265 pa_rtpoll_item_free(pd->poll_item);
266 }
267
268 pa_xfree(pd);
269 }
270
271 static int rtpoll_work_cb(pa_rtpoll_item *i) {
272 struct pa_alsa_mixer_pdata *pd;
273 struct pollfd *p;
274 unsigned n_fds;
275 unsigned short revents = 0;
276 int err;
277
278 pd = pa_rtpoll_item_get_userdata(i);
279 pa_assert_fp(pd);
280 pa_assert_fp(i == pd->poll_item);
281
282 p = pa_rtpoll_item_get_pollfd(i, &n_fds);
283
284 if ((err = snd_mixer_poll_descriptors_revents(pd->mixer, p, n_fds, &revents)) < 0) {
285 pa_log_error("Unable to get poll revent: %s", pa_alsa_strerror(err));
286 pa_rtpoll_item_free(i);
287 return -1;
288 }
289
290 if (revents) {
291 snd_mixer_handle_events(pd->mixer);
292 pa_rtpoll_item_free(i);
293 pa_alsa_set_mixer_rtpoll(pd, pd->mixer, pd->rtpoll);
294 }
295
296 return 0;
297 }
298
299 int pa_alsa_set_mixer_rtpoll(struct pa_alsa_mixer_pdata *pd, snd_mixer_t *mixer, pa_rtpoll *rtp) {
300 pa_rtpoll_item *i;
301 struct pollfd *p;
302 int err, n;
303
304 pa_assert(pd);
305 pa_assert(mixer);
306 pa_assert(rtp);
307
308 if ((n = snd_mixer_poll_descriptors_count(mixer)) < 0) {
309 pa_log("snd_mixer_poll_descriptors_count() failed: %s", pa_alsa_strerror(n));
310 return -1;
311 }
312
313 i = pa_rtpoll_item_new(rtp, PA_RTPOLL_LATE, (unsigned) n);
314
315 p = pa_rtpoll_item_get_pollfd(i, NULL);
316
317 memset(p, 0, sizeof(struct pollfd) * n);
318
319 if ((err = snd_mixer_poll_descriptors(mixer, p, (unsigned) n)) < 0) {
320 pa_log_error("Unable to get poll descriptors: %s", pa_alsa_strerror(err));
321 pa_rtpoll_item_free(i);
322 return -1;
323 }
324
325 pd->rtpoll = rtp;
326 pd->poll_item = i;
327 pd->mixer = mixer;
328
329 pa_rtpoll_item_set_userdata(i, pd);
330 pa_rtpoll_item_set_work_callback(i, rtpoll_work_cb);
331
332 return 0;
333 }
334
335 static int prepare_mixer(snd_mixer_t *mixer, const char *dev) {
336 int err;
337
338 pa_assert(mixer);
339 pa_assert(dev);
340
341 if ((err = snd_mixer_attach(mixer, dev)) < 0) {
342 pa_log_info("Unable to attach to mixer %s: %s", dev, pa_alsa_strerror(err));
343 return -1;
344 }
345
346 if ((err = snd_mixer_selem_register(mixer, NULL, NULL)) < 0) {
347 pa_log_warn("Unable to register mixer: %s", pa_alsa_strerror(err));
348 return -1;
349 }
350
351 if ((err = snd_mixer_load(mixer)) < 0) {
352 pa_log_warn("Unable to load mixer: %s", pa_alsa_strerror(err));
353 return -1;
354 }
355
356 pa_log_info("Successfully attached to mixer '%s'", dev);
357 return 0;
358 }
359
360 snd_mixer_t *pa_alsa_open_mixer_for_pcm(snd_pcm_t *pcm, char **ctl_device) {
361 int err;
362 snd_mixer_t *m;
363 const char *dev;
364 snd_pcm_info_t* info;
365 snd_pcm_info_alloca(&info);
366
367 pa_assert(pcm);
368
369 if ((err = snd_mixer_open(&m, 0)) < 0) {
370 pa_log("Error opening mixer: %s", pa_alsa_strerror(err));
371 return NULL;
372 }
373
374 /* First, try by name */
375 if ((dev = snd_pcm_name(pcm)))
376 if (prepare_mixer(m, dev) >= 0) {
377 if (ctl_device)
378 *ctl_device = pa_xstrdup(dev);
379
380 return m;
381 }
382
383 /* Then, try by card index */
384 if (snd_pcm_info(pcm, info) >= 0) {
385 char *md;
386 int card_idx;
387
388 if ((card_idx = snd_pcm_info_get_card(info)) >= 0) {
389
390 md = pa_sprintf_malloc("hw:%i", card_idx);
391
392 if (!dev || !pa_streq(dev, md))
393 if (prepare_mixer(m, md) >= 0) {
394
395 if (ctl_device)
396 *ctl_device = md;
397 else
398 pa_xfree(md);
399
400 return m;
401 }
402
403 pa_xfree(md);
404 }
405 }
406
407 snd_mixer_close(m);
408 return NULL;
409 }
410
411 static const snd_mixer_selem_channel_id_t alsa_channel_ids[PA_CHANNEL_POSITION_MAX] = {
412 [PA_CHANNEL_POSITION_MONO] = SND_MIXER_SCHN_MONO, /* The ALSA name is just an alias! */
413
414 [PA_CHANNEL_POSITION_FRONT_CENTER] = SND_MIXER_SCHN_FRONT_CENTER,
415 [PA_CHANNEL_POSITION_FRONT_LEFT] = SND_MIXER_SCHN_FRONT_LEFT,
416 [PA_CHANNEL_POSITION_FRONT_RIGHT] = SND_MIXER_SCHN_FRONT_RIGHT,
417
418 [PA_CHANNEL_POSITION_REAR_CENTER] = SND_MIXER_SCHN_REAR_CENTER,
419 [PA_CHANNEL_POSITION_REAR_LEFT] = SND_MIXER_SCHN_REAR_LEFT,
420 [PA_CHANNEL_POSITION_REAR_RIGHT] = SND_MIXER_SCHN_REAR_RIGHT,
421
422 [PA_CHANNEL_POSITION_LFE] = SND_MIXER_SCHN_WOOFER,
423
424 [PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER] = SND_MIXER_SCHN_UNKNOWN,
425 [PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER] = SND_MIXER_SCHN_UNKNOWN,
426
427 [PA_CHANNEL_POSITION_SIDE_LEFT] = SND_MIXER_SCHN_SIDE_LEFT,
428 [PA_CHANNEL_POSITION_SIDE_RIGHT] = SND_MIXER_SCHN_SIDE_RIGHT,
429
430 [PA_CHANNEL_POSITION_AUX0] = SND_MIXER_SCHN_UNKNOWN,
431 [PA_CHANNEL_POSITION_AUX1] = SND_MIXER_SCHN_UNKNOWN,
432 [PA_CHANNEL_POSITION_AUX2] = SND_MIXER_SCHN_UNKNOWN,
433 [PA_CHANNEL_POSITION_AUX3] = SND_MIXER_SCHN_UNKNOWN,
434 [PA_CHANNEL_POSITION_AUX4] = SND_MIXER_SCHN_UNKNOWN,
435 [PA_CHANNEL_POSITION_AUX5] = SND_MIXER_SCHN_UNKNOWN,
436 [PA_CHANNEL_POSITION_AUX6] = SND_MIXER_SCHN_UNKNOWN,
437 [PA_CHANNEL_POSITION_AUX7] = SND_MIXER_SCHN_UNKNOWN,
438 [PA_CHANNEL_POSITION_AUX8] = SND_MIXER_SCHN_UNKNOWN,
439 [PA_CHANNEL_POSITION_AUX9] = SND_MIXER_SCHN_UNKNOWN,
440 [PA_CHANNEL_POSITION_AUX10] = SND_MIXER_SCHN_UNKNOWN,
441 [PA_CHANNEL_POSITION_AUX11] = SND_MIXER_SCHN_UNKNOWN,
442 [PA_CHANNEL_POSITION_AUX12] = SND_MIXER_SCHN_UNKNOWN,
443 [PA_CHANNEL_POSITION_AUX13] = SND_MIXER_SCHN_UNKNOWN,
444 [PA_CHANNEL_POSITION_AUX14] = SND_MIXER_SCHN_UNKNOWN,
445 [PA_CHANNEL_POSITION_AUX15] = SND_MIXER_SCHN_UNKNOWN,
446 [PA_CHANNEL_POSITION_AUX16] = SND_MIXER_SCHN_UNKNOWN,
447 [PA_CHANNEL_POSITION_AUX17] = SND_MIXER_SCHN_UNKNOWN,
448 [PA_CHANNEL_POSITION_AUX18] = SND_MIXER_SCHN_UNKNOWN,
449 [PA_CHANNEL_POSITION_AUX19] = SND_MIXER_SCHN_UNKNOWN,
450 [PA_CHANNEL_POSITION_AUX20] = SND_MIXER_SCHN_UNKNOWN,
451 [PA_CHANNEL_POSITION_AUX21] = SND_MIXER_SCHN_UNKNOWN,
452 [PA_CHANNEL_POSITION_AUX22] = SND_MIXER_SCHN_UNKNOWN,
453 [PA_CHANNEL_POSITION_AUX23] = SND_MIXER_SCHN_UNKNOWN,
454 [PA_CHANNEL_POSITION_AUX24] = SND_MIXER_SCHN_UNKNOWN,
455 [PA_CHANNEL_POSITION_AUX25] = SND_MIXER_SCHN_UNKNOWN,
456 [PA_CHANNEL_POSITION_AUX26] = SND_MIXER_SCHN_UNKNOWN,
457 [PA_CHANNEL_POSITION_AUX27] = SND_MIXER_SCHN_UNKNOWN,
458 [PA_CHANNEL_POSITION_AUX28] = SND_MIXER_SCHN_UNKNOWN,
459 [PA_CHANNEL_POSITION_AUX29] = SND_MIXER_SCHN_UNKNOWN,
460 [PA_CHANNEL_POSITION_AUX30] = SND_MIXER_SCHN_UNKNOWN,
461 [PA_CHANNEL_POSITION_AUX31] = SND_MIXER_SCHN_UNKNOWN,
462
463 [PA_CHANNEL_POSITION_TOP_CENTER] = SND_MIXER_SCHN_UNKNOWN,
464
465 [PA_CHANNEL_POSITION_TOP_FRONT_CENTER] = SND_MIXER_SCHN_UNKNOWN,
466 [PA_CHANNEL_POSITION_TOP_FRONT_LEFT] = SND_MIXER_SCHN_UNKNOWN,
467 [PA_CHANNEL_POSITION_TOP_FRONT_RIGHT] = SND_MIXER_SCHN_UNKNOWN,
468
469 [PA_CHANNEL_POSITION_TOP_REAR_CENTER] = SND_MIXER_SCHN_UNKNOWN,
470 [PA_CHANNEL_POSITION_TOP_REAR_LEFT] = SND_MIXER_SCHN_UNKNOWN,
471 [PA_CHANNEL_POSITION_TOP_REAR_RIGHT] = SND_MIXER_SCHN_UNKNOWN
472 };
473
474 static void setting_free(pa_alsa_setting *s) {
475 pa_assert(s);
476
477 if (s->options)
478 pa_idxset_free(s->options, NULL, NULL);
479
480 pa_xfree(s->name);
481 pa_xfree(s->description);
482 pa_xfree(s);
483 }
484
485 static void option_free(pa_alsa_option *o) {
486 pa_assert(o);
487
488 pa_xfree(o->alsa_name);
489 pa_xfree(o->name);
490 pa_xfree(o->description);
491 pa_xfree(o);
492 }
493
494 static void decibel_fix_free(pa_alsa_decibel_fix *db_fix) {
495 pa_assert(db_fix);
496
497 pa_xfree(db_fix->name);
498 pa_xfree(db_fix->db_values);
499
500 pa_xfree(db_fix);
501 }
502
503 static void element_free(pa_alsa_element *e) {
504 pa_alsa_option *o;
505 pa_assert(e);
506
507 while ((o = e->options)) {
508 PA_LLIST_REMOVE(pa_alsa_option, e->options, o);
509 option_free(o);
510 }
511
512 if (e->db_fix)
513 decibel_fix_free(e->db_fix);
514
515 pa_xfree(e->alsa_name);
516 pa_xfree(e);
517 }
518
519 void pa_alsa_path_free(pa_alsa_path *p) {
520 pa_alsa_element *e;
521 pa_alsa_setting *s;
522
523 pa_assert(p);
524
525 while ((e = p->elements)) {
526 PA_LLIST_REMOVE(pa_alsa_element, p->elements, e);
527 element_free(e);
528 }
529
530 while ((s = p->settings)) {
531 PA_LLIST_REMOVE(pa_alsa_setting, p->settings, s);
532 setting_free(s);
533 }
534
535 pa_xfree(p->name);
536 pa_xfree(p->description);
537 pa_xfree(p);
538 }
539
540 void pa_alsa_path_set_free(pa_alsa_path_set *ps) {
541 pa_alsa_path *p;
542 pa_assert(ps);
543
544 while ((p = ps->paths)) {
545 PA_LLIST_REMOVE(pa_alsa_path, ps->paths, p);
546 pa_alsa_path_free(p);
547 }
548
549 pa_xfree(ps);
550 }
551
552 static long to_alsa_dB(pa_volume_t v) {
553 return (long) (pa_sw_volume_to_dB(v) * 100.0);
554 }
555
556 static pa_volume_t from_alsa_dB(long v) {
557 return pa_sw_volume_from_dB((double) v / 100.0);
558 }
559
560 static long to_alsa_volume(pa_volume_t v, long min, long max) {
561 long w;
562
563 w = (long) round(((double) v * (double) (max - min)) / PA_VOLUME_NORM) + min;
564 return PA_CLAMP_UNLIKELY(w, min, max);
565 }
566
567 static pa_volume_t from_alsa_volume(long v, long min, long max) {
568 return (pa_volume_t) round(((double) (v - min) * PA_VOLUME_NORM) / (double) (max - min));
569 }
570
571 #define SELEM_INIT(sid, name) \
572 do { \
573 snd_mixer_selem_id_alloca(&(sid)); \
574 snd_mixer_selem_id_set_name((sid), (name)); \
575 snd_mixer_selem_id_set_index((sid), 0); \
576 } while(FALSE)
577
578 static int element_get_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v) {
579 snd_mixer_selem_id_t *sid;
580 snd_mixer_elem_t *me;
581 snd_mixer_selem_channel_id_t c;
582 pa_channel_position_mask_t mask = 0;
583 unsigned k;
584
585 pa_assert(m);
586 pa_assert(e);
587 pa_assert(cm);
588 pa_assert(v);
589
590 SELEM_INIT(sid, e->alsa_name);
591 if (!(me = snd_mixer_find_selem(m, sid))) {
592 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
593 return -1;
594 }
595
596 pa_cvolume_mute(v, cm->channels);
597
598 /* We take the highest volume of all channels that match */
599
600 for (c = 0; c <= SND_MIXER_SCHN_LAST; c++) {
601 int r;
602 pa_volume_t f;
603
604 if (e->has_dB) {
605 long value = 0;
606
607 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
608 if (snd_mixer_selem_has_playback_channel(me, c)) {
609 if (e->db_fix) {
610 if ((r = snd_mixer_selem_get_playback_volume(me, c, &value)) >= 0) {
611 /* If the channel volume is outside the limits set
612 * by the dB fix, we clamp the hw volume to be
613 * within the limits. */
614 if (value < e->db_fix->min_step) {
615 value = e->db_fix->min_step;
616 snd_mixer_selem_set_playback_volume(me, c, value);
617 pa_log_debug("Playback volume for element %s channel %i was below the dB fix limit. "
618 "Volume reset to %0.2f dB.", e->alsa_name, c,
619 e->db_fix->db_values[value - e->db_fix->min_step] / 100.0);
620 } else if (value > e->db_fix->max_step) {
621 value = e->db_fix->max_step;
622 snd_mixer_selem_set_playback_volume(me, c, value);
623 pa_log_debug("Playback volume for element %s channel %i was over the dB fix limit. "
624 "Volume reset to %0.2f dB.", e->alsa_name, c,
625 e->db_fix->db_values[value - e->db_fix->min_step] / 100.0);
626 }
627
628 /* Volume step -> dB value conversion. */
629 value = e->db_fix->db_values[value - e->db_fix->min_step];
630 }
631 } else
632 r = snd_mixer_selem_get_playback_dB(me, c, &value);
633 } else
634 r = -1;
635 } else {
636 if (snd_mixer_selem_has_capture_channel(me, c)) {
637 if (e->db_fix) {
638 if ((r = snd_mixer_selem_get_capture_volume(me, c, &value)) >= 0) {
639 /* If the channel volume is outside the limits set
640 * by the dB fix, we clamp the hw volume to be
641 * within the limits. */
642 if (value < e->db_fix->min_step) {
643 value = e->db_fix->min_step;
644 snd_mixer_selem_set_capture_volume(me, c, value);
645 pa_log_debug("Capture volume for element %s channel %i was below the dB fix limit. "
646 "Volume reset to %0.2f dB.", e->alsa_name, c,
647 e->db_fix->db_values[value - e->db_fix->min_step] / 100.0);
648 } else if (value > e->db_fix->max_step) {
649 value = e->db_fix->max_step;
650 snd_mixer_selem_set_capture_volume(me, c, value);
651 pa_log_debug("Capture volume for element %s channel %i was over the dB fix limit. "
652 "Volume reset to %0.2f dB.", e->alsa_name, c,
653 e->db_fix->db_values[value - e->db_fix->min_step] / 100.0);
654 }
655
656 /* Volume step -> dB value conversion. */
657 value = e->db_fix->db_values[value - e->db_fix->min_step];
658 }
659 } else
660 r = snd_mixer_selem_get_capture_dB(me, c, &value);
661 } else
662 r = -1;
663 }
664
665 if (r < 0)
666 continue;
667
668 #ifdef HAVE_VALGRIND_MEMCHECK_H
669 VALGRIND_MAKE_MEM_DEFINED(&value, sizeof(value));
670 #endif
671
672 f = from_alsa_dB(value);
673
674 } else {
675 long value = 0;
676
677 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
678 if (snd_mixer_selem_has_playback_channel(me, c))
679 r = snd_mixer_selem_get_playback_volume(me, c, &value);
680 else
681 r = -1;
682 } else {
683 if (snd_mixer_selem_has_capture_channel(me, c))
684 r = snd_mixer_selem_get_capture_volume(me, c, &value);
685 else
686 r = -1;
687 }
688
689 if (r < 0)
690 continue;
691
692 f = from_alsa_volume(value, e->min_volume, e->max_volume);
693 }
694
695 for (k = 0; k < cm->channels; k++)
696 if (e->masks[c][e->n_channels-1] & PA_CHANNEL_POSITION_MASK(cm->map[k]))
697 if (v->values[k] < f)
698 v->values[k] = f;
699
700 mask |= e->masks[c][e->n_channels-1];
701 }
702
703 for (k = 0; k < cm->channels; k++)
704 if (!(mask & PA_CHANNEL_POSITION_MASK(cm->map[k])))
705 v->values[k] = PA_VOLUME_NORM;
706
707 return 0;
708 }
709
710 int pa_alsa_path_get_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v) {
711 pa_alsa_element *e;
712
713 pa_assert(m);
714 pa_assert(p);
715 pa_assert(cm);
716 pa_assert(v);
717
718 if (!p->has_volume)
719 return -1;
720
721 pa_cvolume_reset(v, cm->channels);
722
723 PA_LLIST_FOREACH(e, p->elements) {
724 pa_cvolume ev;
725
726 if (e->volume_use != PA_ALSA_VOLUME_MERGE)
727 continue;
728
729 pa_assert(!p->has_dB || e->has_dB);
730
731 if (element_get_volume(e, m, cm, &ev) < 0)
732 return -1;
733
734 /* If we have no dB information all we can do is take the first element and leave */
735 if (!p->has_dB) {
736 *v = ev;
737 return 0;
738 }
739
740 pa_sw_cvolume_multiply(v, v, &ev);
741 }
742
743 return 0;
744 }
745
746 static int element_get_switch(pa_alsa_element *e, snd_mixer_t *m, pa_bool_t *b) {
747 snd_mixer_selem_id_t *sid;
748 snd_mixer_elem_t *me;
749 snd_mixer_selem_channel_id_t c;
750
751 pa_assert(m);
752 pa_assert(e);
753 pa_assert(b);
754
755 SELEM_INIT(sid, e->alsa_name);
756 if (!(me = snd_mixer_find_selem(m, sid))) {
757 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
758 return -1;
759 }
760
761 /* We return muted if at least one channel is muted */
762
763 for (c = 0; c <= SND_MIXER_SCHN_LAST; c++) {
764 int r;
765 int value = 0;
766
767 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
768 if (snd_mixer_selem_has_playback_channel(me, c))
769 r = snd_mixer_selem_get_playback_switch(me, c, &value);
770 else
771 r = -1;
772 } else {
773 if (snd_mixer_selem_has_capture_channel(me, c))
774 r = snd_mixer_selem_get_capture_switch(me, c, &value);
775 else
776 r = -1;
777 }
778
779 if (r < 0)
780 continue;
781
782 if (!value) {
783 *b = FALSE;
784 return 0;
785 }
786 }
787
788 *b = TRUE;
789 return 0;
790 }
791
792 int pa_alsa_path_get_mute(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t *muted) {
793 pa_alsa_element *e;
794
795 pa_assert(m);
796 pa_assert(p);
797 pa_assert(muted);
798
799 if (!p->has_mute)
800 return -1;
801
802 PA_LLIST_FOREACH(e, p->elements) {
803 pa_bool_t b;
804
805 if (e->switch_use != PA_ALSA_SWITCH_MUTE)
806 continue;
807
808 if (element_get_switch(e, m, &b) < 0)
809 return -1;
810
811 if (!b) {
812 *muted = TRUE;
813 return 0;
814 }
815 }
816
817 *muted = FALSE;
818 return 0;
819 }
820
821 /* Finds the closest item in db_fix->db_values and returns the corresponding
822 * step. *db_value is replaced with the value from the db_values table.
823 * Rounding is done based on the rounding parameter: -1 means rounding down and
824 * +1 means rounding up. */
825 static long decibel_fix_get_step(pa_alsa_decibel_fix *db_fix, long *db_value, int rounding) {
826 unsigned i = 0;
827 unsigned max_i = 0;
828
829 pa_assert(db_fix);
830 pa_assert(db_value);
831 pa_assert(rounding != 0);
832
833 max_i = db_fix->max_step - db_fix->min_step;
834
835 if (rounding > 0) {
836 for (i = 0; i < max_i; i++) {
837 if (db_fix->db_values[i] >= *db_value)
838 break;
839 }
840 } else {
841 for (i = 0; i < max_i; i++) {
842 if (db_fix->db_values[i + 1] > *db_value)
843 break;
844 }
845 }
846
847 *db_value = db_fix->db_values[i];
848
849 return i + db_fix->min_step;
850 }
851
852 static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, pa_bool_t write_to_hw) {
853
854 snd_mixer_selem_id_t *sid;
855 pa_cvolume rv;
856 snd_mixer_elem_t *me;
857 snd_mixer_selem_channel_id_t c;
858 pa_channel_position_mask_t mask = 0;
859 unsigned k;
860
861 pa_assert(m);
862 pa_assert(e);
863 pa_assert(cm);
864 pa_assert(v);
865 pa_assert(pa_cvolume_compatible_with_channel_map(v, cm));
866
867 SELEM_INIT(sid, e->alsa_name);
868 if (!(me = snd_mixer_find_selem(m, sid))) {
869 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
870 return -1;
871 }
872
873 pa_cvolume_mute(&rv, cm->channels);
874
875 for (c = 0; c <= SND_MIXER_SCHN_LAST; c++) {
876 int r;
877 pa_volume_t f = PA_VOLUME_MUTED;
878 pa_bool_t found = FALSE;
879
880 for (k = 0; k < cm->channels; k++)
881 if (e->masks[c][e->n_channels-1] & PA_CHANNEL_POSITION_MASK(cm->map[k])) {
882 found = TRUE;
883 if (v->values[k] > f)
884 f = v->values[k];
885 }
886
887 if (!found) {
888 /* Hmm, so this channel does not exist in the volume
889 * struct, so let's bind it to the overall max of the
890 * volume. */
891 f = pa_cvolume_max(v);
892 }
893
894 if (e->has_dB) {
895 long value = to_alsa_dB(f);
896 int rounding = value > 0 ? -1 : +1;
897
898 if (e->volume_limit >= 0 && value > (e->max_dB * 100))
899 value = e->max_dB * 100;
900
901 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
902 /* If we call set_playback_volume() without checking first
903 * if the channel is available, ALSA behaves very
904 * strangely and doesn't fail the call */
905 if (snd_mixer_selem_has_playback_channel(me, c)) {
906 if (e->db_fix) {
907 if (write_to_hw)
908 r = snd_mixer_selem_set_playback_volume(me, c, decibel_fix_get_step(e->db_fix, &value, rounding));
909 else {
910 decibel_fix_get_step(e->db_fix, &value, rounding);
911 r = 0;
912 }
913
914 } else {
915 if (write_to_hw) {
916 if ((r = snd_mixer_selem_set_playback_dB(me, c, value, rounding)) >= 0)
917 r = snd_mixer_selem_get_playback_dB(me, c, &value);
918 } else {
919 long alsa_val;
920 if ((r = snd_mixer_selem_ask_playback_dB_vol(me, value, rounding, &alsa_val)) >= 0)
921 r = snd_mixer_selem_ask_playback_vol_dB(me, alsa_val, &value);
922 }
923 }
924 } else
925 r = -1;
926 } else {
927 if (snd_mixer_selem_has_capture_channel(me, c)) {
928 if (e->db_fix) {
929 if (write_to_hw)
930 r = snd_mixer_selem_set_capture_volume(me, c, decibel_fix_get_step(e->db_fix, &value, rounding));
931 else {
932 decibel_fix_get_step(e->db_fix, &value, rounding);
933 r = 0;
934 }
935
936 } else {
937 if (write_to_hw) {
938 if ((r = snd_mixer_selem_set_capture_dB(me, c, value, rounding)) >= 0)
939 r = snd_mixer_selem_get_capture_dB(me, c, &value);
940 } else {
941 long alsa_val;
942 if ((r = snd_mixer_selem_ask_capture_dB_vol(me, value, rounding, &alsa_val)) >= 0)
943 r = snd_mixer_selem_ask_capture_vol_dB(me, alsa_val, &value);
944 }
945 }
946 } else
947 r = -1;
948 }
949
950 if (r < 0)
951 continue;
952
953 #ifdef HAVE_VALGRIND_MEMCHECK_H
954 VALGRIND_MAKE_MEM_DEFINED(&value, sizeof(value));
955 #endif
956
957 f = from_alsa_dB(value);
958
959 } else {
960 long value;
961
962 value = to_alsa_volume(f, e->min_volume, e->max_volume);
963
964 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
965 if (snd_mixer_selem_has_playback_channel(me, c)) {
966 if ((r = snd_mixer_selem_set_playback_volume(me, c, value)) >= 0)
967 r = snd_mixer_selem_get_playback_volume(me, c, &value);
968 } else
969 r = -1;
970 } else {
971 if (snd_mixer_selem_has_capture_channel(me, c)) {
972 if ((r = snd_mixer_selem_set_capture_volume(me, c, value)) >= 0)
973 r = snd_mixer_selem_get_capture_volume(me, c, &value);
974 } else
975 r = -1;
976 }
977
978 if (r < 0)
979 continue;
980
981 f = from_alsa_volume(value, e->min_volume, e->max_volume);
982 }
983
984 for (k = 0; k < cm->channels; k++)
985 if (e->masks[c][e->n_channels-1] & PA_CHANNEL_POSITION_MASK(cm->map[k]))
986 if (rv.values[k] < f)
987 rv.values[k] = f;
988
989 mask |= e->masks[c][e->n_channels-1];
990 }
991
992 for (k = 0; k < cm->channels; k++)
993 if (!(mask & PA_CHANNEL_POSITION_MASK(cm->map[k])))
994 rv.values[k] = PA_VOLUME_NORM;
995
996 *v = rv;
997 return 0;
998 }
999
1000 int pa_alsa_path_set_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, pa_bool_t write_to_hw) {
1001
1002 pa_alsa_element *e;
1003 pa_cvolume rv;
1004
1005 pa_assert(m);
1006 pa_assert(p);
1007 pa_assert(cm);
1008 pa_assert(v);
1009 pa_assert(pa_cvolume_compatible_with_channel_map(v, cm));
1010
1011 if (!p->has_volume)
1012 return -1;
1013
1014 rv = *v; /* Remaining adjustment */
1015 pa_cvolume_reset(v, cm->channels); /* Adjustment done */
1016
1017 PA_LLIST_FOREACH(e, p->elements) {
1018 pa_cvolume ev;
1019
1020 if (e->volume_use != PA_ALSA_VOLUME_MERGE)
1021 continue;
1022
1023 pa_assert(!p->has_dB || e->has_dB);
1024
1025 ev = rv;
1026 if (element_set_volume(e, m, cm, &ev, write_to_hw) < 0)
1027 return -1;
1028
1029 if (!p->has_dB) {
1030 *v = ev;
1031 return 0;
1032 }
1033
1034 pa_sw_cvolume_multiply(v, v, &ev);
1035 pa_sw_cvolume_divide(&rv, &rv, &ev);
1036 }
1037
1038 return 0;
1039 }
1040
1041 static int element_set_switch(pa_alsa_element *e, snd_mixer_t *m, pa_bool_t b) {
1042 snd_mixer_elem_t *me;
1043 snd_mixer_selem_id_t *sid;
1044 int r;
1045
1046 pa_assert(m);
1047 pa_assert(e);
1048
1049 SELEM_INIT(sid, e->alsa_name);
1050 if (!(me = snd_mixer_find_selem(m, sid))) {
1051 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
1052 return -1;
1053 }
1054
1055 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1056 r = snd_mixer_selem_set_playback_switch_all(me, b);
1057 else
1058 r = snd_mixer_selem_set_capture_switch_all(me, b);
1059
1060 if (r < 0)
1061 pa_log_warn("Failed to set switch of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
1062
1063 return r;
1064 }
1065
1066 int pa_alsa_path_set_mute(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t muted) {
1067 pa_alsa_element *e;
1068
1069 pa_assert(m);
1070 pa_assert(p);
1071
1072 if (!p->has_mute)
1073 return -1;
1074
1075 PA_LLIST_FOREACH(e, p->elements) {
1076
1077 if (e->switch_use != PA_ALSA_SWITCH_MUTE)
1078 continue;
1079
1080 if (element_set_switch(e, m, !muted) < 0)
1081 return -1;
1082 }
1083
1084 return 0;
1085 }
1086
1087 /* Depending on whether e->volume_use is _OFF, _ZERO or _CONSTANT, this
1088 * function sets all channels of the volume element to e->min_volume, 0 dB or
1089 * e->constant_volume. */
1090 static int element_set_constant_volume(pa_alsa_element *e, snd_mixer_t *m) {
1091 snd_mixer_elem_t *me = NULL;
1092 snd_mixer_selem_id_t *sid = NULL;
1093 int r = 0;
1094 long volume = -1;
1095
1096 pa_assert(m);
1097 pa_assert(e);
1098
1099 SELEM_INIT(sid, e->alsa_name);
1100 if (!(me = snd_mixer_find_selem(m, sid))) {
1101 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
1102 return -1;
1103 }
1104
1105 switch (e->volume_use) {
1106 case PA_ALSA_VOLUME_OFF:
1107 volume = e->min_volume;
1108 break;
1109
1110 case PA_ALSA_VOLUME_ZERO:
1111 if (e->db_fix) {
1112 long dB = 0;
1113
1114 volume = decibel_fix_get_step(e->db_fix, &dB, +1);
1115 }
1116 break;
1117
1118 case PA_ALSA_VOLUME_CONSTANT:
1119 volume = e->constant_volume;
1120 break;
1121
1122 default:
1123 pa_assert_not_reached();
1124 }
1125
1126 if (volume >= 0) {
1127 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1128 r = snd_mixer_selem_set_playback_volume_all(me, volume);
1129 else
1130 r = snd_mixer_selem_set_capture_volume_all(me, volume);
1131 } else {
1132 pa_assert(e->volume_use == PA_ALSA_VOLUME_ZERO);
1133 pa_assert(!e->db_fix);
1134
1135 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1136 r = snd_mixer_selem_set_playback_dB_all(me, 0, +1);
1137 else
1138 r = snd_mixer_selem_set_capture_dB_all(me, 0, +1);
1139 }
1140
1141 if (r < 0)
1142 pa_log_warn("Failed to set volume of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
1143
1144 return r;
1145 }
1146
1147 int pa_alsa_path_select(pa_alsa_path *p, snd_mixer_t *m) {
1148 pa_alsa_element *e;
1149 int r = 0;
1150
1151 pa_assert(m);
1152 pa_assert(p);
1153
1154 pa_log_debug("Activating path %s", p->name);
1155 pa_alsa_path_dump(p);
1156
1157 PA_LLIST_FOREACH(e, p->elements) {
1158
1159 switch (e->switch_use) {
1160 case PA_ALSA_SWITCH_OFF:
1161 r = element_set_switch(e, m, FALSE);
1162 break;
1163
1164 case PA_ALSA_SWITCH_ON:
1165 r = element_set_switch(e, m, TRUE);
1166 break;
1167
1168 case PA_ALSA_SWITCH_MUTE:
1169 case PA_ALSA_SWITCH_IGNORE:
1170 case PA_ALSA_SWITCH_SELECT:
1171 r = 0;
1172 break;
1173 }
1174
1175 if (r < 0)
1176 return -1;
1177
1178 switch (e->volume_use) {
1179 case PA_ALSA_VOLUME_OFF:
1180 case PA_ALSA_VOLUME_ZERO:
1181 case PA_ALSA_VOLUME_CONSTANT:
1182 r = element_set_constant_volume(e, m);
1183 break;
1184
1185 case PA_ALSA_VOLUME_MERGE:
1186 case PA_ALSA_VOLUME_IGNORE:
1187 r = 0;
1188 break;
1189 }
1190
1191 if (r < 0)
1192 return -1;
1193 }
1194
1195 return 0;
1196 }
1197
1198 static int check_required(pa_alsa_element *e, snd_mixer_elem_t *me) {
1199 pa_bool_t has_switch;
1200 pa_bool_t has_enumeration;
1201 pa_bool_t has_volume;
1202
1203 pa_assert(e);
1204 pa_assert(me);
1205
1206 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
1207 has_switch =
1208 snd_mixer_selem_has_playback_switch(me) ||
1209 (e->direction_try_other && snd_mixer_selem_has_capture_switch(me));
1210 } else {
1211 has_switch =
1212 snd_mixer_selem_has_capture_switch(me) ||
1213 (e->direction_try_other && snd_mixer_selem_has_playback_switch(me));
1214 }
1215
1216 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
1217 has_volume =
1218 snd_mixer_selem_has_playback_volume(me) ||
1219 (e->direction_try_other && snd_mixer_selem_has_capture_volume(me));
1220 } else {
1221 has_volume =
1222 snd_mixer_selem_has_capture_volume(me) ||
1223 (e->direction_try_other && snd_mixer_selem_has_playback_volume(me));
1224 }
1225
1226 has_enumeration = snd_mixer_selem_is_enumerated(me);
1227
1228 if ((e->required == PA_ALSA_REQUIRED_SWITCH && !has_switch) ||
1229 (e->required == PA_ALSA_REQUIRED_VOLUME && !has_volume) ||
1230 (e->required == PA_ALSA_REQUIRED_ENUMERATION && !has_enumeration))
1231 return -1;
1232
1233 if (e->required == PA_ALSA_REQUIRED_ANY && !(has_switch || has_volume || has_enumeration))
1234 return -1;
1235
1236 if ((e->required_absent == PA_ALSA_REQUIRED_SWITCH && has_switch) ||
1237 (e->required_absent == PA_ALSA_REQUIRED_VOLUME && has_volume) ||
1238 (e->required_absent == PA_ALSA_REQUIRED_ENUMERATION && has_enumeration))
1239 return -1;
1240
1241 if (e->required_absent == PA_ALSA_REQUIRED_ANY && (has_switch || has_volume || has_enumeration))
1242 return -1;
1243
1244 if (e->required_any != PA_ALSA_REQUIRED_IGNORE) {
1245 switch (e->required_any) {
1246 case PA_ALSA_REQUIRED_VOLUME:
1247 e->path->req_any_present |= (e->volume_use != PA_ALSA_VOLUME_IGNORE);
1248 break;
1249 case PA_ALSA_REQUIRED_SWITCH:
1250 e->path->req_any_present |= (e->switch_use != PA_ALSA_SWITCH_IGNORE);
1251 break;
1252 case PA_ALSA_REQUIRED_ENUMERATION:
1253 e->path->req_any_present |= (e->enumeration_use != PA_ALSA_ENUMERATION_IGNORE);
1254 break;
1255 case PA_ALSA_REQUIRED_ANY:
1256 e->path->req_any_present |=
1257 (e->volume_use != PA_ALSA_VOLUME_IGNORE) ||
1258 (e->switch_use != PA_ALSA_SWITCH_IGNORE) ||
1259 (e->enumeration_use != PA_ALSA_ENUMERATION_IGNORE);
1260 break;
1261 default:
1262 pa_assert_not_reached();
1263 }
1264 }
1265
1266 if (e->enumeration_use == PA_ALSA_ENUMERATION_SELECT) {
1267 pa_alsa_option *o;
1268 PA_LLIST_FOREACH(o, e->options) {
1269 e->path->req_any_present |= (o->required_any != PA_ALSA_REQUIRED_IGNORE) &&
1270 (o->alsa_idx >= 0);
1271 if (o->required != PA_ALSA_REQUIRED_IGNORE && o->alsa_idx < 0)
1272 return -1;
1273 if (o->required_absent != PA_ALSA_REQUIRED_IGNORE && o->alsa_idx >= 0)
1274 return -1;
1275 }
1276 }
1277
1278 return 0;
1279 }
1280
1281 static int element_probe(pa_alsa_element *e, snd_mixer_t *m) {
1282 snd_mixer_selem_id_t *sid;
1283 snd_mixer_elem_t *me;
1284
1285 pa_assert(m);
1286 pa_assert(e);
1287 pa_assert(e->path);
1288
1289 SELEM_INIT(sid, e->alsa_name);
1290
1291 if (!(me = snd_mixer_find_selem(m, sid))) {
1292
1293 if (e->required != PA_ALSA_REQUIRED_IGNORE)
1294 return -1;
1295
1296 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1297 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1298 e->enumeration_use = PA_ALSA_ENUMERATION_IGNORE;
1299
1300 return 0;
1301 }
1302
1303 if (e->switch_use != PA_ALSA_SWITCH_IGNORE) {
1304 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
1305
1306 if (!snd_mixer_selem_has_playback_switch(me)) {
1307 if (e->direction_try_other && snd_mixer_selem_has_capture_switch(me))
1308 e->direction = PA_ALSA_DIRECTION_INPUT;
1309 else
1310 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1311 }
1312
1313 } else {
1314
1315 if (!snd_mixer_selem_has_capture_switch(me)) {
1316 if (e->direction_try_other && snd_mixer_selem_has_playback_switch(me))
1317 e->direction = PA_ALSA_DIRECTION_OUTPUT;
1318 else
1319 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1320 }
1321 }
1322
1323 if (e->switch_use != PA_ALSA_SWITCH_IGNORE)
1324 e->direction_try_other = FALSE;
1325 }
1326
1327 if (e->volume_use != PA_ALSA_VOLUME_IGNORE) {
1328
1329 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
1330
1331 if (!snd_mixer_selem_has_playback_volume(me)) {
1332 if (e->direction_try_other && snd_mixer_selem_has_capture_volume(me))
1333 e->direction = PA_ALSA_DIRECTION_INPUT;
1334 else
1335 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1336 }
1337
1338 } else {
1339
1340 if (!snd_mixer_selem_has_capture_volume(me)) {
1341 if (e->direction_try_other && snd_mixer_selem_has_playback_volume(me))
1342 e->direction = PA_ALSA_DIRECTION_OUTPUT;
1343 else
1344 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1345 }
1346 }
1347
1348 if (e->volume_use != PA_ALSA_VOLUME_IGNORE) {
1349 long min_dB = 0, max_dB = 0;
1350 int r;
1351
1352 e->direction_try_other = FALSE;
1353
1354 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1355 r = snd_mixer_selem_get_playback_volume_range(me, &e->min_volume, &e->max_volume);
1356 else
1357 r = snd_mixer_selem_get_capture_volume_range(me, &e->min_volume, &e->max_volume);
1358
1359 if (r < 0) {
1360 pa_log_warn("Failed to get volume range of %s: %s", e->alsa_name, pa_alsa_strerror(r));
1361 return -1;
1362 }
1363
1364 if (e->min_volume >= e->max_volume) {
1365 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);
1366 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1367
1368 } else if (e->volume_use == PA_ALSA_VOLUME_CONSTANT &&
1369 (e->min_volume > e->constant_volume || e->max_volume < e->constant_volume)) {
1370 pa_log_warn("Constant volume %li configured for element %s, but the available range is from %li to %li.",
1371 e->constant_volume, e->alsa_name, e->min_volume, e->max_volume);
1372 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1373
1374 } else {
1375 pa_bool_t is_mono;
1376 pa_channel_position_t p;
1377
1378 if (e->db_fix &&
1379 ((e->min_volume > e->db_fix->min_step) ||
1380 (e->max_volume < e->db_fix->max_step))) {
1381 pa_log_warn("The step range of the decibel fix for element %s (%li-%li) doesn't fit to the "
1382 "real hardware range (%li-%li). Disabling the decibel fix.", e->alsa_name,
1383 e->db_fix->min_step, e->db_fix->max_step,
1384 e->min_volume, e->max_volume);
1385
1386 decibel_fix_free(e->db_fix);
1387 e->db_fix = NULL;
1388 }
1389
1390 if (e->db_fix) {
1391 e->has_dB = TRUE;
1392 e->min_volume = e->db_fix->min_step;
1393 e->max_volume = e->db_fix->max_step;
1394 min_dB = e->db_fix->db_values[0];
1395 max_dB = e->db_fix->db_values[e->db_fix->max_step - e->db_fix->min_step];
1396 } else if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1397 e->has_dB = snd_mixer_selem_get_playback_dB_range(me, &min_dB, &max_dB) >= 0;
1398 else
1399 e->has_dB = snd_mixer_selem_get_capture_dB_range(me, &min_dB, &max_dB) >= 0;
1400
1401 if (e->has_dB) {
1402 #ifdef HAVE_VALGRIND_MEMCHECK_H
1403 VALGRIND_MAKE_MEM_DEFINED(&min_dB, sizeof(min_dB));
1404 VALGRIND_MAKE_MEM_DEFINED(&max_dB, sizeof(max_dB));
1405 #endif
1406
1407 e->min_dB = ((double) min_dB) / 100.0;
1408 e->max_dB = ((double) max_dB) / 100.0;
1409
1410 if (min_dB >= max_dB) {
1411 pa_assert(!e->db_fix);
1412 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);
1413 e->has_dB = FALSE;
1414 }
1415 }
1416
1417 if (e->volume_limit >= 0) {
1418 if (e->volume_limit <= e->min_volume || e->volume_limit > e->max_volume)
1419 pa_log_warn("Volume limit for element %s of path %s is invalid: %li isn't within the valid range "
1420 "%li-%li. The volume limit is ignored.",
1421 e->alsa_name, e->path->name, e->volume_limit, e->min_volume + 1, e->max_volume);
1422
1423 else {
1424 e->max_volume = e->volume_limit;
1425
1426 if (e->has_dB) {
1427 if (e->db_fix) {
1428 e->db_fix->max_step = e->max_volume;
1429 e->max_dB = ((double) e->db_fix->db_values[e->db_fix->max_step - e->db_fix->min_step]) / 100.0;
1430
1431 } else {
1432 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1433 r = snd_mixer_selem_ask_playback_vol_dB(me, e->max_volume, &max_dB);
1434 else
1435 r = snd_mixer_selem_ask_capture_vol_dB(me, e->max_volume, &max_dB);
1436
1437 if (r < 0) {
1438 pa_log_warn("Failed to get dB value of %s: %s", e->alsa_name, pa_alsa_strerror(r));
1439 e->has_dB = FALSE;
1440 } else
1441 e->max_dB = ((double) max_dB) / 100.0;
1442 }
1443 }
1444 }
1445 }
1446
1447 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1448 is_mono = snd_mixer_selem_is_playback_mono(me) > 0;
1449 else
1450 is_mono = snd_mixer_selem_is_capture_mono(me) > 0;
1451
1452 if (is_mono) {
1453 e->n_channels = 1;
1454
1455 if (!e->override_map) {
1456 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++)
1457 e->masks[alsa_channel_ids[p]][e->n_channels-1] = 0;
1458 e->masks[SND_MIXER_SCHN_MONO][e->n_channels-1] = PA_CHANNEL_POSITION_MASK_ALL;
1459 }
1460
1461 e->merged_mask = e->masks[SND_MIXER_SCHN_MONO][e->n_channels-1];
1462 } else {
1463 e->n_channels = 0;
1464 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++) {
1465
1466 if (alsa_channel_ids[p] == SND_MIXER_SCHN_UNKNOWN)
1467 continue;
1468
1469 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1470 e->n_channels += snd_mixer_selem_has_playback_channel(me, alsa_channel_ids[p]) > 0;
1471 else
1472 e->n_channels += snd_mixer_selem_has_capture_channel(me, alsa_channel_ids[p]) > 0;
1473 }
1474
1475 if (e->n_channels <= 0) {
1476 pa_log_warn("Volume element %s with no channels?", e->alsa_name);
1477 return -1;
1478 }
1479
1480 if (e->n_channels > 2) {
1481 /* FIXME: In some places code like this is used:
1482 *
1483 * e->masks[alsa_channel_ids[p]][e->n_channels-1]
1484 *
1485 * The definition of e->masks is
1486 *
1487 * pa_channel_position_mask_t masks[SND_MIXER_SCHN_LAST][2];
1488 *
1489 * Since the array size is fixed at 2, we obviously
1490 * don't support elements with more than two
1491 * channels... */
1492 pa_log_warn("Volume element %s has %u channels. That's too much! I can't handle that!", e->alsa_name, e->n_channels);
1493 return -1;
1494 }
1495
1496 if (!e->override_map) {
1497 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++) {
1498 pa_bool_t has_channel;
1499
1500 if (alsa_channel_ids[p] == SND_MIXER_SCHN_UNKNOWN)
1501 continue;
1502
1503 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1504 has_channel = snd_mixer_selem_has_playback_channel(me, alsa_channel_ids[p]) > 0;
1505 else
1506 has_channel = snd_mixer_selem_has_capture_channel(me, alsa_channel_ids[p]) > 0;
1507
1508 e->masks[alsa_channel_ids[p]][e->n_channels-1] = has_channel ? PA_CHANNEL_POSITION_MASK(p) : 0;
1509 }
1510 }
1511
1512 e->merged_mask = 0;
1513 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++)
1514 e->merged_mask |= e->masks[alsa_channel_ids[p]][e->n_channels-1];
1515 }
1516 }
1517 }
1518
1519 }
1520
1521 if (e->switch_use == PA_ALSA_SWITCH_SELECT) {
1522 pa_alsa_option *o;
1523
1524 PA_LLIST_FOREACH(o, e->options)
1525 o->alsa_idx = pa_streq(o->alsa_name, "on") ? 1 : 0;
1526 } else if (e->enumeration_use == PA_ALSA_ENUMERATION_SELECT) {
1527 int n;
1528 pa_alsa_option *o;
1529
1530 if ((n = snd_mixer_selem_get_enum_items(me)) < 0) {
1531 pa_log("snd_mixer_selem_get_enum_items() failed: %s", pa_alsa_strerror(n));
1532 return -1;
1533 }
1534
1535 PA_LLIST_FOREACH(o, e->options) {
1536 int i;
1537
1538 for (i = 0; i < n; i++) {
1539 char buf[128];
1540
1541 if (snd_mixer_selem_get_enum_item_name(me, i, sizeof(buf), buf) < 0)
1542 continue;
1543
1544 if (!pa_streq(buf, o->alsa_name))
1545 continue;
1546
1547 o->alsa_idx = i;
1548 }
1549 }
1550 }
1551
1552 if (check_required(e, me) < 0)
1553 return -1;
1554
1555 return 0;
1556 }
1557
1558 static pa_alsa_element* element_get(pa_alsa_path *p, const char *section, pa_bool_t prefixed) {
1559 pa_alsa_element *e;
1560
1561 pa_assert(p);
1562 pa_assert(section);
1563
1564 if (prefixed) {
1565 if (!pa_startswith(section, "Element "))
1566 return NULL;
1567
1568 section += 8;
1569 }
1570
1571 /* This is not an element section, but an enum section? */
1572 if (strchr(section, ':'))
1573 return NULL;
1574
1575 if (p->last_element && pa_streq(p->last_element->alsa_name, section))
1576 return p->last_element;
1577
1578 PA_LLIST_FOREACH(e, p->elements)
1579 if (pa_streq(e->alsa_name, section))
1580 goto finish;
1581
1582 e = pa_xnew0(pa_alsa_element, 1);
1583 e->path = p;
1584 e->alsa_name = pa_xstrdup(section);
1585 e->direction = p->direction;
1586 e->volume_limit = -1;
1587
1588 PA_LLIST_INSERT_AFTER(pa_alsa_element, p->elements, p->last_element, e);
1589
1590 finish:
1591 p->last_element = e;
1592 return e;
1593 }
1594
1595 static pa_alsa_option* option_get(pa_alsa_path *p, const char *section) {
1596 char *en;
1597 const char *on;
1598 pa_alsa_option *o;
1599 pa_alsa_element *e;
1600
1601 if (!pa_startswith(section, "Option "))
1602 return NULL;
1603
1604 section += 7;
1605
1606 /* This is not an enum section, but an element section? */
1607 if (!(on = strchr(section, ':')))
1608 return NULL;
1609
1610 en = pa_xstrndup(section, on - section);
1611 on++;
1612
1613 if (p->last_option &&
1614 pa_streq(p->last_option->element->alsa_name, en) &&
1615 pa_streq(p->last_option->alsa_name, on)) {
1616 pa_xfree(en);
1617 return p->last_option;
1618 }
1619
1620 pa_assert_se(e = element_get(p, en, FALSE));
1621 pa_xfree(en);
1622
1623 PA_LLIST_FOREACH(o, e->options)
1624 if (pa_streq(o->alsa_name, on))
1625 goto finish;
1626
1627 o = pa_xnew0(pa_alsa_option, 1);
1628 o->element = e;
1629 o->alsa_name = pa_xstrdup(on);
1630 o->alsa_idx = -1;
1631
1632 if (p->last_option && p->last_option->element == e)
1633 PA_LLIST_INSERT_AFTER(pa_alsa_option, e->options, p->last_option, o);
1634 else
1635 PA_LLIST_PREPEND(pa_alsa_option, e->options, o);
1636
1637 finish:
1638 p->last_option = o;
1639 return o;
1640 }
1641
1642 static int element_parse_switch(
1643 const char *filename,
1644 unsigned line,
1645 const char *section,
1646 const char *lvalue,
1647 const char *rvalue,
1648 void *data,
1649 void *userdata) {
1650
1651 pa_alsa_path *p = userdata;
1652 pa_alsa_element *e;
1653
1654 pa_assert(p);
1655
1656 if (!(e = element_get(p, section, TRUE))) {
1657 pa_log("[%s:%u] Switch makes no sense in '%s'", filename, line, section);
1658 return -1;
1659 }
1660
1661 if (pa_streq(rvalue, "ignore"))
1662 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1663 else if (pa_streq(rvalue, "mute"))
1664 e->switch_use = PA_ALSA_SWITCH_MUTE;
1665 else if (pa_streq(rvalue, "off"))
1666 e->switch_use = PA_ALSA_SWITCH_OFF;
1667 else if (pa_streq(rvalue, "on"))
1668 e->switch_use = PA_ALSA_SWITCH_ON;
1669 else if (pa_streq(rvalue, "select"))
1670 e->switch_use = PA_ALSA_SWITCH_SELECT;
1671 else {
1672 pa_log("[%s:%u] Switch invalid of '%s'", filename, line, section);
1673 return -1;
1674 }
1675
1676 return 0;
1677 }
1678
1679 static int element_parse_volume(
1680 const char *filename,
1681 unsigned line,
1682 const char *section,
1683 const char *lvalue,
1684 const char *rvalue,
1685 void *data,
1686 void *userdata) {
1687
1688 pa_alsa_path *p = userdata;
1689 pa_alsa_element *e;
1690
1691 pa_assert(p);
1692
1693 if (!(e = element_get(p, section, TRUE))) {
1694 pa_log("[%s:%u] Volume makes no sense in '%s'", filename, line, section);
1695 return -1;
1696 }
1697
1698 if (pa_streq(rvalue, "ignore"))
1699 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1700 else if (pa_streq(rvalue, "merge"))
1701 e->volume_use = PA_ALSA_VOLUME_MERGE;
1702 else if (pa_streq(rvalue, "off"))
1703 e->volume_use = PA_ALSA_VOLUME_OFF;
1704 else if (pa_streq(rvalue, "zero"))
1705 e->volume_use = PA_ALSA_VOLUME_ZERO;
1706 else {
1707 uint32_t constant;
1708
1709 if (pa_atou(rvalue, &constant) >= 0) {
1710 e->volume_use = PA_ALSA_VOLUME_CONSTANT;
1711 e->constant_volume = constant;
1712 } else {
1713 pa_log("[%s:%u] Volume invalid of '%s'", filename, line, section);
1714 return -1;
1715 }
1716 }
1717
1718 return 0;
1719 }
1720
1721 static int element_parse_enumeration(
1722 const char *filename,
1723 unsigned line,
1724 const char *section,
1725 const char *lvalue,
1726 const char *rvalue,
1727 void *data,
1728 void *userdata) {
1729
1730 pa_alsa_path *p = userdata;
1731 pa_alsa_element *e;
1732
1733 pa_assert(p);
1734
1735 if (!(e = element_get(p, section, TRUE))) {
1736 pa_log("[%s:%u] Enumeration makes no sense in '%s'", filename, line, section);
1737 return -1;
1738 }
1739
1740 if (pa_streq(rvalue, "ignore"))
1741 e->enumeration_use = PA_ALSA_ENUMERATION_IGNORE;
1742 else if (pa_streq(rvalue, "select"))
1743 e->enumeration_use = PA_ALSA_ENUMERATION_SELECT;
1744 else {
1745 pa_log("[%s:%u] Enumeration invalid of '%s'", filename, line, section);
1746 return -1;
1747 }
1748
1749 return 0;
1750 }
1751
1752 static int option_parse_priority(
1753 const char *filename,
1754 unsigned line,
1755 const char *section,
1756 const char *lvalue,
1757 const char *rvalue,
1758 void *data,
1759 void *userdata) {
1760
1761 pa_alsa_path *p = userdata;
1762 pa_alsa_option *o;
1763 uint32_t prio;
1764
1765 pa_assert(p);
1766
1767 if (!(o = option_get(p, section))) {
1768 pa_log("[%s:%u] Priority makes no sense in '%s'", filename, line, section);
1769 return -1;
1770 }
1771
1772 if (pa_atou(rvalue, &prio) < 0) {
1773 pa_log("[%s:%u] Priority invalid of '%s'", filename, line, section);
1774 return -1;
1775 }
1776
1777 o->priority = prio;
1778 return 0;
1779 }
1780
1781 static int option_parse_name(
1782 const char *filename,
1783 unsigned line,
1784 const char *section,
1785 const char *lvalue,
1786 const char *rvalue,
1787 void *data,
1788 void *userdata) {
1789
1790 pa_alsa_path *p = userdata;
1791 pa_alsa_option *o;
1792
1793 pa_assert(p);
1794
1795 if (!(o = option_get(p, section))) {
1796 pa_log("[%s:%u] Name makes no sense in '%s'", filename, line, section);
1797 return -1;
1798 }
1799
1800 pa_xfree(o->name);
1801 o->name = pa_xstrdup(rvalue);
1802
1803 return 0;
1804 }
1805
1806 static int element_parse_required(
1807 const char *filename,
1808 unsigned line,
1809 const char *section,
1810 const char *lvalue,
1811 const char *rvalue,
1812 void *data,
1813 void *userdata) {
1814
1815 pa_alsa_path *p = userdata;
1816 pa_alsa_element *e;
1817 pa_alsa_option *o;
1818 pa_alsa_required_t req;
1819
1820 pa_assert(p);
1821
1822 e = element_get(p, section, TRUE);
1823 o = option_get(p, section);
1824 if (!e && !o) {
1825 pa_log("[%s:%u] Required makes no sense in '%s'", filename, line, section);
1826 return -1;
1827 }
1828
1829 if (pa_streq(rvalue, "ignore"))
1830 req = PA_ALSA_REQUIRED_IGNORE;
1831 else if (pa_streq(rvalue, "switch") && e)
1832 req = PA_ALSA_REQUIRED_SWITCH;
1833 else if (pa_streq(rvalue, "volume") && e)
1834 req = PA_ALSA_REQUIRED_VOLUME;
1835 else if (pa_streq(rvalue, "enumeration"))
1836 req = PA_ALSA_REQUIRED_ENUMERATION;
1837 else if (pa_streq(rvalue, "any"))
1838 req = PA_ALSA_REQUIRED_ANY;
1839 else {
1840 pa_log("[%s:%u] Required invalid of '%s'", filename, line, section);
1841 return -1;
1842 }
1843
1844 if (pa_streq(lvalue, "required-absent")) {
1845 if (e)
1846 e->required_absent = req;
1847 if (o)
1848 o->required_absent = req;
1849 }
1850 else if (pa_streq(lvalue, "required-any")) {
1851 if (e) {
1852 e->required_any = req;
1853 e->path->has_req_any = TRUE;
1854 }
1855 if (o) {
1856 o->required_any = req;
1857 o->element->path->has_req_any = TRUE;
1858 }
1859 }
1860 else {
1861 if (e)
1862 e->required = req;
1863 if (o)
1864 o->required = req;
1865 }
1866
1867 return 0;
1868 }
1869
1870 static int element_parse_direction(
1871 const char *filename,
1872 unsigned line,
1873 const char *section,
1874 const char *lvalue,
1875 const char *rvalue,
1876 void *data,
1877 void *userdata) {
1878
1879 pa_alsa_path *p = userdata;
1880 pa_alsa_element *e;
1881
1882 pa_assert(p);
1883
1884 if (!(e = element_get(p, section, TRUE))) {
1885 pa_log("[%s:%u] Direction makes no sense in '%s'", filename, line, section);
1886 return -1;
1887 }
1888
1889 if (pa_streq(rvalue, "playback"))
1890 e->direction = PA_ALSA_DIRECTION_OUTPUT;
1891 else if (pa_streq(rvalue, "capture"))
1892 e->direction = PA_ALSA_DIRECTION_INPUT;
1893 else {
1894 pa_log("[%s:%u] Direction invalid of '%s'", filename, line, section);
1895 return -1;
1896 }
1897
1898 return 0;
1899 }
1900
1901 static int element_parse_direction_try_other(
1902 const char *filename,
1903 unsigned line,
1904 const char *section,
1905 const char *lvalue,
1906 const char *rvalue,
1907 void *data,
1908 void *userdata) {
1909
1910 pa_alsa_path *p = userdata;
1911 pa_alsa_element *e;
1912 int yes;
1913
1914 if (!(e = element_get(p, section, TRUE))) {
1915 pa_log("[%s:%u] Direction makes no sense in '%s'", filename, line, section);
1916 return -1;
1917 }
1918
1919 if ((yes = pa_parse_boolean(rvalue)) < 0) {
1920 pa_log("[%s:%u] Direction invalid of '%s'", filename, line, section);
1921 return -1;
1922 }
1923
1924 e->direction_try_other = !!yes;
1925 return 0;
1926 }
1927
1928 static int element_parse_volume_limit(
1929 const char *filename,
1930 unsigned line,
1931 const char *section,
1932 const char *lvalue,
1933 const char *rvalue,
1934 void *data,
1935 void *userdata) {
1936
1937 pa_alsa_path *p = userdata;
1938 pa_alsa_element *e;
1939 long volume_limit;
1940
1941 if (!(e = element_get(p, section, TRUE))) {
1942 pa_log("[%s:%u] volume-limit makes no sense in '%s'", filename, line, section);
1943 return -1;
1944 }
1945
1946 if (pa_atol(rvalue, &volume_limit) < 0 || volume_limit < 0) {
1947 pa_log("[%s:%u] Invalid value for volume-limit", filename, line);
1948 return -1;
1949 }
1950
1951 e->volume_limit = volume_limit;
1952 return 0;
1953 }
1954
1955 static pa_channel_position_mask_t parse_mask(const char *m) {
1956 pa_channel_position_mask_t v;
1957
1958 if (pa_streq(m, "all-left"))
1959 v = PA_CHANNEL_POSITION_MASK_LEFT;
1960 else if (pa_streq(m, "all-right"))
1961 v = PA_CHANNEL_POSITION_MASK_RIGHT;
1962 else if (pa_streq(m, "all-center"))
1963 v = PA_CHANNEL_POSITION_MASK_CENTER;
1964 else if (pa_streq(m, "all-front"))
1965 v = PA_CHANNEL_POSITION_MASK_FRONT;
1966 else if (pa_streq(m, "all-rear"))
1967 v = PA_CHANNEL_POSITION_MASK_REAR;
1968 else if (pa_streq(m, "all-side"))
1969 v = PA_CHANNEL_POSITION_MASK_SIDE_OR_TOP_CENTER;
1970 else if (pa_streq(m, "all-top"))
1971 v = PA_CHANNEL_POSITION_MASK_TOP;
1972 else if (pa_streq(m, "all-no-lfe"))
1973 v = PA_CHANNEL_POSITION_MASK_ALL ^ PA_CHANNEL_POSITION_MASK(PA_CHANNEL_POSITION_LFE);
1974 else if (pa_streq(m, "all"))
1975 v = PA_CHANNEL_POSITION_MASK_ALL;
1976 else {
1977 pa_channel_position_t p;
1978
1979 if ((p = pa_channel_position_from_string(m)) == PA_CHANNEL_POSITION_INVALID)
1980 return 0;
1981
1982 v = PA_CHANNEL_POSITION_MASK(p);
1983 }
1984
1985 return v;
1986 }
1987
1988 static int element_parse_override_map(
1989 const char *filename,
1990 unsigned line,
1991 const char *section,
1992 const char *lvalue,
1993 const char *rvalue,
1994 void *data,
1995 void *userdata) {
1996
1997 pa_alsa_path *p = userdata;
1998 pa_alsa_element *e;
1999 const char *state = NULL;
2000 unsigned i = 0;
2001 char *n;
2002
2003 if (!(e = element_get(p, section, TRUE))) {
2004 pa_log("[%s:%u] Override map makes no sense in '%s'", filename, line, section);
2005 return -1;
2006 }
2007
2008 while ((n = pa_split(rvalue, ",", &state))) {
2009 pa_channel_position_mask_t m;
2010
2011 if (!*n)
2012 m = 0;
2013 else {
2014 if ((m = parse_mask(n)) == 0) {
2015 pa_log("[%s:%u] Override map '%s' invalid in '%s'", filename, line, n, section);
2016 pa_xfree(n);
2017 return -1;
2018 }
2019 }
2020
2021 if (pa_streq(lvalue, "override-map.1"))
2022 e->masks[i++][0] = m;
2023 else
2024 e->masks[i++][1] = m;
2025
2026 /* Later on we might add override-map.3 and so on here ... */
2027
2028 pa_xfree(n);
2029 }
2030
2031 e->override_map = TRUE;
2032
2033 return 0;
2034 }
2035
2036 static int element_set_option(pa_alsa_element *e, snd_mixer_t *m, int alsa_idx) {
2037 snd_mixer_selem_id_t *sid;
2038 snd_mixer_elem_t *me;
2039 int r;
2040
2041 pa_assert(e);
2042 pa_assert(m);
2043
2044 SELEM_INIT(sid, e->alsa_name);
2045 if (!(me = snd_mixer_find_selem(m, sid))) {
2046 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
2047 return -1;
2048 }
2049
2050 if (e->switch_use == PA_ALSA_SWITCH_SELECT) {
2051
2052 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
2053 r = snd_mixer_selem_set_playback_switch_all(me, alsa_idx);
2054 else
2055 r = snd_mixer_selem_set_capture_switch_all(me, alsa_idx);
2056
2057 if (r < 0)
2058 pa_log_warn("Failed to set switch of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
2059
2060 } else {
2061 pa_assert(e->enumeration_use == PA_ALSA_ENUMERATION_SELECT);
2062
2063 if ((r = snd_mixer_selem_set_enum_item(me, 0, alsa_idx)) < 0)
2064 pa_log_warn("Failed to set enumeration of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
2065 }
2066
2067 return r;
2068 }
2069
2070 int pa_alsa_setting_select(pa_alsa_setting *s, snd_mixer_t *m) {
2071 pa_alsa_option *o;
2072 uint32_t idx;
2073
2074 pa_assert(s);
2075 pa_assert(m);
2076
2077 PA_IDXSET_FOREACH(o, s->options, idx)
2078 element_set_option(o->element, m, o->alsa_idx);
2079
2080 return 0;
2081 }
2082
2083 static int option_verify(pa_alsa_option *o) {
2084 static const struct description_map well_known_descriptions[] = {
2085 { "input", N_("Input") },
2086 { "input-docking", N_("Docking Station Input") },
2087 { "input-docking-microphone", N_("Docking Station Microphone") },
2088 { "input-docking-linein", N_("Docking Station Line-In") },
2089 { "input-linein", N_("Line-In") },
2090 { "input-microphone", N_("Microphone") },
2091 { "input-microphone-front", N_("Front Microphone") },
2092 { "input-microphone-rear", N_("Rear Microphone") },
2093 { "input-microphone-external", N_("External Microphone") },
2094 { "input-microphone-internal", N_("Internal Microphone") },
2095 { "input-radio", N_("Radio") },
2096 { "input-video", N_("Video") },
2097 { "input-agc-on", N_("Automatic Gain Control") },
2098 { "input-agc-off", N_("No Automatic Gain Control") },
2099 { "input-boost-on", N_("Boost") },
2100 { "input-boost-off", N_("No Boost") },
2101 { "output-amplifier-on", N_("Amplifier") },
2102 { "output-amplifier-off", N_("No Amplifier") },
2103 { "output-bass-boost-on", N_("Bass Boost") },
2104 { "output-bass-boost-off", N_("No Bass Boost") },
2105 { "output-speaker", N_("Speaker") },
2106 { "output-headphones", N_("Headphones") }
2107 };
2108
2109 pa_assert(o);
2110
2111 if (!o->name) {
2112 pa_log("No name set for option %s", o->alsa_name);
2113 return -1;
2114 }
2115
2116 if (o->element->enumeration_use != PA_ALSA_ENUMERATION_SELECT &&
2117 o->element->switch_use != PA_ALSA_SWITCH_SELECT) {
2118 pa_log("Element %s of option %s not set for select.", o->element->alsa_name, o->name);
2119 return -1;
2120 }
2121
2122 if (o->element->switch_use == PA_ALSA_SWITCH_SELECT &&
2123 !pa_streq(o->alsa_name, "on") &&
2124 !pa_streq(o->alsa_name, "off")) {
2125 pa_log("Switch %s options need be named off or on ", o->element->alsa_name);
2126 return -1;
2127 }
2128
2129 if (!o->description)
2130 o->description = pa_xstrdup(lookup_description(o->name,
2131 well_known_descriptions,
2132 PA_ELEMENTSOF(well_known_descriptions)));
2133 if (!o->description)
2134 o->description = pa_xstrdup(o->name);
2135
2136 return 0;
2137 }
2138
2139 static int element_verify(pa_alsa_element *e) {
2140 pa_alsa_option *o;
2141
2142 pa_assert(e);
2143
2144 // pa_log_debug("Element %s, path %s: r=%d, r-any=%d, r-abs=%d", e->alsa_name, e->path->name, e->required, e->required_any, e->required_absent);
2145 if ((e->required != PA_ALSA_REQUIRED_IGNORE && e->required == e->required_absent) ||
2146 (e->required_any != PA_ALSA_REQUIRED_IGNORE && e->required_any == e->required_absent) ||
2147 (e->required_absent == PA_ALSA_REQUIRED_ANY && e->required_any != PA_ALSA_REQUIRED_IGNORE) ||
2148 (e->required_absent == PA_ALSA_REQUIRED_ANY && e->required != PA_ALSA_REQUIRED_IGNORE)) {
2149 pa_log("Element %s cannot be required and absent at the same time.", e->alsa_name);
2150 return -1;
2151 }
2152
2153 if (e->switch_use == PA_ALSA_SWITCH_SELECT && e->enumeration_use == PA_ALSA_ENUMERATION_SELECT) {
2154 pa_log("Element %s cannot set select for both switch and enumeration.", e->alsa_name);
2155 return -1;
2156 }
2157
2158 PA_LLIST_FOREACH(o, e->options)
2159 if (option_verify(o) < 0)
2160 return -1;
2161
2162 return 0;
2163 }
2164
2165 static int path_verify(pa_alsa_path *p) {
2166 static const struct description_map well_known_descriptions[] = {
2167 { "analog-input", N_("Analog Input") },
2168 { "analog-input-microphone", N_("Analog Microphone") },
2169 { "analog-input-microphone-front", N_("Front Microphone") },
2170 { "analog-input-microphone-rear", N_("Rear Microphone") },
2171 { "analog-input-microphone-dock", N_("Docking Station Microphone") },
2172 { "analog-input-microphone-internal", N_("Internal Microphone") },
2173 { "analog-input-linein", N_("Analog Line-In") },
2174 { "analog-input-radio", N_("Analog Radio") },
2175 { "analog-input-video", N_("Analog Video") },
2176 { "analog-output", N_("Analog Output") },
2177 { "analog-output-headphones", N_("Analog Headphones") },
2178 { "analog-output-lfe-on-mono", N_("Analog Output (LFE)") },
2179 { "analog-output-mono", N_("Analog Mono Output") },
2180 { "analog-output-speaker", N_("Analog Speakers") },
2181 { "iec958-stereo-output", N_("Digital Output (IEC958)") },
2182 { "iec958-passthrough-output", N_("Digital Passthrough (IEC958)") }
2183 };
2184
2185 pa_alsa_element *e;
2186
2187 pa_assert(p);
2188
2189 PA_LLIST_FOREACH(e, p->elements)
2190 if (element_verify(e) < 0)
2191 return -1;
2192
2193 if (!p->description)
2194 p->description = pa_xstrdup(lookup_description(p->name,
2195 well_known_descriptions,
2196 PA_ELEMENTSOF(well_known_descriptions)));
2197
2198 if (!p->description)
2199 p->description = pa_xstrdup(p->name);
2200
2201 return 0;
2202 }
2203
2204 pa_alsa_path* pa_alsa_path_new(const char *fname, pa_alsa_direction_t direction) {
2205 pa_alsa_path *p;
2206 char *fn;
2207 int r;
2208 const char *n;
2209
2210 pa_config_item items[] = {
2211 /* [General] */
2212 { "priority", pa_config_parse_unsigned, NULL, "General" },
2213 { "description", pa_config_parse_string, NULL, "General" },
2214 { "name", pa_config_parse_string, NULL, "General" },
2215
2216 /* [Option ...] */
2217 { "priority", option_parse_priority, NULL, NULL },
2218 { "name", option_parse_name, NULL, NULL },
2219
2220 /* [Element ...] */
2221 { "switch", element_parse_switch, NULL, NULL },
2222 { "volume", element_parse_volume, NULL, NULL },
2223 { "enumeration", element_parse_enumeration, NULL, NULL },
2224 { "override-map.1", element_parse_override_map, NULL, NULL },
2225 { "override-map.2", element_parse_override_map, NULL, NULL },
2226 /* ... later on we might add override-map.3 and so on here ... */
2227 { "required", element_parse_required, NULL, NULL },
2228 { "required-any", element_parse_required, NULL, NULL },
2229 { "required-absent", element_parse_required, NULL, NULL },
2230 { "direction", element_parse_direction, NULL, NULL },
2231 { "direction-try-other", element_parse_direction_try_other, NULL, NULL },
2232 { "volume-limit", element_parse_volume_limit, NULL, NULL },
2233 { NULL, NULL, NULL, NULL }
2234 };
2235
2236 pa_assert(fname);
2237
2238 p = pa_xnew0(pa_alsa_path, 1);
2239 n = pa_path_get_filename(fname);
2240 p->name = pa_xstrndup(n, strcspn(n, "."));
2241 p->direction = direction;
2242
2243 items[0].data = &p->priority;
2244 items[1].data = &p->description;
2245 items[2].data = &p->name;
2246
2247 fn = pa_maybe_prefix_path(fname,
2248 pa_run_from_build_tree() ? PA_BUILDDIR "/modules/alsa/mixer/paths/" :
2249 PA_ALSA_PATHS_DIR);
2250
2251 r = pa_config_parse(fn, NULL, items, p);
2252 pa_xfree(fn);
2253
2254 if (r < 0)
2255 goto fail;
2256
2257 if (path_verify(p) < 0)
2258 goto fail;
2259
2260 return p;
2261
2262 fail:
2263 pa_alsa_path_free(p);
2264 return NULL;
2265 }
2266
2267 pa_alsa_path *pa_alsa_path_synthesize(const char *element, pa_alsa_direction_t direction) {
2268 pa_alsa_path *p;
2269 pa_alsa_element *e;
2270
2271 pa_assert(element);
2272
2273 p = pa_xnew0(pa_alsa_path, 1);
2274 p->name = pa_xstrdup(element);
2275 p->direction = direction;
2276
2277 e = pa_xnew0(pa_alsa_element, 1);
2278 e->path = p;
2279 e->alsa_name = pa_xstrdup(element);
2280 e->direction = direction;
2281 e->volume_limit = -1;
2282
2283 e->switch_use = PA_ALSA_SWITCH_MUTE;
2284 e->volume_use = PA_ALSA_VOLUME_MERGE;
2285
2286 PA_LLIST_PREPEND(pa_alsa_element, p->elements, e);
2287 p->last_element = e;
2288 return p;
2289 }
2290
2291 static pa_bool_t element_drop_unsupported(pa_alsa_element *e) {
2292 pa_alsa_option *o, *n;
2293
2294 pa_assert(e);
2295
2296 for (o = e->options; o; o = n) {
2297 n = o->next;
2298
2299 if (o->alsa_idx < 0) {
2300 PA_LLIST_REMOVE(pa_alsa_option, e->options, o);
2301 option_free(o);
2302 }
2303 }
2304
2305 return
2306 e->switch_use != PA_ALSA_SWITCH_IGNORE ||
2307 e->volume_use != PA_ALSA_VOLUME_IGNORE ||
2308 e->enumeration_use != PA_ALSA_ENUMERATION_IGNORE;
2309 }
2310
2311 static void path_drop_unsupported(pa_alsa_path *p) {
2312 pa_alsa_element *e, *n;
2313
2314 pa_assert(p);
2315
2316 for (e = p->elements; e; e = n) {
2317 n = e->next;
2318
2319 if (!element_drop_unsupported(e)) {
2320 PA_LLIST_REMOVE(pa_alsa_element, p->elements, e);
2321 element_free(e);
2322 }
2323 }
2324 }
2325
2326 static void path_make_options_unique(pa_alsa_path *p) {
2327 pa_alsa_element *e;
2328 pa_alsa_option *o, *u;
2329
2330 PA_LLIST_FOREACH(e, p->elements) {
2331 PA_LLIST_FOREACH(o, e->options) {
2332 unsigned i;
2333 char *m;
2334
2335 for (u = o->next; u; u = u->next)
2336 if (pa_streq(u->name, o->name))
2337 break;
2338
2339 if (!u)
2340 continue;
2341
2342 m = pa_xstrdup(o->name);
2343
2344 /* OK, this name is not unique, hence let's rename */
2345 for (i = 1, u = o; u; u = u->next) {
2346 char *nn, *nd;
2347
2348 if (!pa_streq(u->name, m))
2349 continue;
2350
2351 nn = pa_sprintf_malloc("%s-%u", m, i);
2352 pa_xfree(u->name);
2353 u->name = nn;
2354
2355 nd = pa_sprintf_malloc("%s %u", u->description, i);
2356 pa_xfree(u->description);
2357 u->description = nd;
2358
2359 i++;
2360 }
2361
2362 pa_xfree(m);
2363 }
2364 }
2365 }
2366
2367 static pa_bool_t element_create_settings(pa_alsa_element *e, pa_alsa_setting *template) {
2368 pa_alsa_option *o;
2369
2370 for (; e; e = e->next)
2371 if (e->switch_use == PA_ALSA_SWITCH_SELECT ||
2372 e->enumeration_use == PA_ALSA_ENUMERATION_SELECT)
2373 break;
2374
2375 if (!e)
2376 return FALSE;
2377
2378 for (o = e->options; o; o = o->next) {
2379 pa_alsa_setting *s;
2380
2381 if (template) {
2382 s = pa_xnewdup(pa_alsa_setting, template, 1);
2383 s->options = pa_idxset_copy(template->options);
2384 s->name = pa_sprintf_malloc(_("%s+%s"), template->name, o->name);
2385 s->description =
2386 (template->description[0] && o->description[0])
2387 ? pa_sprintf_malloc(_("%s / %s"), template->description, o->description)
2388 : (template->description[0]
2389 ? pa_xstrdup(template->description)
2390 : pa_xstrdup(o->description));
2391
2392 s->priority = PA_MAX(template->priority, o->priority);
2393 } else {
2394 s = pa_xnew0(pa_alsa_setting, 1);
2395 s->options = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2396 s->name = pa_xstrdup(o->name);
2397 s->description = pa_xstrdup(o->description);
2398 s->priority = o->priority;
2399 }
2400
2401 pa_idxset_put(s->options, o, NULL);
2402
2403 if (element_create_settings(e->next, s))
2404 /* This is not a leaf, so let's get rid of it */
2405 setting_free(s);
2406 else {
2407 /* This is a leaf, so let's add it */
2408 PA_LLIST_INSERT_AFTER(pa_alsa_setting, e->path->settings, e->path->last_setting, s);
2409
2410 e->path->last_setting = s;
2411 }
2412 }
2413
2414 return TRUE;
2415 }
2416
2417 static void path_create_settings(pa_alsa_path *p) {
2418 pa_assert(p);
2419
2420 element_create_settings(p->elements, NULL);
2421 }
2422
2423 int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t ignore_dB) {
2424 pa_alsa_element *e;
2425 double min_dB[PA_CHANNEL_POSITION_MAX], max_dB[PA_CHANNEL_POSITION_MAX];
2426 pa_channel_position_t t;
2427 pa_channel_position_mask_t path_volume_channels = 0;
2428
2429 pa_assert(p);
2430 pa_assert(m);
2431
2432 if (p->probed)
2433 return 0;
2434
2435 pa_zero(min_dB);
2436 pa_zero(max_dB);
2437
2438 pa_log_debug("Probing path '%s'", p->name);
2439
2440 PA_LLIST_FOREACH(e, p->elements) {
2441 if (element_probe(e, m) < 0) {
2442 p->supported = FALSE;
2443 pa_log_debug("Probe of element '%s' failed.", e->alsa_name);
2444 return -1;
2445 }
2446 pa_log_debug("Probe of element '%s' succeeded (volume=%d, switch=%d, enumeration=%d).", e->alsa_name, e->volume_use, e->switch_use, e->enumeration_use);
2447
2448 if (ignore_dB)
2449 e->has_dB = FALSE;
2450
2451 if (e->volume_use == PA_ALSA_VOLUME_MERGE) {
2452
2453 if (!p->has_volume) {
2454 p->min_volume = e->min_volume;
2455 p->max_volume = e->max_volume;
2456 }
2457
2458 if (e->has_dB) {
2459 if (!p->has_volume) {
2460 for (t = 0; t < PA_CHANNEL_POSITION_MAX; t++)
2461 if (PA_CHANNEL_POSITION_MASK(t) & e->merged_mask) {
2462 min_dB[t] = e->min_dB;
2463 max_dB[t] = e->max_dB;
2464 path_volume_channels |= PA_CHANNEL_POSITION_MASK(t);
2465 }
2466
2467 p->has_dB = TRUE;
2468 } else {
2469
2470 if (p->has_dB) {
2471 for (t = 0; t < PA_CHANNEL_POSITION_MAX; t++)
2472 if (PA_CHANNEL_POSITION_MASK(t) & e->merged_mask) {
2473 min_dB[t] += e->min_dB;
2474 max_dB[t] += e->max_dB;
2475 path_volume_channels |= PA_CHANNEL_POSITION_MASK(t);
2476 }
2477 } else {
2478 /* Hmm, there's another element before us
2479 * which cannot do dB volumes, so we we need
2480 * to 'neutralize' this slider */
2481 e->volume_use = PA_ALSA_VOLUME_ZERO;
2482 pa_log_info("Zeroing volume of '%s' on path '%s'", e->alsa_name, p->name);
2483 }
2484 }
2485 } else if (p->has_volume) {
2486 /* We can't use this volume, so let's ignore it */
2487 e->volume_use = PA_ALSA_VOLUME_IGNORE;
2488 pa_log_info("Ignoring volume of '%s' on path '%s' (missing dB info)", e->alsa_name, p->name);
2489 }
2490 p->has_volume = TRUE;
2491 }
2492
2493 if (e->switch_use == PA_ALSA_SWITCH_MUTE)
2494 p->has_mute = TRUE;
2495 }
2496
2497 if (p->has_req_any && !p->req_any_present) {
2498 p->supported = FALSE;
2499 pa_log_debug("Skipping path '%s', none of required-any elements preset.", p->name);
2500 return -1;
2501 }
2502
2503 path_drop_unsupported(p);
2504 path_make_options_unique(p);
2505 path_create_settings(p);
2506
2507 p->supported = TRUE;
2508 p->probed = TRUE;
2509
2510 p->min_dB = INFINITY;
2511 p->max_dB = -INFINITY;
2512
2513 for (t = 0; t < PA_CHANNEL_POSITION_MAX; t++) {
2514 if (path_volume_channels & PA_CHANNEL_POSITION_MASK(t)) {
2515 if (p->min_dB > min_dB[t])
2516 p->min_dB = min_dB[t];
2517
2518 if (p->max_dB < max_dB[t])
2519 p->max_dB = max_dB[t];
2520 }
2521 }
2522
2523 return 0;
2524 }
2525
2526 void pa_alsa_setting_dump(pa_alsa_setting *s) {
2527 pa_assert(s);
2528
2529 pa_log_debug("Setting %s (%s) priority=%u",
2530 s->name,
2531 pa_strnull(s->description),
2532 s->priority);
2533 }
2534
2535 void pa_alsa_option_dump(pa_alsa_option *o) {
2536 pa_assert(o);
2537
2538 pa_log_debug("Option %s (%s/%s) index=%i, priority=%u",
2539 o->alsa_name,
2540 pa_strnull(o->name),
2541 pa_strnull(o->description),
2542 o->alsa_idx,
2543 o->priority);
2544 }
2545
2546 void pa_alsa_element_dump(pa_alsa_element *e) {
2547 pa_alsa_option *o;
2548 pa_assert(e);
2549
2550 pa_log_debug("Element %s, direction=%i, switch=%i, volume=%i, volume_limit=%li, enumeration=%i, required=%i, required_any=%i, required_absent=%i, mask=0x%llx, n_channels=%u, override_map=%s",
2551 e->alsa_name,
2552 e->direction,
2553 e->switch_use,
2554 e->volume_use,
2555 e->volume_limit,
2556 e->enumeration_use,
2557 e->required,
2558 e->required_any,
2559 e->required_absent,
2560 (long long unsigned) e->merged_mask,
2561 e->n_channels,
2562 pa_yes_no(e->override_map));
2563
2564 PA_LLIST_FOREACH(o, e->options)
2565 pa_alsa_option_dump(o);
2566 }
2567
2568 void pa_alsa_path_dump(pa_alsa_path *p) {
2569 pa_alsa_element *e;
2570 pa_alsa_setting *s;
2571 pa_assert(p);
2572
2573 pa_log_debug("Path %s (%s), direction=%i, priority=%u, probed=%s, supported=%s, has_mute=%s, has_volume=%s, "
2574 "has_dB=%s, min_volume=%li, max_volume=%li, min_dB=%g, max_dB=%g",
2575 p->name,
2576 pa_strnull(p->description),
2577 p->direction,
2578 p->priority,
2579 pa_yes_no(p->probed),
2580 pa_yes_no(p->supported),
2581 pa_yes_no(p->has_mute),
2582 pa_yes_no(p->has_volume),
2583 pa_yes_no(p->has_dB),
2584 p->min_volume, p->max_volume,
2585 p->min_dB, p->max_dB);
2586
2587 PA_LLIST_FOREACH(e, p->elements)
2588 pa_alsa_element_dump(e);
2589
2590 PA_LLIST_FOREACH(s, p->settings)
2591 pa_alsa_setting_dump(s);
2592 }
2593
2594 static void element_set_callback(pa_alsa_element *e, snd_mixer_t *m, snd_mixer_elem_callback_t cb, void *userdata) {
2595 snd_mixer_selem_id_t *sid;
2596 snd_mixer_elem_t *me;
2597
2598 pa_assert(e);
2599 pa_assert(m);
2600 pa_assert(cb);
2601
2602 SELEM_INIT(sid, e->alsa_name);
2603 if (!(me = snd_mixer_find_selem(m, sid))) {
2604 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
2605 return;
2606 }
2607
2608 snd_mixer_elem_set_callback(me, cb);
2609 snd_mixer_elem_set_callback_private(me, userdata);
2610 }
2611
2612 void pa_alsa_path_set_callback(pa_alsa_path *p, snd_mixer_t *m, snd_mixer_elem_callback_t cb, void *userdata) {
2613 pa_alsa_element *e;
2614
2615 pa_assert(p);
2616 pa_assert(m);
2617 pa_assert(cb);
2618
2619 PA_LLIST_FOREACH(e, p->elements)
2620 element_set_callback(e, m, cb, userdata);
2621 }
2622
2623 void pa_alsa_path_set_set_callback(pa_alsa_path_set *ps, snd_mixer_t *m, snd_mixer_elem_callback_t cb, void *userdata) {
2624 pa_alsa_path *p;
2625
2626 pa_assert(ps);
2627 pa_assert(m);
2628 pa_assert(cb);
2629
2630 PA_LLIST_FOREACH(p, ps->paths)
2631 pa_alsa_path_set_callback(p, m, cb, userdata);
2632 }
2633
2634 pa_alsa_path_set *pa_alsa_path_set_new(pa_alsa_mapping *m, pa_alsa_direction_t direction) {
2635 pa_alsa_path_set *ps;
2636 char **pn = NULL, **en = NULL, **ie;
2637 pa_alsa_decibel_fix *db_fix;
2638 void *state;
2639
2640 pa_assert(m);
2641 pa_assert(m->profile_set);
2642 pa_assert(m->profile_set->decibel_fixes);
2643 pa_assert(direction == PA_ALSA_DIRECTION_OUTPUT || direction == PA_ALSA_DIRECTION_INPUT);
2644
2645 if (m->direction != PA_ALSA_DIRECTION_ANY && m->direction != direction)
2646 return NULL;
2647
2648 ps = pa_xnew0(pa_alsa_path_set, 1);
2649 ps->direction = direction;
2650
2651 if (direction == PA_ALSA_DIRECTION_OUTPUT)
2652 pn = m->output_path_names;
2653 else if (direction == PA_ALSA_DIRECTION_INPUT)
2654 pn = m->input_path_names;
2655
2656 if (pn) {
2657 char **in;
2658
2659 for (in = pn; *in; in++) {
2660 pa_alsa_path *p;
2661 pa_bool_t duplicate = FALSE;
2662 char **kn, *fn;
2663
2664 for (kn = pn; kn < in; kn++)
2665 if (pa_streq(*kn, *in)) {
2666 duplicate = TRUE;
2667 break;
2668 }
2669
2670 if (duplicate)
2671 continue;
2672
2673 fn = pa_sprintf_malloc("%s.conf", *in);
2674
2675 if ((p = pa_alsa_path_new(fn, direction))) {
2676 p->path_set = ps;
2677 PA_LLIST_INSERT_AFTER(pa_alsa_path, ps->paths, ps->last_path, p);
2678 ps->last_path = p;
2679 }
2680
2681 pa_xfree(fn);
2682 }
2683
2684 goto finish;
2685 }
2686
2687 if (direction == PA_ALSA_DIRECTION_OUTPUT)
2688 en = m->output_element;
2689 else if (direction == PA_ALSA_DIRECTION_INPUT)
2690 en = m->input_element;
2691
2692 if (!en) {
2693 pa_alsa_path_set_free(ps);
2694 return NULL;
2695 }
2696
2697 for (ie = en; *ie; ie++) {
2698 char **je;
2699 pa_alsa_path *p;
2700
2701 p = pa_alsa_path_synthesize(*ie, direction);
2702 p->path_set = ps;
2703
2704 /* Mark all other passed elements for require-absent */
2705 for (je = en; *je; je++) {
2706 pa_alsa_element *e;
2707
2708 if (je == ie)
2709 continue;
2710
2711 e = pa_xnew0(pa_alsa_element, 1);
2712 e->path = p;
2713 e->alsa_name = pa_xstrdup(*je);
2714 e->direction = direction;
2715 e->required_absent = PA_ALSA_REQUIRED_ANY;
2716 e->volume_limit = -1;
2717
2718 PA_LLIST_INSERT_AFTER(pa_alsa_element, p->elements, p->last_element, e);
2719 p->last_element = e;
2720 }
2721
2722 PA_LLIST_INSERT_AFTER(pa_alsa_path, ps->paths, ps->last_path, p);
2723 ps->last_path = p;
2724 }
2725
2726 finish:
2727 /* Assign decibel fixes to elements. */
2728 PA_HASHMAP_FOREACH(db_fix, m->profile_set->decibel_fixes, state) {
2729 pa_alsa_path *p;
2730
2731 PA_LLIST_FOREACH(p, ps->paths) {
2732 pa_alsa_element *e;
2733
2734 PA_LLIST_FOREACH(e, p->elements) {
2735 if (e->volume_use != PA_ALSA_VOLUME_IGNORE && pa_streq(db_fix->name, e->alsa_name)) {
2736 /* The profile set that contains the dB fix may be freed
2737 * before the element, so we have to copy the dB fix
2738 * object. */
2739 e->db_fix = pa_xnewdup(pa_alsa_decibel_fix, db_fix, 1);
2740 e->db_fix->profile_set = NULL;
2741 e->db_fix->name = pa_xstrdup(db_fix->name);
2742 e->db_fix->db_values = pa_xmemdup(db_fix->db_values, (db_fix->max_step - db_fix->min_step + 1) * sizeof(long));
2743 }
2744 }
2745 }
2746 }
2747
2748 return ps;
2749 }
2750
2751 void pa_alsa_path_set_dump(pa_alsa_path_set *ps) {
2752 pa_alsa_path *p;
2753 pa_assert(ps);
2754
2755 pa_log_debug("Path Set %p, direction=%i, probed=%s",
2756 (void*) ps,
2757 ps->direction,
2758 pa_yes_no(ps->probed));
2759
2760 PA_LLIST_FOREACH(p, ps->paths)
2761 pa_alsa_path_dump(p);
2762 }
2763
2764 static void path_set_unify(pa_alsa_path_set *ps) {
2765 pa_alsa_path *p;
2766 pa_bool_t has_dB = TRUE, has_volume = TRUE, has_mute = TRUE;
2767 pa_assert(ps);
2768
2769 /* We have issues dealing with paths that vary too wildly. That
2770 * means for now we have to have all paths support volume/mute/dB
2771 * or none. */
2772
2773 PA_LLIST_FOREACH(p, ps->paths) {
2774 pa_assert(p->probed);
2775
2776 if (!p->has_volume)
2777 has_volume = FALSE;
2778 else if (!p->has_dB)
2779 has_dB = FALSE;
2780
2781 if (!p->has_mute)
2782 has_mute = FALSE;
2783 }
2784
2785 if (!has_volume || !has_dB || !has_mute) {
2786
2787 if (!has_volume)
2788 pa_log_debug("Some paths of the device lack hardware volume control, disabling hardware control altogether.");
2789 else if (!has_dB)
2790 pa_log_debug("Some paths of the device lack dB information, disabling dB logic altogether.");
2791
2792 if (!has_mute)
2793 pa_log_debug("Some paths of the device lack hardware mute control, disabling hardware control altogether.");
2794
2795 PA_LLIST_FOREACH(p, ps->paths) {
2796 if (!has_volume)
2797 p->has_volume = FALSE;
2798 else if (!has_dB)
2799 p->has_dB = FALSE;
2800
2801 if (!has_mute)
2802 p->has_mute = FALSE;
2803 }
2804 }
2805 }
2806
2807 static void path_set_make_paths_unique(pa_alsa_path_set *ps) {
2808 pa_alsa_path *p, *q;
2809
2810 PA_LLIST_FOREACH(p, ps->paths) {
2811 unsigned i;
2812 char *m;
2813
2814 for (q = p->next; q; q = q->next)
2815 if (pa_streq(q->name, p->name))
2816 break;
2817
2818 if (!q)
2819 continue;
2820
2821 m = pa_xstrdup(p->name);
2822
2823 /* OK, this name is not unique, hence let's rename */
2824 for (i = 1, q = p; q; q = q->next) {
2825 char *nn, *nd;
2826
2827 if (!pa_streq(q->name, m))
2828 continue;
2829
2830 nn = pa_sprintf_malloc("%s-%u", m, i);
2831 pa_xfree(q->name);
2832 q->name = nn;
2833
2834 nd = pa_sprintf_malloc("%s %u", q->description, i);
2835 pa_xfree(q->description);
2836 q->description = nd;
2837
2838 i++;
2839 }
2840
2841 pa_xfree(m);
2842 }
2843 }
2844
2845 void pa_alsa_path_set_probe(pa_alsa_path_set *ps, snd_mixer_t *m, pa_bool_t ignore_dB) {
2846 pa_alsa_path *p, *n;
2847
2848 pa_assert(ps);
2849
2850 if (ps->probed)
2851 return;
2852
2853 for (p = ps->paths; p; p = n) {
2854 n = p->next;
2855
2856 if (pa_alsa_path_probe(p, m, ignore_dB) < 0) {
2857 PA_LLIST_REMOVE(pa_alsa_path, ps->paths, p);
2858 pa_alsa_path_free(p);
2859 }
2860 }
2861
2862 path_set_unify(ps);
2863 path_set_make_paths_unique(ps);
2864 ps->probed = TRUE;
2865 }
2866
2867 static void mapping_free(pa_alsa_mapping *m) {
2868 pa_assert(m);
2869
2870 pa_xfree(m->name);
2871 pa_xfree(m->description);
2872
2873 pa_xstrfreev(m->device_strings);
2874 pa_xstrfreev(m->input_path_names);
2875 pa_xstrfreev(m->output_path_names);
2876 pa_xstrfreev(m->input_element);
2877 pa_xstrfreev(m->output_element);
2878
2879 pa_assert(!m->input_pcm);
2880 pa_assert(!m->output_pcm);
2881
2882 pa_xfree(m);
2883 }
2884
2885 static void profile_free(pa_alsa_profile *p) {
2886 pa_assert(p);
2887
2888 pa_xfree(p->name);
2889 pa_xfree(p->description);
2890
2891 pa_xstrfreev(p->input_mapping_names);
2892 pa_xstrfreev(p->output_mapping_names);
2893
2894 if (p->input_mappings)
2895 pa_idxset_free(p->input_mappings, NULL, NULL);
2896
2897 if (p->output_mappings)
2898 pa_idxset_free(p->output_mappings, NULL, NULL);
2899
2900 pa_xfree(p);
2901 }
2902
2903 void pa_alsa_profile_set_free(pa_alsa_profile_set *ps) {
2904 pa_assert(ps);
2905
2906 if (ps->profiles) {
2907 pa_alsa_profile *p;
2908
2909 while ((p = pa_hashmap_steal_first(ps->profiles)))
2910 profile_free(p);
2911
2912 pa_hashmap_free(ps->profiles, NULL, NULL);
2913 }
2914
2915 if (ps->mappings) {
2916 pa_alsa_mapping *m;
2917
2918 while ((m = pa_hashmap_steal_first(ps->mappings)))
2919 mapping_free(m);
2920
2921 pa_hashmap_free(ps->mappings, NULL, NULL);
2922 }
2923
2924 if (ps->decibel_fixes) {
2925 pa_alsa_decibel_fix *db_fix;
2926
2927 while ((db_fix = pa_hashmap_steal_first(ps->decibel_fixes)))
2928 decibel_fix_free(db_fix);
2929
2930 pa_hashmap_free(ps->decibel_fixes, NULL, NULL);
2931 }
2932
2933 pa_xfree(ps);
2934 }
2935
2936 static pa_alsa_mapping *mapping_get(pa_alsa_profile_set *ps, const char *name) {
2937 pa_alsa_mapping *m;
2938
2939 if (!pa_startswith(name, "Mapping "))
2940 return NULL;
2941
2942 name += 8;
2943
2944 if ((m = pa_hashmap_get(ps->mappings, name)))
2945 return m;
2946
2947 m = pa_xnew0(pa_alsa_mapping, 1);
2948 m->profile_set = ps;
2949 m->name = pa_xstrdup(name);
2950 pa_channel_map_init(&m->channel_map);
2951
2952 pa_hashmap_put(ps->mappings, m->name, m);
2953
2954 return m;
2955 }
2956
2957 static pa_alsa_profile *profile_get(pa_alsa_profile_set *ps, const char *name) {
2958 pa_alsa_profile *p;
2959
2960 if (!pa_startswith(name, "Profile "))
2961 return NULL;
2962
2963 name += 8;
2964
2965 if ((p = pa_hashmap_get(ps->profiles, name)))
2966 return p;
2967
2968 p = pa_xnew0(pa_alsa_profile, 1);
2969 p->profile_set = ps;
2970 p->name = pa_xstrdup(name);
2971
2972 pa_hashmap_put(ps->profiles, p->name, p);
2973
2974 return p;
2975 }
2976
2977 static pa_alsa_decibel_fix *decibel_fix_get(pa_alsa_profile_set *ps, const char *name) {
2978 pa_alsa_decibel_fix *db_fix;
2979
2980 if (!pa_startswith(name, "DecibelFix "))
2981 return NULL;
2982
2983 name += 11;
2984
2985 if ((db_fix = pa_hashmap_get(ps->decibel_fixes, name)))
2986 return db_fix;
2987
2988 db_fix = pa_xnew0(pa_alsa_decibel_fix, 1);
2989 db_fix->profile_set = ps;
2990 db_fix->name = pa_xstrdup(name);
2991
2992 pa_hashmap_put(ps->decibel_fixes, db_fix->name, db_fix);
2993
2994 return db_fix;
2995 }
2996
2997 static int mapping_parse_device_strings(
2998 const char *filename,
2999 unsigned line,
3000 const char *section,
3001 const char *lvalue,
3002 const char *rvalue,
3003 void *data,
3004 void *userdata) {
3005
3006 pa_alsa_profile_set *ps = userdata;
3007 pa_alsa_mapping *m;
3008
3009 pa_assert(ps);
3010
3011 if (!(m = mapping_get(ps, section))) {
3012 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3013 return -1;
3014 }
3015
3016 pa_xstrfreev(m->device_strings);
3017 if (!(m->device_strings = pa_split_spaces_strv(rvalue))) {
3018 pa_log("[%s:%u] Device string list empty of '%s'", filename, line, section);
3019 return -1;
3020 }
3021
3022 return 0;
3023 }
3024
3025 static int mapping_parse_channel_map(
3026 const char *filename,
3027 unsigned line,
3028 const char *section,
3029 const char *lvalue,
3030 const char *rvalue,
3031 void *data,
3032 void *userdata) {
3033
3034 pa_alsa_profile_set *ps = userdata;
3035 pa_alsa_mapping *m;
3036
3037 pa_assert(ps);
3038
3039 if (!(m = mapping_get(ps, section))) {
3040 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3041 return -1;
3042 }
3043
3044 if (!(pa_channel_map_parse(&m->channel_map, rvalue))) {
3045 pa_log("[%s:%u] Channel map invalid of '%s'", filename, line, section);
3046 return -1;
3047 }
3048
3049 return 0;
3050 }
3051
3052 static int mapping_parse_paths(
3053 const char *filename,
3054 unsigned line,
3055 const char *section,
3056 const char *lvalue,
3057 const char *rvalue,
3058 void *data,
3059 void *userdata) {
3060
3061 pa_alsa_profile_set *ps = userdata;
3062 pa_alsa_mapping *m;
3063
3064 pa_assert(ps);
3065
3066 if (!(m = mapping_get(ps, section))) {
3067 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3068 return -1;
3069 }
3070
3071 if (pa_streq(lvalue, "paths-input")) {
3072 pa_xstrfreev(m->input_path_names);
3073 m->input_path_names = pa_split_spaces_strv(rvalue);
3074 } else {
3075 pa_xstrfreev(m->output_path_names);
3076 m->output_path_names = pa_split_spaces_strv(rvalue);
3077 }
3078
3079 return 0;
3080 }
3081
3082 static int mapping_parse_element(
3083 const char *filename,
3084 unsigned line,
3085 const char *section,
3086 const char *lvalue,
3087 const char *rvalue,
3088 void *data,
3089 void *userdata) {
3090
3091 pa_alsa_profile_set *ps = userdata;
3092 pa_alsa_mapping *m;
3093
3094 pa_assert(ps);
3095
3096 if (!(m = mapping_get(ps, section))) {
3097 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3098 return -1;
3099 }
3100
3101 if (pa_streq(lvalue, "element-input")) {
3102 pa_xstrfreev(m->input_element);
3103 m->input_element = pa_split_spaces_strv(rvalue);
3104 } else {
3105 pa_xstrfreev(m->output_element);
3106 m->output_element = pa_split_spaces_strv(rvalue);
3107 }
3108
3109 return 0;
3110 }
3111
3112 static int mapping_parse_direction(
3113 const char *filename,
3114 unsigned line,
3115 const char *section,
3116 const char *lvalue,
3117 const char *rvalue,
3118 void *data,
3119 void *userdata) {
3120
3121 pa_alsa_profile_set *ps = userdata;
3122 pa_alsa_mapping *m;
3123
3124 pa_assert(ps);
3125
3126 if (!(m = mapping_get(ps, section))) {
3127 pa_log("[%s:%u] Section name %s invalid.", filename, line, section);
3128 return -1;
3129 }
3130
3131 if (pa_streq(rvalue, "input"))
3132 m->direction = PA_ALSA_DIRECTION_INPUT;
3133 else if (pa_streq(rvalue, "output"))
3134 m->direction = PA_ALSA_DIRECTION_OUTPUT;
3135 else if (pa_streq(rvalue, "any"))
3136 m->direction = PA_ALSA_DIRECTION_ANY;
3137 else {
3138 pa_log("[%s:%u] Direction %s invalid.", filename, line, rvalue);
3139 return -1;
3140 }
3141
3142 return 0;
3143 }
3144
3145 static int mapping_parse_description(
3146 const char *filename,
3147 unsigned line,
3148 const char *section,
3149 const char *lvalue,
3150 const char *rvalue,
3151 void *data,
3152 void *userdata) {
3153
3154 pa_alsa_profile_set *ps = userdata;
3155 pa_alsa_profile *p;
3156 pa_alsa_mapping *m;
3157
3158 pa_assert(ps);
3159
3160 if ((m = mapping_get(ps, section))) {
3161 pa_xfree(m->description);
3162 m->description = pa_xstrdup(rvalue);
3163 } else if ((p = profile_get(ps, section))) {
3164 pa_xfree(p->description);
3165 p->description = pa_xstrdup(rvalue);
3166 } else {
3167 pa_log("[%s:%u] Section name %s invalid.", filename, line, section);
3168 return -1;
3169 }
3170
3171 return 0;
3172 }
3173
3174 static int mapping_parse_priority(
3175 const char *filename,
3176 unsigned line,
3177 const char *section,
3178 const char *lvalue,
3179 const char *rvalue,
3180 void *data,
3181 void *userdata) {
3182
3183 pa_alsa_profile_set *ps = userdata;
3184 pa_alsa_profile *p;
3185 pa_alsa_mapping *m;
3186 uint32_t prio;
3187
3188 pa_assert(ps);
3189
3190 if (pa_atou(rvalue, &prio) < 0) {
3191 pa_log("[%s:%u] Priority invalid of '%s'", filename, line, section);
3192 return -1;
3193 }
3194
3195 if ((m = mapping_get(ps, section)))
3196 m->priority = prio;
3197 else if ((p = profile_get(ps, section)))
3198 p->priority = prio;
3199 else {
3200 pa_log("[%s:%u] Section name %s invalid.", filename, line, section);
3201 return -1;
3202 }
3203
3204 return 0;
3205 }
3206
3207 static int profile_parse_mappings(
3208 const char *filename,
3209 unsigned line,
3210 const char *section,
3211 const char *lvalue,
3212 const char *rvalue,
3213 void *data,
3214 void *userdata) {
3215
3216 pa_alsa_profile_set *ps = userdata;
3217 pa_alsa_profile *p;
3218
3219 pa_assert(ps);
3220
3221 if (!(p = profile_get(ps, section))) {
3222 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3223 return -1;
3224 }
3225
3226 if (pa_streq(lvalue, "input-mappings")) {
3227 pa_xstrfreev(p->input_mapping_names);
3228 p->input_mapping_names = pa_split_spaces_strv(rvalue);
3229 } else {
3230 pa_xstrfreev(p->output_mapping_names);
3231 p->output_mapping_names = pa_split_spaces_strv(rvalue);
3232 }
3233
3234 return 0;
3235 }
3236
3237 static int profile_parse_skip_probe(
3238 const char *filename,
3239 unsigned line,
3240 const char *section,
3241 const char *lvalue,
3242 const char *rvalue,
3243 void *data,
3244 void *userdata) {
3245
3246 pa_alsa_profile_set *ps = userdata;
3247 pa_alsa_profile *p;
3248 int b;
3249
3250 pa_assert(ps);
3251
3252 if (!(p = profile_get(ps, section))) {
3253 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3254 return -1;
3255 }
3256
3257 if ((b = pa_parse_boolean(rvalue)) < 0) {
3258 pa_log("[%s:%u] Skip probe invalid of '%s'", filename, line, section);
3259 return -1;
3260 }
3261
3262 p->supported = b;
3263
3264 return 0;
3265 }
3266
3267 static int decibel_fix_parse_db_values(
3268 const char *filename,
3269 unsigned line,
3270 const char *section,
3271 const char *lvalue,
3272 const char *rvalue,
3273 void *data,
3274 void *userdata) {
3275
3276 pa_alsa_profile_set *ps = userdata;
3277 pa_alsa_decibel_fix *db_fix;
3278 char **items;
3279 char *item;
3280 long *db_values;
3281 unsigned n = 8; /* Current size of the db_values table. */
3282 unsigned min_step = 0;
3283 unsigned max_step = 0;
3284 unsigned i = 0; /* Index to the items table. */
3285 unsigned prev_step = 0;
3286 double prev_db = 0;
3287
3288 pa_assert(filename);
3289 pa_assert(section);
3290 pa_assert(lvalue);
3291 pa_assert(rvalue);
3292 pa_assert(ps);
3293
3294 if (!(db_fix = decibel_fix_get(ps, section))) {
3295 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3296 return -1;
3297 }
3298
3299 if (!(items = pa_split_spaces_strv(rvalue))) {
3300 pa_log("[%s:%u] Value missing", pa_strnull(filename), line);
3301 return -1;
3302 }
3303
3304 db_values = pa_xnew(long, n);
3305
3306 while ((item = items[i++])) {
3307 char *s = item; /* Step value string. */
3308 char *d = item; /* dB value string. */
3309 uint32_t step;
3310 double db;
3311
3312 /* Move d forward until it points to a colon or to the end of the item. */
3313 for (; *d && *d != ':'; ++d);
3314
3315 if (d == s) {
3316 /* item started with colon. */
3317 pa_log("[%s:%u] No step value found in %s", filename, line, item);
3318 goto fail;
3319 }
3320
3321 if (!*d || !*(d + 1)) {
3322 /* No colon found, or it was the last character in item. */
3323 pa_log("[%s:%u] No dB value found in %s", filename, line, item);
3324 goto fail;
3325 }
3326
3327 /* pa_atou() needs a null-terminating string. Let's replace the colon
3328 * with a zero byte. */
3329 *d++ = '\0';
3330
3331 if (pa_atou(s, &step) < 0) {
3332 pa_log("[%s:%u] Invalid step value: %s", filename, line, s);
3333 goto fail;
3334 }
3335
3336 if (pa_atod(d, &db) < 0) {
3337 pa_log("[%s:%u] Invalid dB value: %s", filename, line, d);
3338 goto fail;
3339 }
3340
3341 if (step <= prev_step && i != 1) {
3342 pa_log("[%s:%u] Step value %u not greater than the previous value %u", filename, line, step, prev_step);
3343 goto fail;
3344 }
3345
3346 if (db < prev_db && i != 1) {
3347 pa_log("[%s:%u] Decibel value %0.2f less than the previous value %0.2f", filename, line, db, prev_db);
3348 goto fail;
3349 }
3350
3351 if (i == 1) {
3352 min_step = step;
3353 db_values[0] = (long) (db * 100.0);
3354 prev_step = step;
3355 prev_db = db;
3356 } else {
3357 /* Interpolate linearly. */
3358 double db_increment = (db - prev_db) / (step - prev_step);
3359
3360 for (; prev_step < step; ++prev_step, prev_db += db_increment) {
3361
3362 /* Reallocate the db_values table if it's about to overflow. */
3363 if (prev_step + 1 - min_step == n) {
3364 n *= 2;
3365 db_values = pa_xrenew(long, db_values, n);
3366 }
3367
3368 db_values[prev_step + 1 - min_step] = (long) ((prev_db + db_increment) * 100.0);
3369 }
3370 }
3371
3372 max_step = step;
3373 }
3374
3375 db_fix->min_step = min_step;
3376 db_fix->max_step = max_step;
3377 pa_xfree(db_fix->db_values);
3378 db_fix->db_values = db_values;
3379
3380 pa_xstrfreev(items);
3381
3382 return 0;
3383
3384 fail:
3385 pa_xstrfreev(items);
3386 pa_xfree(db_values);
3387
3388 return -1;
3389 }
3390
3391 static int mapping_verify(pa_alsa_mapping *m, const pa_channel_map *bonus) {
3392
3393 static const struct description_map well_known_descriptions[] = {
3394 { "analog-mono", N_("Analog Mono") },
3395 { "analog-stereo", N_("Analog Stereo") },
3396 { "analog-surround-21", N_("Analog Surround 2.1") },
3397 { "analog-surround-30", N_("Analog Surround 3.0") },
3398 { "analog-surround-31", N_("Analog Surround 3.1") },
3399 { "analog-surround-40", N_("Analog Surround 4.0") },
3400 { "analog-surround-41", N_("Analog Surround 4.1") },
3401 { "analog-surround-50", N_("Analog Surround 5.0") },
3402 { "analog-surround-51", N_("Analog Surround 5.1") },
3403 { "analog-surround-61", N_("Analog Surround 6.0") },
3404 { "analog-surround-61", N_("Analog Surround 6.1") },
3405 { "analog-surround-70", N_("Analog Surround 7.0") },
3406 { "analog-surround-71", N_("Analog Surround 7.1") },
3407 { "iec958-stereo", N_("Digital Stereo (IEC958)") },
3408 { "iec958-passthrough", N_("Digital Passthrough (IEC958)") },
3409 { "iec958-ac3-surround-40", N_("Digital Surround 4.0 (IEC958/AC3)") },
3410 { "iec958-ac3-surround-51", N_("Digital Surround 5.1 (IEC958/AC3)") },
3411 { "hdmi-stereo", N_("Digital Stereo (HDMI)") }
3412 };
3413
3414 pa_assert(m);
3415
3416 if (!pa_channel_map_valid(&m->channel_map)) {
3417 pa_log("Mapping %s is missing channel map.", m->name);
3418 return -1;
3419 }
3420
3421 if (!m->device_strings) {
3422 pa_log("Mapping %s is missing device strings.", m->name);
3423 return -1;
3424 }
3425
3426 if ((m->input_path_names && m->input_element) ||
3427 (m->output_path_names && m->output_element)) {
3428 pa_log("Mapping %s must have either mixer path or mixer element, not both.", m->name);
3429 return -1;
3430 }
3431
3432 if (!m->description)
3433 m->description = pa_xstrdup(lookup_description(m->name,
3434 well_known_descriptions,
3435 PA_ELEMENTSOF(well_known_descriptions)));
3436
3437 if (!m->description)
3438 m->description = pa_xstrdup(m->name);
3439
3440 if (bonus) {
3441 if (pa_channel_map_equal(&m->channel_map, bonus))
3442 m->priority += 50;
3443 else if (m->channel_map.channels == bonus->channels)
3444 m->priority += 30;
3445 }
3446
3447 return 0;
3448 }
3449
3450 void pa_alsa_mapping_dump(pa_alsa_mapping *m) {
3451 char cm[PA_CHANNEL_MAP_SNPRINT_MAX];
3452
3453 pa_assert(m);
3454
3455 pa_log_debug("Mapping %s (%s), priority=%u, channel_map=%s, supported=%s, direction=%i",
3456 m->name,
3457 pa_strnull(m->description),
3458 m->priority,
3459 pa_channel_map_snprint(cm, sizeof(cm), &m->channel_map),
3460 pa_yes_no(m->supported),
3461 m->direction);
3462 }
3463
3464 static void profile_set_add_auto_pair(
3465 pa_alsa_profile_set *ps,
3466 pa_alsa_mapping *m, /* output */
3467 pa_alsa_mapping *n /* input */) {
3468
3469 char *name;
3470 pa_alsa_profile *p;
3471
3472 pa_assert(ps);
3473 pa_assert(m || n);
3474
3475 if (m && m->direction == PA_ALSA_DIRECTION_INPUT)
3476 return;
3477
3478 if (n && n->direction == PA_ALSA_DIRECTION_OUTPUT)
3479 return;
3480
3481 if (m && n)
3482 name = pa_sprintf_malloc("output:%s+input:%s", m->name, n->name);
3483 else if (m)
3484 name = pa_sprintf_malloc("output:%s", m->name);
3485 else
3486 name = pa_sprintf_malloc("input:%s", n->name);
3487
3488 if (pa_hashmap_get(ps->profiles, name)) {
3489 pa_xfree(name);
3490 return;
3491 }
3492
3493 p = pa_xnew0(pa_alsa_profile, 1);
3494 p->profile_set = ps;
3495 p->name = name;
3496
3497 if (m) {
3498 p->output_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
3499 pa_idxset_put(p->output_mappings, m, NULL);
3500 p->priority += m->priority * 100;
3501 }
3502
3503 if (n) {
3504 p->input_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
3505 pa_idxset_put(p->input_mappings, n, NULL);
3506 p->priority += n->priority;
3507 }
3508
3509 pa_hashmap_put(ps->profiles, p->name, p);
3510 }
3511
3512 static void profile_set_add_auto(pa_alsa_profile_set *ps) {
3513 pa_alsa_mapping *m, *n;
3514 void *m_state, *n_state;
3515
3516 pa_assert(ps);
3517
3518 PA_HASHMAP_FOREACH(m, ps->mappings, m_state) {
3519 profile_set_add_auto_pair(ps, m, NULL);
3520
3521 PA_HASHMAP_FOREACH(n, ps->mappings, n_state)
3522 profile_set_add_auto_pair(ps, m, n);
3523 }
3524
3525 PA_HASHMAP_FOREACH(n, ps->mappings, n_state)
3526 profile_set_add_auto_pair(ps, NULL, n);
3527 }
3528
3529 static int profile_verify(pa_alsa_profile *p) {
3530
3531 static const struct description_map well_known_descriptions[] = {
3532 { "output:analog-mono+input:analog-mono", N_("Analog Mono Duplex") },
3533 { "output:analog-stereo+input:analog-stereo", N_("Analog Stereo Duplex") },
3534 { "output:iec958-stereo+input:iec958-stereo", N_("Digital Stereo Duplex (IEC958)") },
3535 { "off", N_("Off") }
3536 };
3537
3538 pa_assert(p);
3539
3540 /* Replace the output mapping names by the actual mappings */
3541 if (p->output_mapping_names) {
3542 char **name;
3543
3544 pa_assert(!p->output_mappings);
3545 p->output_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
3546
3547 for (name = p->output_mapping_names; *name; name++) {
3548 pa_alsa_mapping *m;
3549 char **in;
3550 pa_bool_t duplicate = FALSE;
3551
3552 for (in = name + 1; *in; in++)
3553 if (pa_streq(*name, *in)) {
3554 duplicate = TRUE;
3555 break;
3556 }
3557
3558 if (duplicate)
3559 continue;
3560
3561 if (!(m = pa_hashmap_get(p->profile_set->mappings, *name)) || m->direction == PA_ALSA_DIRECTION_INPUT) {
3562 pa_log("Profile '%s' refers to unexistant mapping '%s'.", p->name, *name);
3563 return -1;
3564 }
3565
3566 pa_idxset_put(p->output_mappings, m, NULL);
3567
3568 if (p->supported)
3569 m->supported++;
3570 }
3571
3572 pa_xstrfreev(p->output_mapping_names);
3573 p->output_mapping_names = NULL;
3574 }
3575
3576 /* Replace the input mapping names by the actual mappings */
3577 if (p->input_mapping_names) {
3578 char **name;
3579
3580 pa_assert(!p->input_mappings);
3581 p->input_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
3582
3583 for (name = p->input_mapping_names; *name; name++) {
3584 pa_alsa_mapping *m;
3585 char **in;
3586 pa_bool_t duplicate = FALSE;
3587
3588 for (in = name + 1; *in; in++)
3589 if (pa_streq(*name, *in)) {
3590 duplicate = TRUE;
3591 break;
3592 }
3593
3594 if (duplicate)
3595 continue;
3596
3597 if (!(m = pa_hashmap_get(p->profile_set->mappings, *name)) || m->direction == PA_ALSA_DIRECTION_OUTPUT) {
3598 pa_log("Profile '%s' refers to unexistant mapping '%s'.", p->name, *name);
3599 return -1;
3600 }
3601
3602 pa_idxset_put(p->input_mappings, m, NULL);
3603
3604 if (p->supported)
3605 m->supported++;
3606 }
3607
3608 pa_xstrfreev(p->input_mapping_names);
3609 p->input_mapping_names = NULL;
3610 }
3611
3612 if (!p->input_mappings && !p->output_mappings) {
3613 pa_log("Profile '%s' lacks mappings.", p->name);
3614 return -1;
3615 }
3616
3617 if (!p->description)
3618 p->description = pa_xstrdup(lookup_description(p->name,
3619 well_known_descriptions,
3620 PA_ELEMENTSOF(well_known_descriptions)));
3621
3622 if (!p->description) {
3623 pa_strbuf *sb;
3624 uint32_t idx;
3625 pa_alsa_mapping *m;
3626
3627 sb = pa_strbuf_new();
3628
3629 if (p->output_mappings)
3630 PA_IDXSET_FOREACH(m, p->output_mappings, idx) {
3631 if (!pa_strbuf_isempty(sb))
3632 pa_strbuf_puts(sb, " + ");
3633
3634 pa_strbuf_printf(sb, _("%s Output"), m->description);
3635 }
3636
3637 if (p->input_mappings)
3638 PA_IDXSET_FOREACH(m, p->input_mappings, idx) {
3639 if (!pa_strbuf_isempty(sb))
3640 pa_strbuf_puts(sb, " + ");
3641
3642 pa_strbuf_printf(sb, _("%s Input"), m->description);
3643 }
3644
3645 p->description = pa_strbuf_tostring_free(sb);
3646 }
3647
3648 return 0;
3649 }
3650
3651 void pa_alsa_profile_dump(pa_alsa_profile *p) {
3652 uint32_t idx;
3653 pa_alsa_mapping *m;
3654 pa_assert(p);
3655
3656 pa_log_debug("Profile %s (%s), priority=%u, supported=%s n_input_mappings=%u, n_output_mappings=%u",
3657 p->name,
3658 pa_strnull(p->description),
3659 p->priority,
3660 pa_yes_no(p->supported),
3661 p->input_mappings ? pa_idxset_size(p->input_mappings) : 0,
3662 p->output_mappings ? pa_idxset_size(p->output_mappings) : 0);
3663
3664 if (p->input_mappings)
3665 PA_IDXSET_FOREACH(m, p->input_mappings, idx)
3666 pa_log_debug("Input %s", m->name);
3667
3668 if (p->output_mappings)
3669 PA_IDXSET_FOREACH(m, p->output_mappings, idx)
3670 pa_log_debug("Output %s", m->name);
3671 }
3672
3673 static int decibel_fix_verify(pa_alsa_decibel_fix *db_fix) {
3674 pa_assert(db_fix);
3675
3676 /* Check that the dB mapping has been configured. Since "db-values" is
3677 * currently the only option in the DecibelFix section, and decibel fix
3678 * objects don't get created if a DecibelFix section is empty, this is
3679 * actually a redundant check. Having this may prevent future bugs,
3680 * however. */
3681 if (!db_fix->db_values) {
3682 pa_log("Decibel fix for element %s lacks the dB values.", db_fix->name);
3683 return -1;
3684 }
3685
3686 return 0;
3687 }
3688
3689 void pa_alsa_decibel_fix_dump(pa_alsa_decibel_fix *db_fix) {
3690 char *db_values = NULL;
3691
3692 pa_assert(db_fix);
3693
3694 if (db_fix->db_values) {
3695 pa_strbuf *buf;
3696 unsigned long i, nsteps;
3697
3698 pa_assert(db_fix->min_step <= db_fix->max_step);
3699 nsteps = db_fix->max_step - db_fix->min_step + 1;
3700
3701 buf = pa_strbuf_new();
3702 for (i = 0; i < nsteps; ++i)
3703 pa_strbuf_printf(buf, "[%li]:%0.2f ", i + db_fix->min_step, db_fix->db_values[i] / 100.0);
3704
3705 db_values = pa_strbuf_tostring_free(buf);
3706 }
3707
3708 pa_log_debug("Decibel fix %s, min_step=%li, max_step=%li, db_values=%s",
3709 db_fix->name, db_fix->min_step, db_fix->max_step, pa_strnull(db_values));
3710
3711 pa_xfree(db_values);
3712 }
3713
3714 pa_alsa_profile_set* pa_alsa_profile_set_new(const char *fname, const pa_channel_map *bonus) {
3715 pa_alsa_profile_set *ps;
3716 pa_alsa_profile *p;
3717 pa_alsa_mapping *m;
3718 pa_alsa_decibel_fix *db_fix;
3719 char *fn;
3720 int r;
3721 void *state;
3722
3723 static pa_config_item items[] = {
3724 /* [General] */
3725 { "auto-profiles", pa_config_parse_bool, NULL, "General" },
3726
3727 /* [Mapping ...] */
3728 { "device-strings", mapping_parse_device_strings, NULL, NULL },
3729 { "channel-map", mapping_parse_channel_map, NULL, NULL },
3730 { "paths-input", mapping_parse_paths, NULL, NULL },
3731 { "paths-output", mapping_parse_paths, NULL, NULL },
3732 { "element-input", mapping_parse_element, NULL, NULL },
3733 { "element-output", mapping_parse_element, NULL, NULL },
3734 { "direction", mapping_parse_direction, NULL, NULL },
3735
3736 /* Shared by [Mapping ...] and [Profile ...] */
3737 { "description", mapping_parse_description, NULL, NULL },
3738 { "priority", mapping_parse_priority, NULL, NULL },
3739
3740 /* [Profile ...] */
3741 { "input-mappings", profile_parse_mappings, NULL, NULL },
3742 { "output-mappings", profile_parse_mappings, NULL, NULL },
3743 { "skip-probe", profile_parse_skip_probe, NULL, NULL },
3744
3745 /* [DecibelFix ...] */
3746 { "db-values", decibel_fix_parse_db_values, NULL, NULL },
3747 { NULL, NULL, NULL, NULL }
3748 };
3749
3750 ps = pa_xnew0(pa_alsa_profile_set, 1);
3751 ps->mappings = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
3752 ps->profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
3753 ps->decibel_fixes = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
3754
3755 items[0].data = &ps->auto_profiles;
3756
3757 if (!fname)
3758 fname = "default.conf";
3759
3760 fn = pa_maybe_prefix_path(fname,
3761 pa_run_from_build_tree() ? PA_BUILDDIR "/modules/alsa/mixer/profile-sets/" :
3762 PA_ALSA_PROFILE_SETS_DIR);
3763
3764 r = pa_config_parse(fn, NULL, items, ps);
3765 pa_xfree(fn);
3766
3767 if (r < 0)
3768 goto fail;
3769
3770 PA_HASHMAP_FOREACH(m, ps->mappings, state)
3771 if (mapping_verify(m, bonus) < 0)
3772 goto fail;
3773
3774 if (ps->auto_profiles)
3775 profile_set_add_auto(ps);
3776
3777 PA_HASHMAP_FOREACH(p, ps->profiles, state)
3778 if (profile_verify(p) < 0)
3779 goto fail;
3780
3781 PA_HASHMAP_FOREACH(db_fix, ps->decibel_fixes, state)
3782 if (decibel_fix_verify(db_fix) < 0)
3783 goto fail;
3784
3785 return ps;
3786
3787 fail:
3788 pa_alsa_profile_set_free(ps);
3789 return NULL;
3790 }
3791
3792 void pa_alsa_profile_set_probe(
3793 pa_alsa_profile_set *ps,
3794 const char *dev_id,
3795 const pa_sample_spec *ss,
3796 unsigned default_n_fragments,
3797 unsigned default_fragment_size_msec) {
3798
3799 void *state;
3800 pa_alsa_profile *p, *last = NULL;
3801 pa_alsa_mapping *m;
3802
3803 pa_assert(ps);
3804 pa_assert(dev_id);
3805 pa_assert(ss);
3806
3807 if (ps->probed)
3808 return;
3809
3810 PA_HASHMAP_FOREACH(p, ps->profiles, state) {
3811 pa_sample_spec try_ss;
3812 pa_channel_map try_map;
3813 snd_pcm_uframes_t try_period_size, try_buffer_size;
3814 uint32_t idx;
3815
3816 /* Is this already marked that it is supported? (i.e. from the config file) */
3817 if (p->supported)
3818 continue;
3819
3820 pa_log_debug("Looking at profile %s", p->name);
3821
3822 /* Close PCMs from the last iteration we don't need anymore */
3823 if (last && last->output_mappings)
3824 PA_IDXSET_FOREACH(m, last->output_mappings, idx) {
3825
3826 if (!m->output_pcm)
3827 break;
3828
3829 if (last->supported)
3830 m->supported++;
3831
3832 if (!p->output_mappings || !pa_idxset_get_by_data(p->output_mappings, m, NULL)) {
3833 snd_pcm_close(m->output_pcm);
3834 m->output_pcm = NULL;
3835 }
3836 }
3837
3838 if (last && last->input_mappings)
3839 PA_IDXSET_FOREACH(m, last->input_mappings, idx) {
3840
3841 if (!m->input_pcm)
3842 break;
3843
3844 if (last->supported)
3845 m->supported++;
3846
3847 if (!p->input_mappings || !pa_idxset_get_by_data(p->input_mappings, m, NULL)) {
3848 snd_pcm_close(m->input_pcm);
3849 m->input_pcm = NULL;
3850 }
3851 }
3852
3853 p->supported = TRUE;
3854
3855 /* Check if we can open all new ones */
3856 if (p->output_mappings)
3857 PA_IDXSET_FOREACH(m, p->output_mappings, idx) {
3858
3859 if (m->output_pcm)
3860 continue;
3861
3862 pa_log_debug("Checking for playback on %s (%s)", m->description, m->name);
3863 try_map = m->channel_map;
3864 try_ss = *ss;
3865 try_ss.channels = try_map.channels;
3866
3867 try_period_size =
3868 pa_usec_to_bytes(default_fragment_size_msec * PA_USEC_PER_MSEC, &try_ss) /
3869 pa_frame_size(&try_ss);
3870 try_buffer_size = default_n_fragments * try_period_size;
3871
3872 if (!(m ->output_pcm = pa_alsa_open_by_template(
3873 m->device_strings,
3874 dev_id,
3875 NULL,
3876 &try_ss, &try_map,
3877 SND_PCM_STREAM_PLAYBACK,
3878 &try_period_size, &try_buffer_size, 0, NULL, NULL,
3879 TRUE))) {
3880 p->supported = FALSE;
3881 break;
3882 }
3883 }
3884
3885 if (p->input_mappings && p->supported)
3886 PA_IDXSET_FOREACH(m, p->input_mappings, idx) {
3887
3888 if (m->input_pcm)
3889 continue;
3890
3891 pa_log_debug("Checking for recording on %s (%s)", m->description, m->name);
3892 try_map = m->channel_map;
3893 try_ss = *ss;
3894 try_ss.channels = try_map.channels;
3895
3896 try_period_size =
3897 pa_usec_to_bytes(default_fragment_size_msec*PA_USEC_PER_MSEC, &try_ss) /
3898 pa_frame_size(&try_ss);
3899 try_buffer_size = default_n_fragments * try_period_size;
3900
3901 if (!(m ->input_pcm = pa_alsa_open_by_template(
3902 m->device_strings,
3903 dev_id,
3904 NULL,
3905 &try_ss, &try_map,
3906 SND_PCM_STREAM_CAPTURE,
3907 &try_period_size, &try_buffer_size, 0, NULL, NULL,
3908 TRUE))) {
3909 p->supported = FALSE;
3910 break;
3911 }
3912 }
3913
3914 last = p;
3915
3916 if (p->supported)
3917 pa_log_debug("Profile %s supported.", p->name);
3918 }
3919
3920 /* Clean up */
3921 if (last) {
3922 uint32_t idx;
3923
3924 if (last->output_mappings)
3925 PA_IDXSET_FOREACH(m, last->output_mappings, idx)
3926 if (m->output_pcm) {
3927
3928 if (last->supported)
3929 m->supported++;
3930
3931 snd_pcm_close(m->output_pcm);
3932 m->output_pcm = NULL;
3933 }
3934
3935 if (last->input_mappings)
3936 PA_IDXSET_FOREACH(m, last->input_mappings, idx)
3937 if (m->input_pcm) {
3938
3939 if (last->supported)
3940 m->supported++;
3941
3942 snd_pcm_close(m->input_pcm);
3943 m->input_pcm = NULL;
3944 }
3945 }
3946
3947 PA_HASHMAP_FOREACH(p, ps->profiles, state)
3948 if (!p->supported) {
3949 pa_hashmap_remove(ps->profiles, p->name);
3950 profile_free(p);
3951 }
3952
3953 PA_HASHMAP_FOREACH(m, ps->mappings, state)
3954 if (m->supported <= 0) {
3955 pa_hashmap_remove(ps->mappings, m->name);
3956 mapping_free(m);
3957 }
3958
3959 ps->probed = TRUE;
3960 }
3961
3962 void pa_alsa_profile_set_dump(pa_alsa_profile_set *ps) {
3963 pa_alsa_profile *p;
3964 pa_alsa_mapping *m;
3965 pa_alsa_decibel_fix *db_fix;
3966 void *state;
3967
3968 pa_assert(ps);
3969
3970 pa_log_debug("Profile set %p, auto_profiles=%s, probed=%s, n_mappings=%u, n_profiles=%u, n_decibel_fixes=%u",
3971 (void*)
3972 ps,
3973 pa_yes_no(ps->auto_profiles),
3974 pa_yes_no(ps->probed),
3975 pa_hashmap_size(ps->mappings),
3976 pa_hashmap_size(ps->profiles),
3977 pa_hashmap_size(ps->decibel_fixes));
3978
3979 PA_HASHMAP_FOREACH(m, ps->mappings, state)
3980 pa_alsa_mapping_dump(m);
3981
3982 PA_HASHMAP_FOREACH(p, ps->profiles, state)
3983 pa_alsa_profile_dump(p);
3984
3985 PA_HASHMAP_FOREACH(db_fix, ps->decibel_fixes, state)
3986 pa_alsa_decibel_fix_dump(db_fix);
3987 }
3988
3989 void pa_alsa_add_ports(pa_hashmap **p, pa_alsa_path_set *ps) {
3990 pa_alsa_path *path;
3991
3992 pa_assert(p);
3993 pa_assert(!*p);
3994 pa_assert(ps);
3995
3996 /* if there is no path, we don't want a port list */
3997 if (!ps->paths)
3998 return;
3999
4000 if (!ps->paths->next){
4001 pa_alsa_setting *s;
4002
4003 /* If there is only one path, but no or only one setting, then
4004 * we want a port list either */
4005 if (!ps->paths->settings || !ps->paths->settings->next)
4006 return;
4007
4008 /* Ok, there is only one path, however with multiple settings,
4009 * so let's create a port for each setting */
4010 *p = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
4011
4012 PA_LLIST_FOREACH(s, ps->paths->settings) {
4013 pa_device_port *port;
4014 pa_alsa_port_data *data;
4015
4016 port = pa_device_port_new(s->name, s->description, sizeof(pa_alsa_port_data));
4017 port->priority = s->priority;
4018
4019 data = PA_DEVICE_PORT_DATA(port);
4020 data->path = ps->paths;
4021 data->setting = s;
4022
4023 pa_hashmap_put(*p, port->name, port);
4024 }
4025
4026 } else {
4027
4028 /* We have multiple paths, so let's create a port for each
4029 * one, and each of each settings */
4030 *p = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
4031
4032 PA_LLIST_FOREACH(path, ps->paths) {
4033
4034 if (!path->settings || !path->settings->next) {
4035 pa_device_port *port;
4036 pa_alsa_port_data *data;
4037
4038 /* If there is no or just one setting we only need a
4039 * single entry */
4040
4041 port = pa_device_port_new(path->name, path->description, sizeof(pa_alsa_port_data));
4042 port->priority = path->priority * 100;
4043
4044
4045 data = PA_DEVICE_PORT_DATA(port);
4046 data->path = path;
4047 data->setting = path->settings;
4048
4049 pa_hashmap_put(*p, port->name, port);
4050 } else {
4051 pa_alsa_setting *s;
4052
4053 PA_LLIST_FOREACH(s, path->settings) {
4054 pa_device_port *port;
4055 pa_alsa_port_data *data;
4056 char *n, *d;
4057
4058 n = pa_sprintf_malloc("%s;%s", path->name, s->name);
4059
4060 if (s->description[0])
4061 d = pa_sprintf_malloc(_("%s / %s"), path->description, s->description);
4062 else
4063 d = pa_xstrdup(path->description);
4064
4065 port = pa_device_port_new(n, d, sizeof(pa_alsa_port_data));
4066 port->priority = path->priority * 100 + s->priority;
4067
4068 pa_xfree(n);
4069 pa_xfree(d);
4070
4071 data = PA_DEVICE_PORT_DATA(port);
4072 data->path = path;
4073 data->setting = s;
4074
4075 pa_hashmap_put(*p, port->name, port);
4076 }
4077 }
4078 }
4079 }
4080
4081 pa_log_debug("Added %u ports", pa_hashmap_size(*p));
4082 }