]> 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
Merge remote-tracking branch 'mkbosmans/mingw32-build'
[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 static int element_mute_volume(pa_alsa_element *e, snd_mixer_t *m) {
1088 snd_mixer_elem_t *me;
1089 snd_mixer_selem_id_t *sid;
1090 int r;
1091
1092 pa_assert(m);
1093 pa_assert(e);
1094
1095 SELEM_INIT(sid, e->alsa_name);
1096 if (!(me = snd_mixer_find_selem(m, sid))) {
1097 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
1098 return -1;
1099 }
1100
1101 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1102 r = snd_mixer_selem_set_playback_volume_all(me, e->min_volume);
1103 else
1104 r = snd_mixer_selem_set_capture_volume_all(me, e->min_volume);
1105
1106 if (r < 0)
1107 pa_log_warn("Failed to set volume to muted of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
1108
1109 return r;
1110 }
1111
1112 /* The volume to 0dB */
1113 static int element_zero_volume(pa_alsa_element *e, snd_mixer_t *m) {
1114 snd_mixer_elem_t *me;
1115 snd_mixer_selem_id_t *sid;
1116 int r;
1117
1118 pa_assert(m);
1119 pa_assert(e);
1120
1121 SELEM_INIT(sid, e->alsa_name);
1122 if (!(me = snd_mixer_find_selem(m, sid))) {
1123 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
1124 return -1;
1125 }
1126
1127 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1128 if (e->db_fix) {
1129 long value = 0;
1130
1131 r = snd_mixer_selem_set_playback_volume_all(me, decibel_fix_get_step(e->db_fix, &value, +1));
1132 } else
1133 r = snd_mixer_selem_set_playback_dB_all(me, 0, +1);
1134 else
1135 if (e->db_fix) {
1136 long value = 0;
1137
1138 r = snd_mixer_selem_set_capture_volume_all(me, decibel_fix_get_step(e->db_fix, &value, +1));
1139 } else
1140 r = snd_mixer_selem_set_capture_dB_all(me, 0, +1);
1141
1142 if (r < 0)
1143 pa_log_warn("Failed to set volume to 0dB of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
1144
1145 return r;
1146 }
1147
1148 int pa_alsa_path_select(pa_alsa_path *p, snd_mixer_t *m) {
1149 pa_alsa_element *e;
1150 int r = 0;
1151
1152 pa_assert(m);
1153 pa_assert(p);
1154
1155 pa_log_debug("Activating path %s", p->name);
1156 pa_alsa_path_dump(p);
1157
1158 PA_LLIST_FOREACH(e, p->elements) {
1159
1160 switch (e->switch_use) {
1161 case PA_ALSA_SWITCH_OFF:
1162 r = element_set_switch(e, m, FALSE);
1163 break;
1164
1165 case PA_ALSA_SWITCH_ON:
1166 r = element_set_switch(e, m, TRUE);
1167 break;
1168
1169 case PA_ALSA_SWITCH_MUTE:
1170 case PA_ALSA_SWITCH_IGNORE:
1171 case PA_ALSA_SWITCH_SELECT:
1172 r = 0;
1173 break;
1174 }
1175
1176 if (r < 0)
1177 return -1;
1178
1179 switch (e->volume_use) {
1180 case PA_ALSA_VOLUME_OFF:
1181 r = element_mute_volume(e, m);
1182 break;
1183
1184 case PA_ALSA_VOLUME_ZERO:
1185 r = element_zero_volume(e, m);
1186 break;
1187
1188 case PA_ALSA_VOLUME_MERGE:
1189 case PA_ALSA_VOLUME_IGNORE:
1190 r = 0;
1191 break;
1192 }
1193
1194 if (r < 0)
1195 return -1;
1196 }
1197
1198 return 0;
1199 }
1200
1201 static int check_required(pa_alsa_element *e, snd_mixer_elem_t *me) {
1202 pa_bool_t has_switch;
1203 pa_bool_t has_enumeration;
1204 pa_bool_t has_volume;
1205
1206 pa_assert(e);
1207 pa_assert(me);
1208
1209 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
1210 has_switch =
1211 snd_mixer_selem_has_playback_switch(me) ||
1212 (e->direction_try_other && snd_mixer_selem_has_capture_switch(me));
1213 } else {
1214 has_switch =
1215 snd_mixer_selem_has_capture_switch(me) ||
1216 (e->direction_try_other && snd_mixer_selem_has_playback_switch(me));
1217 }
1218
1219 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
1220 has_volume =
1221 snd_mixer_selem_has_playback_volume(me) ||
1222 (e->direction_try_other && snd_mixer_selem_has_capture_volume(me));
1223 } else {
1224 has_volume =
1225 snd_mixer_selem_has_capture_volume(me) ||
1226 (e->direction_try_other && snd_mixer_selem_has_playback_volume(me));
1227 }
1228
1229 has_enumeration = snd_mixer_selem_is_enumerated(me);
1230
1231 if ((e->required == PA_ALSA_REQUIRED_SWITCH && !has_switch) ||
1232 (e->required == PA_ALSA_REQUIRED_VOLUME && !has_volume) ||
1233 (e->required == PA_ALSA_REQUIRED_ENUMERATION && !has_enumeration))
1234 return -1;
1235
1236 if (e->required == PA_ALSA_REQUIRED_ANY && !(has_switch || has_volume || has_enumeration))
1237 return -1;
1238
1239 if ((e->required_absent == PA_ALSA_REQUIRED_SWITCH && has_switch) ||
1240 (e->required_absent == PA_ALSA_REQUIRED_VOLUME && has_volume) ||
1241 (e->required_absent == PA_ALSA_REQUIRED_ENUMERATION && has_enumeration))
1242 return -1;
1243
1244 if (e->required_absent == PA_ALSA_REQUIRED_ANY && (has_switch || has_volume || has_enumeration))
1245 return -1;
1246
1247 if (e->required_any != PA_ALSA_REQUIRED_IGNORE) {
1248 switch (e->required_any) {
1249 case PA_ALSA_REQUIRED_VOLUME:
1250 e->path->req_any_present |= (e->volume_use != PA_ALSA_VOLUME_IGNORE);
1251 break;
1252 case PA_ALSA_REQUIRED_SWITCH:
1253 e->path->req_any_present |= (e->switch_use != PA_ALSA_SWITCH_IGNORE);
1254 break;
1255 case PA_ALSA_REQUIRED_ENUMERATION:
1256 e->path->req_any_present |= (e->enumeration_use != PA_ALSA_ENUMERATION_IGNORE);
1257 break;
1258 case PA_ALSA_REQUIRED_ANY:
1259 e->path->req_any_present |=
1260 (e->volume_use != PA_ALSA_VOLUME_IGNORE) ||
1261 (e->switch_use != PA_ALSA_SWITCH_IGNORE) ||
1262 (e->enumeration_use != PA_ALSA_ENUMERATION_IGNORE);
1263 break;
1264 default:
1265 pa_assert_not_reached();
1266 }
1267 }
1268
1269 if (e->enumeration_use == PA_ALSA_ENUMERATION_SELECT) {
1270 pa_alsa_option *o;
1271 PA_LLIST_FOREACH(o, e->options) {
1272 e->path->req_any_present |= (o->required_any != PA_ALSA_REQUIRED_IGNORE) &&
1273 (o->alsa_idx >= 0);
1274 if (o->required != PA_ALSA_REQUIRED_IGNORE && o->alsa_idx < 0)
1275 return -1;
1276 if (o->required_absent != PA_ALSA_REQUIRED_IGNORE && o->alsa_idx >= 0)
1277 return -1;
1278 }
1279 }
1280
1281 return 0;
1282 }
1283
1284 static int element_probe(pa_alsa_element *e, snd_mixer_t *m) {
1285 snd_mixer_selem_id_t *sid;
1286 snd_mixer_elem_t *me;
1287
1288 pa_assert(m);
1289 pa_assert(e);
1290 pa_assert(e->path);
1291
1292 SELEM_INIT(sid, e->alsa_name);
1293
1294 if (!(me = snd_mixer_find_selem(m, sid))) {
1295
1296 if (e->required != PA_ALSA_REQUIRED_IGNORE)
1297 return -1;
1298
1299 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1300 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1301 e->enumeration_use = PA_ALSA_ENUMERATION_IGNORE;
1302
1303 return 0;
1304 }
1305
1306 if (e->switch_use != PA_ALSA_SWITCH_IGNORE) {
1307 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
1308
1309 if (!snd_mixer_selem_has_playback_switch(me)) {
1310 if (e->direction_try_other && snd_mixer_selem_has_capture_switch(me))
1311 e->direction = PA_ALSA_DIRECTION_INPUT;
1312 else
1313 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1314 }
1315
1316 } else {
1317
1318 if (!snd_mixer_selem_has_capture_switch(me)) {
1319 if (e->direction_try_other && snd_mixer_selem_has_playback_switch(me))
1320 e->direction = PA_ALSA_DIRECTION_OUTPUT;
1321 else
1322 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1323 }
1324 }
1325
1326 if (e->switch_use != PA_ALSA_SWITCH_IGNORE)
1327 e->direction_try_other = FALSE;
1328 }
1329
1330 if (e->volume_use != PA_ALSA_VOLUME_IGNORE) {
1331
1332 if (e->direction == PA_ALSA_DIRECTION_OUTPUT) {
1333
1334 if (!snd_mixer_selem_has_playback_volume(me)) {
1335 if (e->direction_try_other && snd_mixer_selem_has_capture_volume(me))
1336 e->direction = PA_ALSA_DIRECTION_INPUT;
1337 else
1338 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1339 }
1340
1341 } else {
1342
1343 if (!snd_mixer_selem_has_capture_volume(me)) {
1344 if (e->direction_try_other && snd_mixer_selem_has_playback_volume(me))
1345 e->direction = PA_ALSA_DIRECTION_OUTPUT;
1346 else
1347 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1348 }
1349 }
1350
1351 if (e->volume_use != PA_ALSA_VOLUME_IGNORE) {
1352 long min_dB = 0, max_dB = 0;
1353 int r;
1354
1355 e->direction_try_other = FALSE;
1356
1357 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1358 r = snd_mixer_selem_get_playback_volume_range(me, &e->min_volume, &e->max_volume);
1359 else
1360 r = snd_mixer_selem_get_capture_volume_range(me, &e->min_volume, &e->max_volume);
1361
1362 if (r < 0) {
1363 pa_log_warn("Failed to get volume range of %s: %s", e->alsa_name, pa_alsa_strerror(r));
1364 return -1;
1365 }
1366
1367 if (e->min_volume >= e->max_volume) {
1368 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);
1369 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1370
1371 } else {
1372 pa_bool_t is_mono;
1373 pa_channel_position_t p;
1374
1375 if (e->db_fix &&
1376 ((e->min_volume > e->db_fix->min_step) ||
1377 (e->max_volume < e->db_fix->max_step))) {
1378 pa_log_warn("The step range of the decibel fix for element %s (%li-%li) doesn't fit to the "
1379 "real hardware range (%li-%li). Disabling the decibel fix.", e->alsa_name,
1380 e->db_fix->min_step, e->db_fix->max_step,
1381 e->min_volume, e->max_volume);
1382
1383 decibel_fix_free(e->db_fix);
1384 e->db_fix = NULL;
1385 }
1386
1387 if (e->db_fix) {
1388 e->has_dB = TRUE;
1389 e->min_volume = e->db_fix->min_step;
1390 e->max_volume = e->db_fix->max_step;
1391 min_dB = e->db_fix->db_values[0];
1392 max_dB = e->db_fix->db_values[e->db_fix->max_step - e->db_fix->min_step];
1393 } else if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1394 e->has_dB = snd_mixer_selem_get_playback_dB_range(me, &min_dB, &max_dB) >= 0;
1395 else
1396 e->has_dB = snd_mixer_selem_get_capture_dB_range(me, &min_dB, &max_dB) >= 0;
1397
1398 if (e->has_dB) {
1399 #ifdef HAVE_VALGRIND_MEMCHECK_H
1400 VALGRIND_MAKE_MEM_DEFINED(&min_dB, sizeof(min_dB));
1401 VALGRIND_MAKE_MEM_DEFINED(&max_dB, sizeof(max_dB));
1402 #endif
1403
1404 e->min_dB = ((double) min_dB) / 100.0;
1405 e->max_dB = ((double) max_dB) / 100.0;
1406
1407 if (min_dB >= max_dB) {
1408 pa_assert(!e->db_fix);
1409 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);
1410 e->has_dB = FALSE;
1411 }
1412 }
1413
1414 if (e->volume_limit >= 0) {
1415 if (e->volume_limit <= e->min_volume || e->volume_limit > e->max_volume)
1416 pa_log_warn("Volume limit for element %s of path %s is invalid: %li isn't within the valid range "
1417 "%li-%li. The volume limit is ignored.",
1418 e->alsa_name, e->path->name, e->volume_limit, e->min_volume + 1, e->max_volume);
1419
1420 else {
1421 e->max_volume = e->volume_limit;
1422
1423 if (e->has_dB) {
1424 if (e->db_fix) {
1425 e->db_fix->max_step = e->max_volume;
1426 e->max_dB = ((double) e->db_fix->db_values[e->db_fix->max_step - e->db_fix->min_step]) / 100.0;
1427
1428 } else {
1429 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1430 r = snd_mixer_selem_ask_playback_vol_dB(me, e->max_volume, &max_dB);
1431 else
1432 r = snd_mixer_selem_ask_capture_vol_dB(me, e->max_volume, &max_dB);
1433
1434 if (r < 0) {
1435 pa_log_warn("Failed to get dB value of %s: %s", e->alsa_name, pa_alsa_strerror(r));
1436 e->has_dB = FALSE;
1437 } else
1438 e->max_dB = ((double) max_dB) / 100.0;
1439 }
1440 }
1441 }
1442 }
1443
1444 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1445 is_mono = snd_mixer_selem_is_playback_mono(me) > 0;
1446 else
1447 is_mono = snd_mixer_selem_is_capture_mono(me) > 0;
1448
1449 if (is_mono) {
1450 e->n_channels = 1;
1451
1452 if (!e->override_map) {
1453 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++)
1454 e->masks[alsa_channel_ids[p]][e->n_channels-1] = 0;
1455 e->masks[SND_MIXER_SCHN_MONO][e->n_channels-1] = PA_CHANNEL_POSITION_MASK_ALL;
1456 }
1457
1458 e->merged_mask = e->masks[SND_MIXER_SCHN_MONO][e->n_channels-1];
1459 } else {
1460 e->n_channels = 0;
1461 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++) {
1462
1463 if (alsa_channel_ids[p] == SND_MIXER_SCHN_UNKNOWN)
1464 continue;
1465
1466 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1467 e->n_channels += snd_mixer_selem_has_playback_channel(me, alsa_channel_ids[p]) > 0;
1468 else
1469 e->n_channels += snd_mixer_selem_has_capture_channel(me, alsa_channel_ids[p]) > 0;
1470 }
1471
1472 if (e->n_channels <= 0) {
1473 pa_log_warn("Volume element %s with no channels?", e->alsa_name);
1474 return -1;
1475 }
1476
1477 if (!e->override_map) {
1478 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++) {
1479 pa_bool_t has_channel;
1480
1481 if (alsa_channel_ids[p] == SND_MIXER_SCHN_UNKNOWN)
1482 continue;
1483
1484 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
1485 has_channel = snd_mixer_selem_has_playback_channel(me, alsa_channel_ids[p]) > 0;
1486 else
1487 has_channel = snd_mixer_selem_has_capture_channel(me, alsa_channel_ids[p]) > 0;
1488
1489 e->masks[alsa_channel_ids[p]][e->n_channels-1] = has_channel ? PA_CHANNEL_POSITION_MASK(p) : 0;
1490 }
1491 }
1492
1493 e->merged_mask = 0;
1494 for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++)
1495 e->merged_mask |= e->masks[alsa_channel_ids[p]][e->n_channels-1];
1496 }
1497 }
1498 }
1499
1500 }
1501
1502 if (e->switch_use == PA_ALSA_SWITCH_SELECT) {
1503 pa_alsa_option *o;
1504
1505 PA_LLIST_FOREACH(o, e->options)
1506 o->alsa_idx = pa_streq(o->alsa_name, "on") ? 1 : 0;
1507 } else if (e->enumeration_use == PA_ALSA_ENUMERATION_SELECT) {
1508 int n;
1509 pa_alsa_option *o;
1510
1511 if ((n = snd_mixer_selem_get_enum_items(me)) < 0) {
1512 pa_log("snd_mixer_selem_get_enum_items() failed: %s", pa_alsa_strerror(n));
1513 return -1;
1514 }
1515
1516 PA_LLIST_FOREACH(o, e->options) {
1517 int i;
1518
1519 for (i = 0; i < n; i++) {
1520 char buf[128];
1521
1522 if (snd_mixer_selem_get_enum_item_name(me, i, sizeof(buf), buf) < 0)
1523 continue;
1524
1525 if (!pa_streq(buf, o->alsa_name))
1526 continue;
1527
1528 o->alsa_idx = i;
1529 }
1530 }
1531 }
1532
1533 if (check_required(e, me) < 0)
1534 return -1;
1535
1536 return 0;
1537 }
1538
1539 static pa_alsa_element* element_get(pa_alsa_path *p, const char *section, pa_bool_t prefixed) {
1540 pa_alsa_element *e;
1541
1542 pa_assert(p);
1543 pa_assert(section);
1544
1545 if (prefixed) {
1546 if (!pa_startswith(section, "Element "))
1547 return NULL;
1548
1549 section += 8;
1550 }
1551
1552 /* This is not an element section, but an enum section? */
1553 if (strchr(section, ':'))
1554 return NULL;
1555
1556 if (p->last_element && pa_streq(p->last_element->alsa_name, section))
1557 return p->last_element;
1558
1559 PA_LLIST_FOREACH(e, p->elements)
1560 if (pa_streq(e->alsa_name, section))
1561 goto finish;
1562
1563 e = pa_xnew0(pa_alsa_element, 1);
1564 e->path = p;
1565 e->alsa_name = pa_xstrdup(section);
1566 e->direction = p->direction;
1567 e->volume_limit = -1;
1568
1569 PA_LLIST_INSERT_AFTER(pa_alsa_element, p->elements, p->last_element, e);
1570
1571 finish:
1572 p->last_element = e;
1573 return e;
1574 }
1575
1576 static pa_alsa_option* option_get(pa_alsa_path *p, const char *section) {
1577 char *en;
1578 const char *on;
1579 pa_alsa_option *o;
1580 pa_alsa_element *e;
1581
1582 if (!pa_startswith(section, "Option "))
1583 return NULL;
1584
1585 section += 7;
1586
1587 /* This is not an enum section, but an element section? */
1588 if (!(on = strchr(section, ':')))
1589 return NULL;
1590
1591 en = pa_xstrndup(section, on - section);
1592 on++;
1593
1594 if (p->last_option &&
1595 pa_streq(p->last_option->element->alsa_name, en) &&
1596 pa_streq(p->last_option->alsa_name, on)) {
1597 pa_xfree(en);
1598 return p->last_option;
1599 }
1600
1601 pa_assert_se(e = element_get(p, en, FALSE));
1602 pa_xfree(en);
1603
1604 PA_LLIST_FOREACH(o, e->options)
1605 if (pa_streq(o->alsa_name, on))
1606 goto finish;
1607
1608 o = pa_xnew0(pa_alsa_option, 1);
1609 o->element = e;
1610 o->alsa_name = pa_xstrdup(on);
1611 o->alsa_idx = -1;
1612
1613 if (p->last_option && p->last_option->element == e)
1614 PA_LLIST_INSERT_AFTER(pa_alsa_option, e->options, p->last_option, o);
1615 else
1616 PA_LLIST_PREPEND(pa_alsa_option, e->options, o);
1617
1618 finish:
1619 p->last_option = o;
1620 return o;
1621 }
1622
1623 static int element_parse_switch(
1624 const char *filename,
1625 unsigned line,
1626 const char *section,
1627 const char *lvalue,
1628 const char *rvalue,
1629 void *data,
1630 void *userdata) {
1631
1632 pa_alsa_path *p = userdata;
1633 pa_alsa_element *e;
1634
1635 pa_assert(p);
1636
1637 if (!(e = element_get(p, section, TRUE))) {
1638 pa_log("[%s:%u] Switch makes no sense in '%s'", filename, line, section);
1639 return -1;
1640 }
1641
1642 if (pa_streq(rvalue, "ignore"))
1643 e->switch_use = PA_ALSA_SWITCH_IGNORE;
1644 else if (pa_streq(rvalue, "mute"))
1645 e->switch_use = PA_ALSA_SWITCH_MUTE;
1646 else if (pa_streq(rvalue, "off"))
1647 e->switch_use = PA_ALSA_SWITCH_OFF;
1648 else if (pa_streq(rvalue, "on"))
1649 e->switch_use = PA_ALSA_SWITCH_ON;
1650 else if (pa_streq(rvalue, "select"))
1651 e->switch_use = PA_ALSA_SWITCH_SELECT;
1652 else {
1653 pa_log("[%s:%u] Switch invalid of '%s'", filename, line, section);
1654 return -1;
1655 }
1656
1657 return 0;
1658 }
1659
1660 static int element_parse_volume(
1661 const char *filename,
1662 unsigned line,
1663 const char *section,
1664 const char *lvalue,
1665 const char *rvalue,
1666 void *data,
1667 void *userdata) {
1668
1669 pa_alsa_path *p = userdata;
1670 pa_alsa_element *e;
1671
1672 pa_assert(p);
1673
1674 if (!(e = element_get(p, section, TRUE))) {
1675 pa_log("[%s:%u] Volume makes no sense in '%s'", filename, line, section);
1676 return -1;
1677 }
1678
1679 if (pa_streq(rvalue, "ignore"))
1680 e->volume_use = PA_ALSA_VOLUME_IGNORE;
1681 else if (pa_streq(rvalue, "merge"))
1682 e->volume_use = PA_ALSA_VOLUME_MERGE;
1683 else if (pa_streq(rvalue, "off"))
1684 e->volume_use = PA_ALSA_VOLUME_OFF;
1685 else if (pa_streq(rvalue, "zero"))
1686 e->volume_use = PA_ALSA_VOLUME_ZERO;
1687 else {
1688 pa_log("[%s:%u] Volume invalid of '%s'", filename, line, section);
1689 return -1;
1690 }
1691
1692 return 0;
1693 }
1694
1695 static int element_parse_enumeration(
1696 const char *filename,
1697 unsigned line,
1698 const char *section,
1699 const char *lvalue,
1700 const char *rvalue,
1701 void *data,
1702 void *userdata) {
1703
1704 pa_alsa_path *p = userdata;
1705 pa_alsa_element *e;
1706
1707 pa_assert(p);
1708
1709 if (!(e = element_get(p, section, TRUE))) {
1710 pa_log("[%s:%u] Enumeration makes no sense in '%s'", filename, line, section);
1711 return -1;
1712 }
1713
1714 if (pa_streq(rvalue, "ignore"))
1715 e->enumeration_use = PA_ALSA_ENUMERATION_IGNORE;
1716 else if (pa_streq(rvalue, "select"))
1717 e->enumeration_use = PA_ALSA_ENUMERATION_SELECT;
1718 else {
1719 pa_log("[%s:%u] Enumeration invalid of '%s'", filename, line, section);
1720 return -1;
1721 }
1722
1723 return 0;
1724 }
1725
1726 static int option_parse_priority(
1727 const char *filename,
1728 unsigned line,
1729 const char *section,
1730 const char *lvalue,
1731 const char *rvalue,
1732 void *data,
1733 void *userdata) {
1734
1735 pa_alsa_path *p = userdata;
1736 pa_alsa_option *o;
1737 uint32_t prio;
1738
1739 pa_assert(p);
1740
1741 if (!(o = option_get(p, section))) {
1742 pa_log("[%s:%u] Priority makes no sense in '%s'", filename, line, section);
1743 return -1;
1744 }
1745
1746 if (pa_atou(rvalue, &prio) < 0) {
1747 pa_log("[%s:%u] Priority invalid of '%s'", filename, line, section);
1748 return -1;
1749 }
1750
1751 o->priority = prio;
1752 return 0;
1753 }
1754
1755 static int option_parse_name(
1756 const char *filename,
1757 unsigned line,
1758 const char *section,
1759 const char *lvalue,
1760 const char *rvalue,
1761 void *data,
1762 void *userdata) {
1763
1764 pa_alsa_path *p = userdata;
1765 pa_alsa_option *o;
1766
1767 pa_assert(p);
1768
1769 if (!(o = option_get(p, section))) {
1770 pa_log("[%s:%u] Name makes no sense in '%s'", filename, line, section);
1771 return -1;
1772 }
1773
1774 pa_xfree(o->name);
1775 o->name = pa_xstrdup(rvalue);
1776
1777 return 0;
1778 }
1779
1780 static int element_parse_required(
1781 const char *filename,
1782 unsigned line,
1783 const char *section,
1784 const char *lvalue,
1785 const char *rvalue,
1786 void *data,
1787 void *userdata) {
1788
1789 pa_alsa_path *p = userdata;
1790 pa_alsa_element *e;
1791 pa_alsa_option *o;
1792 pa_alsa_required_t req;
1793
1794 pa_assert(p);
1795
1796 e = element_get(p, section, TRUE);
1797 o = option_get(p, section);
1798 if (!e && !o) {
1799 pa_log("[%s:%u] Required makes no sense in '%s'", filename, line, section);
1800 return -1;
1801 }
1802
1803 if (pa_streq(rvalue, "ignore"))
1804 req = PA_ALSA_REQUIRED_IGNORE;
1805 else if (pa_streq(rvalue, "switch") && e)
1806 req = PA_ALSA_REQUIRED_SWITCH;
1807 else if (pa_streq(rvalue, "volume") && e)
1808 req = PA_ALSA_REQUIRED_VOLUME;
1809 else if (pa_streq(rvalue, "enumeration"))
1810 req = PA_ALSA_REQUIRED_ENUMERATION;
1811 else if (pa_streq(rvalue, "any"))
1812 req = PA_ALSA_REQUIRED_ANY;
1813 else {
1814 pa_log("[%s:%u] Required invalid of '%s'", filename, line, section);
1815 return -1;
1816 }
1817
1818 if (pa_streq(lvalue, "required-absent")) {
1819 if (e)
1820 e->required_absent = req;
1821 if (o)
1822 o->required_absent = req;
1823 }
1824 else if (pa_streq(lvalue, "required-any")) {
1825 if (e) {
1826 e->required_any = req;
1827 e->path->has_req_any = TRUE;
1828 }
1829 if (o) {
1830 o->required_any = req;
1831 o->element->path->has_req_any = TRUE;
1832 }
1833 }
1834 else {
1835 if (e)
1836 e->required = req;
1837 if (o)
1838 o->required = req;
1839 }
1840
1841 return 0;
1842 }
1843
1844 static int element_parse_direction(
1845 const char *filename,
1846 unsigned line,
1847 const char *section,
1848 const char *lvalue,
1849 const char *rvalue,
1850 void *data,
1851 void *userdata) {
1852
1853 pa_alsa_path *p = userdata;
1854 pa_alsa_element *e;
1855
1856 pa_assert(p);
1857
1858 if (!(e = element_get(p, section, TRUE))) {
1859 pa_log("[%s:%u] Direction makes no sense in '%s'", filename, line, section);
1860 return -1;
1861 }
1862
1863 if (pa_streq(rvalue, "playback"))
1864 e->direction = PA_ALSA_DIRECTION_OUTPUT;
1865 else if (pa_streq(rvalue, "capture"))
1866 e->direction = PA_ALSA_DIRECTION_INPUT;
1867 else {
1868 pa_log("[%s:%u] Direction invalid of '%s'", filename, line, section);
1869 return -1;
1870 }
1871
1872 return 0;
1873 }
1874
1875 static int element_parse_direction_try_other(
1876 const char *filename,
1877 unsigned line,
1878 const char *section,
1879 const char *lvalue,
1880 const char *rvalue,
1881 void *data,
1882 void *userdata) {
1883
1884 pa_alsa_path *p = userdata;
1885 pa_alsa_element *e;
1886 int yes;
1887
1888 if (!(e = element_get(p, section, TRUE))) {
1889 pa_log("[%s:%u] Direction makes no sense in '%s'", filename, line, section);
1890 return -1;
1891 }
1892
1893 if ((yes = pa_parse_boolean(rvalue)) < 0) {
1894 pa_log("[%s:%u] Direction invalid of '%s'", filename, line, section);
1895 return -1;
1896 }
1897
1898 e->direction_try_other = !!yes;
1899 return 0;
1900 }
1901
1902 static int element_parse_volume_limit(
1903 const char *filename,
1904 unsigned line,
1905 const char *section,
1906 const char *lvalue,
1907 const char *rvalue,
1908 void *data,
1909 void *userdata) {
1910
1911 pa_alsa_path *p = userdata;
1912 pa_alsa_element *e;
1913 uint32_t volume_limit;
1914
1915 if (!(e = element_get(p, section, TRUE))) {
1916 pa_log("[%s:%u] volume-limit makes no sense in '%s'", filename, line, section);
1917 return -1;
1918 }
1919
1920 if (pa_atou(rvalue, &volume_limit) < 0 || volume_limit > LONG_MAX) {
1921 pa_log("[%s:%u] Invalid value for volume-limit", filename, line);
1922 return -1;
1923 }
1924
1925 e->volume_limit = volume_limit;
1926 return 0;
1927 }
1928
1929 static pa_channel_position_mask_t parse_mask(const char *m) {
1930 pa_channel_position_mask_t v;
1931
1932 if (pa_streq(m, "all-left"))
1933 v = PA_CHANNEL_POSITION_MASK_LEFT;
1934 else if (pa_streq(m, "all-right"))
1935 v = PA_CHANNEL_POSITION_MASK_RIGHT;
1936 else if (pa_streq(m, "all-center"))
1937 v = PA_CHANNEL_POSITION_MASK_CENTER;
1938 else if (pa_streq(m, "all-front"))
1939 v = PA_CHANNEL_POSITION_MASK_FRONT;
1940 else if (pa_streq(m, "all-rear"))
1941 v = PA_CHANNEL_POSITION_MASK_REAR;
1942 else if (pa_streq(m, "all-side"))
1943 v = PA_CHANNEL_POSITION_MASK_SIDE_OR_TOP_CENTER;
1944 else if (pa_streq(m, "all-top"))
1945 v = PA_CHANNEL_POSITION_MASK_TOP;
1946 else if (pa_streq(m, "all-no-lfe"))
1947 v = PA_CHANNEL_POSITION_MASK_ALL ^ PA_CHANNEL_POSITION_MASK(PA_CHANNEL_POSITION_LFE);
1948 else if (pa_streq(m, "all"))
1949 v = PA_CHANNEL_POSITION_MASK_ALL;
1950 else {
1951 pa_channel_position_t p;
1952
1953 if ((p = pa_channel_position_from_string(m)) == PA_CHANNEL_POSITION_INVALID)
1954 return 0;
1955
1956 v = PA_CHANNEL_POSITION_MASK(p);
1957 }
1958
1959 return v;
1960 }
1961
1962 static int element_parse_override_map(
1963 const char *filename,
1964 unsigned line,
1965 const char *section,
1966 const char *lvalue,
1967 const char *rvalue,
1968 void *data,
1969 void *userdata) {
1970
1971 pa_alsa_path *p = userdata;
1972 pa_alsa_element *e;
1973 const char *state = NULL;
1974 unsigned i = 0;
1975 char *n;
1976
1977 if (!(e = element_get(p, section, TRUE))) {
1978 pa_log("[%s:%u] Override map makes no sense in '%s'", filename, line, section);
1979 return -1;
1980 }
1981
1982 while ((n = pa_split(rvalue, ",", &state))) {
1983 pa_channel_position_mask_t m;
1984
1985 if (!*n)
1986 m = 0;
1987 else {
1988 if ((m = parse_mask(n)) == 0) {
1989 pa_log("[%s:%u] Override map '%s' invalid in '%s'", filename, line, n, section);
1990 pa_xfree(n);
1991 return -1;
1992 }
1993 }
1994
1995 if (pa_streq(lvalue, "override-map.1"))
1996 e->masks[i++][0] = m;
1997 else
1998 e->masks[i++][1] = m;
1999
2000 /* Later on we might add override-map.3 and so on here ... */
2001
2002 pa_xfree(n);
2003 }
2004
2005 e->override_map = TRUE;
2006
2007 return 0;
2008 }
2009
2010 static int element_set_option(pa_alsa_element *e, snd_mixer_t *m, int alsa_idx) {
2011 snd_mixer_selem_id_t *sid;
2012 snd_mixer_elem_t *me;
2013 int r;
2014
2015 pa_assert(e);
2016 pa_assert(m);
2017
2018 SELEM_INIT(sid, e->alsa_name);
2019 if (!(me = snd_mixer_find_selem(m, sid))) {
2020 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
2021 return -1;
2022 }
2023
2024 if (e->switch_use == PA_ALSA_SWITCH_SELECT) {
2025
2026 if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
2027 r = snd_mixer_selem_set_playback_switch_all(me, alsa_idx);
2028 else
2029 r = snd_mixer_selem_set_capture_switch_all(me, alsa_idx);
2030
2031 if (r < 0)
2032 pa_log_warn("Failed to set switch of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
2033
2034 } else {
2035 pa_assert(e->enumeration_use == PA_ALSA_ENUMERATION_SELECT);
2036
2037 if ((r = snd_mixer_selem_set_enum_item(me, 0, alsa_idx)) < 0)
2038 pa_log_warn("Failed to set enumeration of %s: %s", e->alsa_name, pa_alsa_strerror(errno));
2039 }
2040
2041 return r;
2042 }
2043
2044 int pa_alsa_setting_select(pa_alsa_setting *s, snd_mixer_t *m) {
2045 pa_alsa_option *o;
2046 uint32_t idx;
2047
2048 pa_assert(s);
2049 pa_assert(m);
2050
2051 PA_IDXSET_FOREACH(o, s->options, idx)
2052 element_set_option(o->element, m, o->alsa_idx);
2053
2054 return 0;
2055 }
2056
2057 static int option_verify(pa_alsa_option *o) {
2058 static const struct description_map well_known_descriptions[] = {
2059 { "input", N_("Input") },
2060 { "input-docking", N_("Docking Station Input") },
2061 { "input-docking-microphone", N_("Docking Station Microphone") },
2062 { "input-docking-linein", N_("Docking Station Line-In") },
2063 { "input-linein", N_("Line-In") },
2064 { "input-microphone", N_("Microphone") },
2065 { "input-microphone-front", N_("Front Microphone") },
2066 { "input-microphone-rear", N_("Rear Microphone") },
2067 { "input-microphone-external", N_("External Microphone") },
2068 { "input-microphone-internal", N_("Internal Microphone") },
2069 { "input-radio", N_("Radio") },
2070 { "input-video", N_("Video") },
2071 { "input-agc-on", N_("Automatic Gain Control") },
2072 { "input-agc-off", N_("No Automatic Gain Control") },
2073 { "input-boost-on", N_("Boost") },
2074 { "input-boost-off", N_("No Boost") },
2075 { "output-amplifier-on", N_("Amplifier") },
2076 { "output-amplifier-off", N_("No Amplifier") },
2077 { "output-bass-boost-on", N_("Bass Boost") },
2078 { "output-bass-boost-off", N_("No Bass Boost") },
2079 { "output-speaker", N_("Speaker") },
2080 { "output-headphones", N_("Headphones") }
2081 };
2082
2083 pa_assert(o);
2084
2085 if (!o->name) {
2086 pa_log("No name set for option %s", o->alsa_name);
2087 return -1;
2088 }
2089
2090 if (o->element->enumeration_use != PA_ALSA_ENUMERATION_SELECT &&
2091 o->element->switch_use != PA_ALSA_SWITCH_SELECT) {
2092 pa_log("Element %s of option %s not set for select.", o->element->alsa_name, o->name);
2093 return -1;
2094 }
2095
2096 if (o->element->switch_use == PA_ALSA_SWITCH_SELECT &&
2097 !pa_streq(o->alsa_name, "on") &&
2098 !pa_streq(o->alsa_name, "off")) {
2099 pa_log("Switch %s options need be named off or on ", o->element->alsa_name);
2100 return -1;
2101 }
2102
2103 if (!o->description)
2104 o->description = pa_xstrdup(lookup_description(o->name,
2105 well_known_descriptions,
2106 PA_ELEMENTSOF(well_known_descriptions)));
2107 if (!o->description)
2108 o->description = pa_xstrdup(o->name);
2109
2110 return 0;
2111 }
2112
2113 static int element_verify(pa_alsa_element *e) {
2114 pa_alsa_option *o;
2115
2116 pa_assert(e);
2117
2118 // 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);
2119 if ((e->required != PA_ALSA_REQUIRED_IGNORE && e->required == e->required_absent) ||
2120 (e->required_any != PA_ALSA_REQUIRED_IGNORE && e->required_any == e->required_absent) ||
2121 (e->required_absent == PA_ALSA_REQUIRED_ANY && e->required_any != PA_ALSA_REQUIRED_IGNORE) ||
2122 (e->required_absent == PA_ALSA_REQUIRED_ANY && e->required != PA_ALSA_REQUIRED_IGNORE)) {
2123 pa_log("Element %s cannot be required and absent at the same time.", e->alsa_name);
2124 return -1;
2125 }
2126
2127 if (e->switch_use == PA_ALSA_SWITCH_SELECT && e->enumeration_use == PA_ALSA_ENUMERATION_SELECT) {
2128 pa_log("Element %s cannot set select for both switch and enumeration.", e->alsa_name);
2129 return -1;
2130 }
2131
2132 PA_LLIST_FOREACH(o, e->options)
2133 if (option_verify(o) < 0)
2134 return -1;
2135
2136 return 0;
2137 }
2138
2139 static int path_verify(pa_alsa_path *p) {
2140 static const struct description_map well_known_descriptions[] = {
2141 { "analog-input", N_("Analog Input") },
2142 { "analog-input-microphone", N_("Analog Microphone") },
2143 { "analog-input-microphone-front", N_("Front Microphone") },
2144 { "analog-input-microphone-rear", N_("Rear Microphone") },
2145 { "analog-input-microphone-dock", N_("Docking Station Microphone") },
2146 { "analog-input-microphone-internal", N_("Internal Microphone") },
2147 { "analog-input-linein", N_("Analog Line-In") },
2148 { "analog-input-radio", N_("Analog Radio") },
2149 { "analog-input-video", N_("Analog Video") },
2150 { "analog-output", N_("Analog Output") },
2151 { "analog-output-headphones", N_("Analog Headphones") },
2152 { "analog-output-lfe-on-mono", N_("Analog Output (LFE)") },
2153 { "analog-output-mono", N_("Analog Mono Output") },
2154 { "analog-output-speaker", N_("Analog Speakers") },
2155 { "iec958-stereo-output", N_("Digital Output (IEC958)") },
2156 { "iec958-passthrough-output", N_("Digital Passthrough (IEC958)") }
2157 };
2158
2159 pa_alsa_element *e;
2160
2161 pa_assert(p);
2162
2163 PA_LLIST_FOREACH(e, p->elements)
2164 if (element_verify(e) < 0)
2165 return -1;
2166
2167 if (!p->description)
2168 p->description = pa_xstrdup(lookup_description(p->name,
2169 well_known_descriptions,
2170 PA_ELEMENTSOF(well_known_descriptions)));
2171
2172 if (!p->description)
2173 p->description = pa_xstrdup(p->name);
2174
2175 return 0;
2176 }
2177
2178 pa_alsa_path* pa_alsa_path_new(const char *fname, pa_alsa_direction_t direction) {
2179 pa_alsa_path *p;
2180 char *fn;
2181 int r;
2182 const char *n;
2183
2184 pa_config_item items[] = {
2185 /* [General] */
2186 { "priority", pa_config_parse_unsigned, NULL, "General" },
2187 { "description", pa_config_parse_string, NULL, "General" },
2188 { "name", pa_config_parse_string, NULL, "General" },
2189
2190 /* [Option ...] */
2191 { "priority", option_parse_priority, NULL, NULL },
2192 { "name", option_parse_name, NULL, NULL },
2193
2194 /* [Element ...] */
2195 { "switch", element_parse_switch, NULL, NULL },
2196 { "volume", element_parse_volume, NULL, NULL },
2197 { "enumeration", element_parse_enumeration, NULL, NULL },
2198 { "override-map.1", element_parse_override_map, NULL, NULL },
2199 { "override-map.2", element_parse_override_map, NULL, NULL },
2200 /* ... later on we might add override-map.3 and so on here ... */
2201 { "required", element_parse_required, NULL, NULL },
2202 { "required-any", element_parse_required, NULL, NULL },
2203 { "required-absent", element_parse_required, NULL, NULL },
2204 { "direction", element_parse_direction, NULL, NULL },
2205 { "direction-try-other", element_parse_direction_try_other, NULL, NULL },
2206 { "volume-limit", element_parse_volume_limit, NULL, NULL },
2207 { NULL, NULL, NULL, NULL }
2208 };
2209
2210 pa_assert(fname);
2211
2212 p = pa_xnew0(pa_alsa_path, 1);
2213 n = pa_path_get_filename(fname);
2214 p->name = pa_xstrndup(n, strcspn(n, "."));
2215 p->direction = direction;
2216
2217 items[0].data = &p->priority;
2218 items[1].data = &p->description;
2219 items[2].data = &p->name;
2220
2221 fn = pa_maybe_prefix_path(fname,
2222 #if defined(__linux__) && !defined(__OPTIMIZE__)
2223 pa_run_from_build_tree() ? PA_BUILDDIR "/modules/alsa/mixer/paths/" :
2224 #endif
2225 PA_ALSA_PATHS_DIR);
2226
2227 r = pa_config_parse(fn, NULL, items, p);
2228 pa_xfree(fn);
2229
2230 if (r < 0)
2231 goto fail;
2232
2233 if (path_verify(p) < 0)
2234 goto fail;
2235
2236 return p;
2237
2238 fail:
2239 pa_alsa_path_free(p);
2240 return NULL;
2241 }
2242
2243 pa_alsa_path* pa_alsa_path_synthesize(const char*element, pa_alsa_direction_t direction) {
2244 pa_alsa_path *p;
2245 pa_alsa_element *e;
2246
2247 pa_assert(element);
2248
2249 p = pa_xnew0(pa_alsa_path, 1);
2250 p->name = pa_xstrdup(element);
2251 p->direction = direction;
2252
2253 e = pa_xnew0(pa_alsa_element, 1);
2254 e->path = p;
2255 e->alsa_name = pa_xstrdup(element);
2256 e->direction = direction;
2257 e->volume_limit = -1;
2258
2259 e->switch_use = PA_ALSA_SWITCH_MUTE;
2260 e->volume_use = PA_ALSA_VOLUME_MERGE;
2261
2262 PA_LLIST_PREPEND(pa_alsa_element, p->elements, e);
2263 p->last_element = e;
2264 return p;
2265 }
2266
2267 static pa_bool_t element_drop_unsupported(pa_alsa_element *e) {
2268 pa_alsa_option *o, *n;
2269
2270 pa_assert(e);
2271
2272 for (o = e->options; o; o = n) {
2273 n = o->next;
2274
2275 if (o->alsa_idx < 0) {
2276 PA_LLIST_REMOVE(pa_alsa_option, e->options, o);
2277 option_free(o);
2278 }
2279 }
2280
2281 return
2282 e->switch_use != PA_ALSA_SWITCH_IGNORE ||
2283 e->volume_use != PA_ALSA_VOLUME_IGNORE ||
2284 e->enumeration_use != PA_ALSA_ENUMERATION_IGNORE;
2285 }
2286
2287 static void path_drop_unsupported(pa_alsa_path *p) {
2288 pa_alsa_element *e, *n;
2289
2290 pa_assert(p);
2291
2292 for (e = p->elements; e; e = n) {
2293 n = e->next;
2294
2295 if (!element_drop_unsupported(e)) {
2296 PA_LLIST_REMOVE(pa_alsa_element, p->elements, e);
2297 element_free(e);
2298 }
2299 }
2300 }
2301
2302 static void path_make_options_unique(pa_alsa_path *p) {
2303 pa_alsa_element *e;
2304 pa_alsa_option *o, *u;
2305
2306 PA_LLIST_FOREACH(e, p->elements) {
2307 PA_LLIST_FOREACH(o, e->options) {
2308 unsigned i;
2309 char *m;
2310
2311 for (u = o->next; u; u = u->next)
2312 if (pa_streq(u->name, o->name))
2313 break;
2314
2315 if (!u)
2316 continue;
2317
2318 m = pa_xstrdup(o->name);
2319
2320 /* OK, this name is not unique, hence let's rename */
2321 for (i = 1, u = o; u; u = u->next) {
2322 char *nn, *nd;
2323
2324 if (!pa_streq(u->name, m))
2325 continue;
2326
2327 nn = pa_sprintf_malloc("%s-%u", m, i);
2328 pa_xfree(u->name);
2329 u->name = nn;
2330
2331 nd = pa_sprintf_malloc("%s %u", u->description, i);
2332 pa_xfree(u->description);
2333 u->description = nd;
2334
2335 i++;
2336 }
2337
2338 pa_xfree(m);
2339 }
2340 }
2341 }
2342
2343 static pa_bool_t element_create_settings(pa_alsa_element *e, pa_alsa_setting *template) {
2344 pa_alsa_option *o;
2345
2346 for (; e; e = e->next)
2347 if (e->switch_use == PA_ALSA_SWITCH_SELECT ||
2348 e->enumeration_use == PA_ALSA_ENUMERATION_SELECT)
2349 break;
2350
2351 if (!e)
2352 return FALSE;
2353
2354 for (o = e->options; o; o = o->next) {
2355 pa_alsa_setting *s;
2356
2357 if (template) {
2358 s = pa_xnewdup(pa_alsa_setting, template, 1);
2359 s->options = pa_idxset_copy(template->options);
2360 s->name = pa_sprintf_malloc(_("%s+%s"), template->name, o->name);
2361 s->description =
2362 (template->description[0] && o->description[0])
2363 ? pa_sprintf_malloc(_("%s / %s"), template->description, o->description)
2364 : (template->description[0]
2365 ? pa_xstrdup(template->description)
2366 : pa_xstrdup(o->description));
2367
2368 s->priority = PA_MAX(template->priority, o->priority);
2369 } else {
2370 s = pa_xnew0(pa_alsa_setting, 1);
2371 s->options = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2372 s->name = pa_xstrdup(o->name);
2373 s->description = pa_xstrdup(o->description);
2374 s->priority = o->priority;
2375 }
2376
2377 pa_idxset_put(s->options, o, NULL);
2378
2379 if (element_create_settings(e->next, s))
2380 /* This is not a leaf, so let's get rid of it */
2381 setting_free(s);
2382 else {
2383 /* This is a leaf, so let's add it */
2384 PA_LLIST_INSERT_AFTER(pa_alsa_setting, e->path->settings, e->path->last_setting, s);
2385
2386 e->path->last_setting = s;
2387 }
2388 }
2389
2390 return TRUE;
2391 }
2392
2393 static void path_create_settings(pa_alsa_path *p) {
2394 pa_assert(p);
2395
2396 element_create_settings(p->elements, NULL);
2397 }
2398
2399 int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t ignore_dB) {
2400 pa_alsa_element *e;
2401 double min_dB[PA_CHANNEL_POSITION_MAX], max_dB[PA_CHANNEL_POSITION_MAX];
2402 pa_channel_position_t t;
2403 pa_channel_position_mask_t path_volume_channels = 0;
2404
2405 pa_assert(p);
2406 pa_assert(m);
2407
2408 if (p->probed)
2409 return 0;
2410
2411 pa_zero(min_dB);
2412 pa_zero(max_dB);
2413
2414 pa_log_debug("Probing path '%s'", p->name);
2415
2416 PA_LLIST_FOREACH(e, p->elements) {
2417 if (element_probe(e, m) < 0) {
2418 p->supported = FALSE;
2419 pa_log_debug("Probe of element '%s' failed.", e->alsa_name);
2420 return -1;
2421 }
2422 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);
2423
2424 if (ignore_dB)
2425 e->has_dB = FALSE;
2426
2427 if (e->volume_use == PA_ALSA_VOLUME_MERGE) {
2428
2429 if (!p->has_volume) {
2430 p->min_volume = e->min_volume;
2431 p->max_volume = e->max_volume;
2432 }
2433
2434 if (e->has_dB) {
2435 if (!p->has_volume) {
2436 for (t = 0; t < PA_CHANNEL_POSITION_MAX; t++)
2437 if (PA_CHANNEL_POSITION_MASK(t) & e->merged_mask) {
2438 min_dB[t] = e->min_dB;
2439 max_dB[t] = e->max_dB;
2440 path_volume_channels |= PA_CHANNEL_POSITION_MASK(t);
2441 }
2442
2443 p->has_dB = TRUE;
2444 } else {
2445
2446 if (p->has_dB) {
2447 for (t = 0; t < PA_CHANNEL_POSITION_MAX; t++)
2448 if (PA_CHANNEL_POSITION_MASK(t) & e->merged_mask) {
2449 min_dB[t] += e->min_dB;
2450 max_dB[t] += e->max_dB;
2451 path_volume_channels |= PA_CHANNEL_POSITION_MASK(t);
2452 }
2453 } else {
2454 /* Hmm, there's another element before us
2455 * which cannot do dB volumes, so we we need
2456 * to 'neutralize' this slider */
2457 e->volume_use = PA_ALSA_VOLUME_ZERO;
2458 pa_log_info("Zeroing volume of '%s' on path '%s'", e->alsa_name, p->name);
2459 }
2460 }
2461 } else if (p->has_volume) {
2462 /* We can't use this volume, so let's ignore it */
2463 e->volume_use = PA_ALSA_VOLUME_IGNORE;
2464 pa_log_info("Ignoring volume of '%s' on path '%s' (missing dB info)", e->alsa_name, p->name);
2465 }
2466 p->has_volume = TRUE;
2467 }
2468
2469 if (e->switch_use == PA_ALSA_SWITCH_MUTE)
2470 p->has_mute = TRUE;
2471 }
2472
2473 if (p->has_req_any && !p->req_any_present) {
2474 p->supported = FALSE;
2475 pa_log_debug("Skipping path '%s', none of required-any elements preset.", p->name);
2476 return -1;
2477 }
2478
2479 path_drop_unsupported(p);
2480 path_make_options_unique(p);
2481 path_create_settings(p);
2482
2483 p->supported = TRUE;
2484 p->probed = TRUE;
2485
2486 p->min_dB = INFINITY;
2487 p->max_dB = -INFINITY;
2488
2489 for (t = 0; t < PA_CHANNEL_POSITION_MAX; t++) {
2490 if (path_volume_channels & PA_CHANNEL_POSITION_MASK(t)) {
2491 if (p->min_dB > min_dB[t])
2492 p->min_dB = min_dB[t];
2493
2494 if (p->max_dB < max_dB[t])
2495 p->max_dB = max_dB[t];
2496 }
2497 }
2498
2499 return 0;
2500 }
2501
2502 void pa_alsa_setting_dump(pa_alsa_setting *s) {
2503 pa_assert(s);
2504
2505 pa_log_debug("Setting %s (%s) priority=%u",
2506 s->name,
2507 pa_strnull(s->description),
2508 s->priority);
2509 }
2510
2511 void pa_alsa_option_dump(pa_alsa_option *o) {
2512 pa_assert(o);
2513
2514 pa_log_debug("Option %s (%s/%s) index=%i, priority=%u",
2515 o->alsa_name,
2516 pa_strnull(o->name),
2517 pa_strnull(o->description),
2518 o->alsa_idx,
2519 o->priority);
2520 }
2521
2522 void pa_alsa_element_dump(pa_alsa_element *e) {
2523 pa_alsa_option *o;
2524 pa_assert(e);
2525
2526 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",
2527 e->alsa_name,
2528 e->direction,
2529 e->switch_use,
2530 e->volume_use,
2531 e->volume_limit,
2532 e->enumeration_use,
2533 e->required,
2534 e->required_any,
2535 e->required_absent,
2536 (long long unsigned) e->merged_mask,
2537 e->n_channels,
2538 pa_yes_no(e->override_map));
2539
2540 PA_LLIST_FOREACH(o, e->options)
2541 pa_alsa_option_dump(o);
2542 }
2543
2544 void pa_alsa_path_dump(pa_alsa_path *p) {
2545 pa_alsa_element *e;
2546 pa_alsa_setting *s;
2547 pa_assert(p);
2548
2549 pa_log_debug("Path %s (%s), direction=%i, priority=%u, probed=%s, supported=%s, has_mute=%s, has_volume=%s, "
2550 "has_dB=%s, min_volume=%li, max_volume=%li, min_dB=%g, max_dB=%g",
2551 p->name,
2552 pa_strnull(p->description),
2553 p->direction,
2554 p->priority,
2555 pa_yes_no(p->probed),
2556 pa_yes_no(p->supported),
2557 pa_yes_no(p->has_mute),
2558 pa_yes_no(p->has_volume),
2559 pa_yes_no(p->has_dB),
2560 p->min_volume, p->max_volume,
2561 p->min_dB, p->max_dB);
2562
2563 PA_LLIST_FOREACH(e, p->elements)
2564 pa_alsa_element_dump(e);
2565
2566 PA_LLIST_FOREACH(s, p->settings)
2567 pa_alsa_setting_dump(s);
2568 }
2569
2570 static void element_set_callback(pa_alsa_element *e, snd_mixer_t *m, snd_mixer_elem_callback_t cb, void *userdata) {
2571 snd_mixer_selem_id_t *sid;
2572 snd_mixer_elem_t *me;
2573
2574 pa_assert(e);
2575 pa_assert(m);
2576 pa_assert(cb);
2577
2578 SELEM_INIT(sid, e->alsa_name);
2579 if (!(me = snd_mixer_find_selem(m, sid))) {
2580 pa_log_warn("Element %s seems to have disappeared.", e->alsa_name);
2581 return;
2582 }
2583
2584 snd_mixer_elem_set_callback(me, cb);
2585 snd_mixer_elem_set_callback_private(me, userdata);
2586 }
2587
2588 void pa_alsa_path_set_callback(pa_alsa_path *p, snd_mixer_t *m, snd_mixer_elem_callback_t cb, void *userdata) {
2589 pa_alsa_element *e;
2590
2591 pa_assert(p);
2592 pa_assert(m);
2593 pa_assert(cb);
2594
2595 PA_LLIST_FOREACH(e, p->elements)
2596 element_set_callback(e, m, cb, userdata);
2597 }
2598
2599 void pa_alsa_path_set_set_callback(pa_alsa_path_set *ps, snd_mixer_t *m, snd_mixer_elem_callback_t cb, void *userdata) {
2600 pa_alsa_path *p;
2601
2602 pa_assert(ps);
2603 pa_assert(m);
2604 pa_assert(cb);
2605
2606 PA_LLIST_FOREACH(p, ps->paths)
2607 pa_alsa_path_set_callback(p, m, cb, userdata);
2608 }
2609
2610 pa_alsa_path_set *pa_alsa_path_set_new(pa_alsa_mapping *m, pa_alsa_direction_t direction) {
2611 pa_alsa_path_set *ps;
2612 char **pn = NULL, **en = NULL, **ie;
2613 pa_alsa_decibel_fix *db_fix;
2614 void *state;
2615
2616 pa_assert(m);
2617 pa_assert(m->profile_set);
2618 pa_assert(m->profile_set->decibel_fixes);
2619 pa_assert(direction == PA_ALSA_DIRECTION_OUTPUT || direction == PA_ALSA_DIRECTION_INPUT);
2620
2621 if (m->direction != PA_ALSA_DIRECTION_ANY && m->direction != direction)
2622 return NULL;
2623
2624 ps = pa_xnew0(pa_alsa_path_set, 1);
2625 ps->direction = direction;
2626
2627 if (direction == PA_ALSA_DIRECTION_OUTPUT)
2628 pn = m->output_path_names;
2629 else if (direction == PA_ALSA_DIRECTION_INPUT)
2630 pn = m->input_path_names;
2631
2632 if (pn) {
2633 char **in;
2634
2635 for (in = pn; *in; in++) {
2636 pa_alsa_path *p;
2637 pa_bool_t duplicate = FALSE;
2638 char **kn, *fn;
2639
2640 for (kn = pn; kn != in; kn++)
2641 if (pa_streq(*kn, *in)) {
2642 duplicate = TRUE;
2643 break;
2644 }
2645
2646 if (duplicate)
2647 continue;
2648
2649 fn = pa_sprintf_malloc("%s.conf", *in);
2650
2651 if ((p = pa_alsa_path_new(fn, direction))) {
2652 p->path_set = ps;
2653 PA_LLIST_INSERT_AFTER(pa_alsa_path, ps->paths, ps->last_path, p);
2654 ps->last_path = p;
2655 }
2656
2657 pa_xfree(fn);
2658 }
2659
2660 goto finish;
2661 }
2662
2663 if (direction == PA_ALSA_DIRECTION_OUTPUT)
2664 en = m->output_element;
2665 else if (direction == PA_ALSA_DIRECTION_INPUT)
2666 en = m->input_element;
2667
2668 if (!en) {
2669 pa_alsa_path_set_free(ps);
2670 return NULL;
2671 }
2672
2673 for (ie = en; *ie; ie++) {
2674 char **je;
2675 pa_alsa_path *p;
2676
2677 p = pa_alsa_path_synthesize(*ie, direction);
2678 p->path_set = ps;
2679
2680 /* Mark all other passed elements for require-absent */
2681 for (je = en; *je; je++) {
2682 pa_alsa_element *e;
2683
2684 if (je == ie)
2685 continue;
2686
2687 e = pa_xnew0(pa_alsa_element, 1);
2688 e->path = p;
2689 e->alsa_name = pa_xstrdup(*je);
2690 e->direction = direction;
2691 e->required_absent = PA_ALSA_REQUIRED_ANY;
2692 e->volume_limit = -1;
2693
2694 PA_LLIST_INSERT_AFTER(pa_alsa_element, p->elements, p->last_element, e);
2695 p->last_element = e;
2696 }
2697
2698 PA_LLIST_INSERT_AFTER(pa_alsa_path, ps->paths, ps->last_path, p);
2699 ps->last_path = p;
2700 }
2701
2702 finish:
2703 /* Assign decibel fixes to elements. */
2704 PA_HASHMAP_FOREACH(db_fix, m->profile_set->decibel_fixes, state) {
2705 pa_alsa_path *p;
2706
2707 PA_LLIST_FOREACH(p, ps->paths) {
2708 pa_alsa_element *e;
2709
2710 PA_LLIST_FOREACH(e, p->elements) {
2711 if (e->volume_use != PA_ALSA_VOLUME_IGNORE && pa_streq(db_fix->name, e->alsa_name)) {
2712 /* The profile set that contains the dB fix may be freed
2713 * before the element, so we have to copy the dB fix
2714 * object. */
2715 e->db_fix = pa_xnewdup(pa_alsa_decibel_fix, db_fix, 1);
2716 e->db_fix->profile_set = NULL;
2717 e->db_fix->name = pa_xstrdup(db_fix->name);
2718 e->db_fix->db_values = pa_xmemdup(db_fix->db_values, (db_fix->max_step - db_fix->min_step + 1) * sizeof(long));
2719 }
2720 }
2721 }
2722 }
2723
2724 return ps;
2725 }
2726
2727 void pa_alsa_path_set_dump(pa_alsa_path_set *ps) {
2728 pa_alsa_path *p;
2729 pa_assert(ps);
2730
2731 pa_log_debug("Path Set %p, direction=%i, probed=%s",
2732 (void*) ps,
2733 ps->direction,
2734 pa_yes_no(ps->probed));
2735
2736 PA_LLIST_FOREACH(p, ps->paths)
2737 pa_alsa_path_dump(p);
2738 }
2739
2740 static void path_set_unify(pa_alsa_path_set *ps) {
2741 pa_alsa_path *p;
2742 pa_bool_t has_dB = TRUE, has_volume = TRUE, has_mute = TRUE;
2743 pa_assert(ps);
2744
2745 /* We have issues dealing with paths that vary too wildly. That
2746 * means for now we have to have all paths support volume/mute/dB
2747 * or none. */
2748
2749 PA_LLIST_FOREACH(p, ps->paths) {
2750 pa_assert(p->probed);
2751
2752 if (!p->has_volume)
2753 has_volume = FALSE;
2754 else if (!p->has_dB)
2755 has_dB = FALSE;
2756
2757 if (!p->has_mute)
2758 has_mute = FALSE;
2759 }
2760
2761 if (!has_volume || !has_dB || !has_mute) {
2762
2763 if (!has_volume)
2764 pa_log_debug("Some paths of the device lack hardware volume control, disabling hardware control altogether.");
2765 else if (!has_dB)
2766 pa_log_debug("Some paths of the device lack dB information, disabling dB logic altogether.");
2767
2768 if (!has_mute)
2769 pa_log_debug("Some paths of the device lack hardware mute control, disabling hardware control altogether.");
2770
2771 PA_LLIST_FOREACH(p, ps->paths) {
2772 if (!has_volume)
2773 p->has_volume = FALSE;
2774 else if (!has_dB)
2775 p->has_dB = FALSE;
2776
2777 if (!has_mute)
2778 p->has_mute = FALSE;
2779 }
2780 }
2781 }
2782
2783 static void path_set_make_paths_unique(pa_alsa_path_set *ps) {
2784 pa_alsa_path *p, *q;
2785
2786 PA_LLIST_FOREACH(p, ps->paths) {
2787 unsigned i;
2788 char *m;
2789
2790 for (q = p->next; q; q = q->next)
2791 if (pa_streq(q->name, p->name))
2792 break;
2793
2794 if (!q)
2795 continue;
2796
2797 m = pa_xstrdup(p->name);
2798
2799 /* OK, this name is not unique, hence let's rename */
2800 for (i = 1, q = p; q; q = q->next) {
2801 char *nn, *nd;
2802
2803 if (!pa_streq(q->name, m))
2804 continue;
2805
2806 nn = pa_sprintf_malloc("%s-%u", m, i);
2807 pa_xfree(q->name);
2808 q->name = nn;
2809
2810 nd = pa_sprintf_malloc("%s %u", q->description, i);
2811 pa_xfree(q->description);
2812 q->description = nd;
2813
2814 i++;
2815 }
2816
2817 pa_xfree(m);
2818 }
2819 }
2820
2821 void pa_alsa_path_set_probe(pa_alsa_path_set *ps, snd_mixer_t *m, pa_bool_t ignore_dB) {
2822 pa_alsa_path *p, *n;
2823
2824 pa_assert(ps);
2825
2826 if (ps->probed)
2827 return;
2828
2829 for (p = ps->paths; p; p = n) {
2830 n = p->next;
2831
2832 if (pa_alsa_path_probe(p, m, ignore_dB) < 0) {
2833 PA_LLIST_REMOVE(pa_alsa_path, ps->paths, p);
2834 pa_alsa_path_free(p);
2835 }
2836 }
2837
2838 path_set_unify(ps);
2839 path_set_make_paths_unique(ps);
2840 ps->probed = TRUE;
2841 }
2842
2843 static void mapping_free(pa_alsa_mapping *m) {
2844 pa_assert(m);
2845
2846 pa_xfree(m->name);
2847 pa_xfree(m->description);
2848
2849 pa_xstrfreev(m->device_strings);
2850 pa_xstrfreev(m->input_path_names);
2851 pa_xstrfreev(m->output_path_names);
2852 pa_xstrfreev(m->input_element);
2853 pa_xstrfreev(m->output_element);
2854
2855 pa_assert(!m->input_pcm);
2856 pa_assert(!m->output_pcm);
2857
2858 pa_xfree(m);
2859 }
2860
2861 static void profile_free(pa_alsa_profile *p) {
2862 pa_assert(p);
2863
2864 pa_xfree(p->name);
2865 pa_xfree(p->description);
2866
2867 pa_xstrfreev(p->input_mapping_names);
2868 pa_xstrfreev(p->output_mapping_names);
2869
2870 if (p->input_mappings)
2871 pa_idxset_free(p->input_mappings, NULL, NULL);
2872
2873 if (p->output_mappings)
2874 pa_idxset_free(p->output_mappings, NULL, NULL);
2875
2876 pa_xfree(p);
2877 }
2878
2879 void pa_alsa_profile_set_free(pa_alsa_profile_set *ps) {
2880 pa_assert(ps);
2881
2882 if (ps->profiles) {
2883 pa_alsa_profile *p;
2884
2885 while ((p = pa_hashmap_steal_first(ps->profiles)))
2886 profile_free(p);
2887
2888 pa_hashmap_free(ps->profiles, NULL, NULL);
2889 }
2890
2891 if (ps->mappings) {
2892 pa_alsa_mapping *m;
2893
2894 while ((m = pa_hashmap_steal_first(ps->mappings)))
2895 mapping_free(m);
2896
2897 pa_hashmap_free(ps->mappings, NULL, NULL);
2898 }
2899
2900 if (ps->decibel_fixes) {
2901 pa_alsa_decibel_fix *db_fix;
2902
2903 while ((db_fix = pa_hashmap_steal_first(ps->decibel_fixes)))
2904 decibel_fix_free(db_fix);
2905
2906 pa_hashmap_free(ps->decibel_fixes, NULL, NULL);
2907 }
2908
2909 pa_xfree(ps);
2910 }
2911
2912 static pa_alsa_mapping *mapping_get(pa_alsa_profile_set *ps, const char *name) {
2913 pa_alsa_mapping *m;
2914
2915 if (!pa_startswith(name, "Mapping "))
2916 return NULL;
2917
2918 name += 8;
2919
2920 if ((m = pa_hashmap_get(ps->mappings, name)))
2921 return m;
2922
2923 m = pa_xnew0(pa_alsa_mapping, 1);
2924 m->profile_set = ps;
2925 m->name = pa_xstrdup(name);
2926 pa_channel_map_init(&m->channel_map);
2927
2928 pa_hashmap_put(ps->mappings, m->name, m);
2929
2930 return m;
2931 }
2932
2933 static pa_alsa_profile *profile_get(pa_alsa_profile_set *ps, const char *name) {
2934 pa_alsa_profile *p;
2935
2936 if (!pa_startswith(name, "Profile "))
2937 return NULL;
2938
2939 name += 8;
2940
2941 if ((p = pa_hashmap_get(ps->profiles, name)))
2942 return p;
2943
2944 p = pa_xnew0(pa_alsa_profile, 1);
2945 p->profile_set = ps;
2946 p->name = pa_xstrdup(name);
2947
2948 pa_hashmap_put(ps->profiles, p->name, p);
2949
2950 return p;
2951 }
2952
2953 static pa_alsa_decibel_fix *decibel_fix_get(pa_alsa_profile_set *ps, const char *name) {
2954 pa_alsa_decibel_fix *db_fix;
2955
2956 if (!pa_startswith(name, "DecibelFix "))
2957 return NULL;
2958
2959 name += 11;
2960
2961 if ((db_fix = pa_hashmap_get(ps->decibel_fixes, name)))
2962 return db_fix;
2963
2964 db_fix = pa_xnew0(pa_alsa_decibel_fix, 1);
2965 db_fix->profile_set = ps;
2966 db_fix->name = pa_xstrdup(name);
2967
2968 pa_hashmap_put(ps->decibel_fixes, db_fix->name, db_fix);
2969
2970 return db_fix;
2971 }
2972
2973 static int mapping_parse_device_strings(
2974 const char *filename,
2975 unsigned line,
2976 const char *section,
2977 const char *lvalue,
2978 const char *rvalue,
2979 void *data,
2980 void *userdata) {
2981
2982 pa_alsa_profile_set *ps = userdata;
2983 pa_alsa_mapping *m;
2984
2985 pa_assert(ps);
2986
2987 if (!(m = mapping_get(ps, section))) {
2988 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
2989 return -1;
2990 }
2991
2992 pa_xstrfreev(m->device_strings);
2993 if (!(m->device_strings = pa_split_spaces_strv(rvalue))) {
2994 pa_log("[%s:%u] Device string list empty of '%s'", filename, line, section);
2995 return -1;
2996 }
2997
2998 return 0;
2999 }
3000
3001 static int mapping_parse_channel_map(
3002 const char *filename,
3003 unsigned line,
3004 const char *section,
3005 const char *lvalue,
3006 const char *rvalue,
3007 void *data,
3008 void *userdata) {
3009
3010 pa_alsa_profile_set *ps = userdata;
3011 pa_alsa_mapping *m;
3012
3013 pa_assert(ps);
3014
3015 if (!(m = mapping_get(ps, section))) {
3016 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3017 return -1;
3018 }
3019
3020 if (!(pa_channel_map_parse(&m->channel_map, rvalue))) {
3021 pa_log("[%s:%u] Channel map invalid of '%s'", filename, line, section);
3022 return -1;
3023 }
3024
3025 return 0;
3026 }
3027
3028 static int mapping_parse_paths(
3029 const char *filename,
3030 unsigned line,
3031 const char *section,
3032 const char *lvalue,
3033 const char *rvalue,
3034 void *data,
3035 void *userdata) {
3036
3037 pa_alsa_profile_set *ps = userdata;
3038 pa_alsa_mapping *m;
3039
3040 pa_assert(ps);
3041
3042 if (!(m = mapping_get(ps, section))) {
3043 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3044 return -1;
3045 }
3046
3047 if (pa_streq(lvalue, "paths-input")) {
3048 pa_xstrfreev(m->input_path_names);
3049 m->input_path_names = pa_split_spaces_strv(rvalue);
3050 } else {
3051 pa_xstrfreev(m->output_path_names);
3052 m->output_path_names = pa_split_spaces_strv(rvalue);
3053 }
3054
3055 return 0;
3056 }
3057
3058 static int mapping_parse_element(
3059 const char *filename,
3060 unsigned line,
3061 const char *section,
3062 const char *lvalue,
3063 const char *rvalue,
3064 void *data,
3065 void *userdata) {
3066
3067 pa_alsa_profile_set *ps = userdata;
3068 pa_alsa_mapping *m;
3069
3070 pa_assert(ps);
3071
3072 if (!(m = mapping_get(ps, section))) {
3073 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3074 return -1;
3075 }
3076
3077 if (pa_streq(lvalue, "element-input")) {
3078 pa_xstrfreev(m->input_element);
3079 m->input_element = pa_split_spaces_strv(rvalue);
3080 } else {
3081 pa_xstrfreev(m->output_element);
3082 m->output_element = pa_split_spaces_strv(rvalue);
3083 }
3084
3085 return 0;
3086 }
3087
3088 static int mapping_parse_direction(
3089 const char *filename,
3090 unsigned line,
3091 const char *section,
3092 const char *lvalue,
3093 const char *rvalue,
3094 void *data,
3095 void *userdata) {
3096
3097 pa_alsa_profile_set *ps = userdata;
3098 pa_alsa_mapping *m;
3099
3100 pa_assert(ps);
3101
3102 if (!(m = mapping_get(ps, section))) {
3103 pa_log("[%s:%u] Section name %s invalid.", filename, line, section);
3104 return -1;
3105 }
3106
3107 if (pa_streq(rvalue, "input"))
3108 m->direction = PA_ALSA_DIRECTION_INPUT;
3109 else if (pa_streq(rvalue, "output"))
3110 m->direction = PA_ALSA_DIRECTION_OUTPUT;
3111 else if (pa_streq(rvalue, "any"))
3112 m->direction = PA_ALSA_DIRECTION_ANY;
3113 else {
3114 pa_log("[%s:%u] Direction %s invalid.", filename, line, rvalue);
3115 return -1;
3116 }
3117
3118 return 0;
3119 }
3120
3121 static int mapping_parse_description(
3122 const char *filename,
3123 unsigned line,
3124 const char *section,
3125 const char *lvalue,
3126 const char *rvalue,
3127 void *data,
3128 void *userdata) {
3129
3130 pa_alsa_profile_set *ps = userdata;
3131 pa_alsa_profile *p;
3132 pa_alsa_mapping *m;
3133
3134 pa_assert(ps);
3135
3136 if ((m = mapping_get(ps, section))) {
3137 pa_xfree(m->description);
3138 m->description = pa_xstrdup(rvalue);
3139 } else if ((p = profile_get(ps, section))) {
3140 pa_xfree(p->description);
3141 p->description = pa_xstrdup(rvalue);
3142 } else {
3143 pa_log("[%s:%u] Section name %s invalid.", filename, line, section);
3144 return -1;
3145 }
3146
3147 return 0;
3148 }
3149
3150 static int mapping_parse_priority(
3151 const char *filename,
3152 unsigned line,
3153 const char *section,
3154 const char *lvalue,
3155 const char *rvalue,
3156 void *data,
3157 void *userdata) {
3158
3159 pa_alsa_profile_set *ps = userdata;
3160 pa_alsa_profile *p;
3161 pa_alsa_mapping *m;
3162 uint32_t prio;
3163
3164 pa_assert(ps);
3165
3166 if (pa_atou(rvalue, &prio) < 0) {
3167 pa_log("[%s:%u] Priority invalid of '%s'", filename, line, section);
3168 return -1;
3169 }
3170
3171 if ((m = mapping_get(ps, section)))
3172 m->priority = prio;
3173 else if ((p = profile_get(ps, section)))
3174 p->priority = prio;
3175 else {
3176 pa_log("[%s:%u] Section name %s invalid.", filename, line, section);
3177 return -1;
3178 }
3179
3180 return 0;
3181 }
3182
3183 static int profile_parse_mappings(
3184 const char *filename,
3185 unsigned line,
3186 const char *section,
3187 const char *lvalue,
3188 const char *rvalue,
3189 void *data,
3190 void *userdata) {
3191
3192 pa_alsa_profile_set *ps = userdata;
3193 pa_alsa_profile *p;
3194
3195 pa_assert(ps);
3196
3197 if (!(p = profile_get(ps, section))) {
3198 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3199 return -1;
3200 }
3201
3202 if (pa_streq(lvalue, "input-mappings")) {
3203 pa_xstrfreev(p->input_mapping_names);
3204 p->input_mapping_names = pa_split_spaces_strv(rvalue);
3205 } else {
3206 pa_xstrfreev(p->output_mapping_names);
3207 p->output_mapping_names = pa_split_spaces_strv(rvalue);
3208 }
3209
3210 return 0;
3211 }
3212
3213 static int profile_parse_skip_probe(
3214 const char *filename,
3215 unsigned line,
3216 const char *section,
3217 const char *lvalue,
3218 const char *rvalue,
3219 void *data,
3220 void *userdata) {
3221
3222 pa_alsa_profile_set *ps = userdata;
3223 pa_alsa_profile *p;
3224 int b;
3225
3226 pa_assert(ps);
3227
3228 if (!(p = profile_get(ps, section))) {
3229 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3230 return -1;
3231 }
3232
3233 if ((b = pa_parse_boolean(rvalue)) < 0) {
3234 pa_log("[%s:%u] Skip probe invalid of '%s'", filename, line, section);
3235 return -1;
3236 }
3237
3238 p->supported = b;
3239
3240 return 0;
3241 }
3242
3243 static int decibel_fix_parse_db_values(
3244 const char *filename,
3245 unsigned line,
3246 const char *section,
3247 const char *lvalue,
3248 const char *rvalue,
3249 void *data,
3250 void *userdata) {
3251
3252 pa_alsa_profile_set *ps = userdata;
3253 pa_alsa_decibel_fix *db_fix;
3254 char **items;
3255 char *item;
3256 long *db_values;
3257 unsigned n = 8; /* Current size of the db_values table. */
3258 unsigned min_step = 0;
3259 unsigned max_step = 0;
3260 unsigned i = 0; /* Index to the items table. */
3261 unsigned prev_step = 0;
3262 double prev_db = 0;
3263
3264 pa_assert(filename);
3265 pa_assert(section);
3266 pa_assert(lvalue);
3267 pa_assert(rvalue);
3268 pa_assert(ps);
3269
3270 if (!(db_fix = decibel_fix_get(ps, section))) {
3271 pa_log("[%s:%u] %s invalid in section %s", filename, line, lvalue, section);
3272 return -1;
3273 }
3274
3275 if (!(items = pa_split_spaces_strv(rvalue))) {
3276 pa_log("[%s:%u] Value missing", pa_strnull(filename), line);
3277 return -1;
3278 }
3279
3280 db_values = pa_xnew(long, n);
3281
3282 while ((item = items[i++])) {
3283 char *s = item; /* Step value string. */
3284 char *d = item; /* dB value string. */
3285 uint32_t step;
3286 double db;
3287
3288 /* Move d forward until it points to a colon or to the end of the item. */
3289 for (; *d && *d != ':'; ++d);
3290
3291 if (d == s) {
3292 /* item started with colon. */
3293 pa_log("[%s:%u] No step value found in %s", filename, line, item);
3294 goto fail;
3295 }
3296
3297 if (!*d || !*(d + 1)) {
3298 /* No colon found, or it was the last character in item. */
3299 pa_log("[%s:%u] No dB value found in %s", filename, line, item);
3300 goto fail;
3301 }
3302
3303 /* pa_atou() needs a null-terminating string. Let's replace the colon
3304 * with a zero byte. */
3305 *d++ = '\0';
3306
3307 if (pa_atou(s, &step) < 0) {
3308 pa_log("[%s:%u] Invalid step value: %s", filename, line, s);
3309 goto fail;
3310 }
3311
3312 if (pa_atod(d, &db) < 0) {
3313 pa_log("[%s:%u] Invalid dB value: %s", filename, line, d);
3314 goto fail;
3315 }
3316
3317 if (step <= prev_step && i != 1) {
3318 pa_log("[%s:%u] Step value %u not greater than the previous value %u", filename, line, step, prev_step);
3319 goto fail;
3320 }
3321
3322 if (db < prev_db && i != 1) {
3323 pa_log("[%s:%u] Decibel value %0.2f less than the previous value %0.2f", filename, line, db, prev_db);
3324 goto fail;
3325 }
3326
3327 if (i == 1) {
3328 min_step = step;
3329 db_values[0] = (long) (db * 100.0);
3330 prev_step = step;
3331 prev_db = db;
3332 } else {
3333 /* Interpolate linearly. */
3334 double db_increment = (db - prev_db) / (step - prev_step);
3335
3336 for (; prev_step < step; ++prev_step, prev_db += db_increment) {
3337
3338 /* Reallocate the db_values table if it's about to overflow. */
3339 if (prev_step + 1 - min_step == n) {
3340 n *= 2;
3341 db_values = pa_xrenew(long, db_values, n);
3342 }
3343
3344 db_values[prev_step + 1 - min_step] = (long) ((prev_db + db_increment) * 100.0);
3345 }
3346 }
3347
3348 max_step = step;
3349 }
3350
3351 db_fix->min_step = min_step;
3352 db_fix->max_step = max_step;
3353 pa_xfree(db_fix->db_values);
3354 db_fix->db_values = db_values;
3355
3356 pa_xstrfreev(items);
3357
3358 return 0;
3359
3360 fail:
3361 pa_xstrfreev(items);
3362 pa_xfree(db_values);
3363
3364 return -1;
3365 }
3366
3367 static int mapping_verify(pa_alsa_mapping *m, const pa_channel_map *bonus) {
3368
3369 static const struct description_map well_known_descriptions[] = {
3370 { "analog-mono", N_("Analog Mono") },
3371 { "analog-stereo", N_("Analog Stereo") },
3372 { "analog-surround-21", N_("Analog Surround 2.1") },
3373 { "analog-surround-30", N_("Analog Surround 3.0") },
3374 { "analog-surround-31", N_("Analog Surround 3.1") },
3375 { "analog-surround-40", N_("Analog Surround 4.0") },
3376 { "analog-surround-41", N_("Analog Surround 4.1") },
3377 { "analog-surround-50", N_("Analog Surround 5.0") },
3378 { "analog-surround-51", N_("Analog Surround 5.1") },
3379 { "analog-surround-61", N_("Analog Surround 6.0") },
3380 { "analog-surround-61", N_("Analog Surround 6.1") },
3381 { "analog-surround-70", N_("Analog Surround 7.0") },
3382 { "analog-surround-71", N_("Analog Surround 7.1") },
3383 { "iec958-stereo", N_("Digital Stereo (IEC958)") },
3384 { "iec958-passthrough", N_("Digital Passthrough (IEC958)") },
3385 { "iec958-ac3-surround-40", N_("Digital Surround 4.0 (IEC958/AC3)") },
3386 { "iec958-ac3-surround-51", N_("Digital Surround 5.1 (IEC958/AC3)") },
3387 { "hdmi-stereo", N_("Digital Stereo (HDMI)") }
3388 };
3389
3390 pa_assert(m);
3391
3392 if (!pa_channel_map_valid(&m->channel_map)) {
3393 pa_log("Mapping %s is missing channel map.", m->name);
3394 return -1;
3395 }
3396
3397 if (!m->device_strings) {
3398 pa_log("Mapping %s is missing device strings.", m->name);
3399 return -1;
3400 }
3401
3402 if ((m->input_path_names && m->input_element) ||
3403 (m->output_path_names && m->output_element)) {
3404 pa_log("Mapping %s must have either mixer path or mixer element, not both.", m->name);
3405 return -1;
3406 }
3407
3408 if (!m->description)
3409 m->description = pa_xstrdup(lookup_description(m->name,
3410 well_known_descriptions,
3411 PA_ELEMENTSOF(well_known_descriptions)));
3412
3413 if (!m->description)
3414 m->description = pa_xstrdup(m->name);
3415
3416 if (bonus) {
3417 if (pa_channel_map_equal(&m->channel_map, bonus))
3418 m->priority += 50;
3419 else if (m->channel_map.channels == bonus->channels)
3420 m->priority += 30;
3421 }
3422
3423 return 0;
3424 }
3425
3426 void pa_alsa_mapping_dump(pa_alsa_mapping *m) {
3427 char cm[PA_CHANNEL_MAP_SNPRINT_MAX];
3428
3429 pa_assert(m);
3430
3431 pa_log_debug("Mapping %s (%s), priority=%u, channel_map=%s, supported=%s, direction=%i",
3432 m->name,
3433 pa_strnull(m->description),
3434 m->priority,
3435 pa_channel_map_snprint(cm, sizeof(cm), &m->channel_map),
3436 pa_yes_no(m->supported),
3437 m->direction);
3438 }
3439
3440 static void profile_set_add_auto_pair(
3441 pa_alsa_profile_set *ps,
3442 pa_alsa_mapping *m, /* output */
3443 pa_alsa_mapping *n /* input */) {
3444
3445 char *name;
3446 pa_alsa_profile *p;
3447
3448 pa_assert(ps);
3449 pa_assert(m || n);
3450
3451 if (m && m->direction == PA_ALSA_DIRECTION_INPUT)
3452 return;
3453
3454 if (n && n->direction == PA_ALSA_DIRECTION_OUTPUT)
3455 return;
3456
3457 if (m && n)
3458 name = pa_sprintf_malloc("output:%s+input:%s", m->name, n->name);
3459 else if (m)
3460 name = pa_sprintf_malloc("output:%s", m->name);
3461 else
3462 name = pa_sprintf_malloc("input:%s", n->name);
3463
3464 if (pa_hashmap_get(ps->profiles, name)) {
3465 pa_xfree(name);
3466 return;
3467 }
3468
3469 p = pa_xnew0(pa_alsa_profile, 1);
3470 p->profile_set = ps;
3471 p->name = name;
3472
3473 if (m) {
3474 p->output_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
3475 pa_idxset_put(p->output_mappings, m, NULL);
3476 p->priority += m->priority * 100;
3477 }
3478
3479 if (n) {
3480 p->input_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
3481 pa_idxset_put(p->input_mappings, n, NULL);
3482 p->priority += n->priority;
3483 }
3484
3485 pa_hashmap_put(ps->profiles, p->name, p);
3486 }
3487
3488 static void profile_set_add_auto(pa_alsa_profile_set *ps) {
3489 pa_alsa_mapping *m, *n;
3490 void *m_state, *n_state;
3491
3492 pa_assert(ps);
3493
3494 PA_HASHMAP_FOREACH(m, ps->mappings, m_state) {
3495 profile_set_add_auto_pair(ps, m, NULL);
3496
3497 PA_HASHMAP_FOREACH(n, ps->mappings, n_state)
3498 profile_set_add_auto_pair(ps, m, n);
3499 }
3500
3501 PA_HASHMAP_FOREACH(n, ps->mappings, n_state)
3502 profile_set_add_auto_pair(ps, NULL, n);
3503 }
3504
3505 static int profile_verify(pa_alsa_profile *p) {
3506
3507 static const struct description_map well_known_descriptions[] = {
3508 { "output:analog-mono+input:analog-mono", N_("Analog Mono Duplex") },
3509 { "output:analog-stereo+input:analog-stereo", N_("Analog Stereo Duplex") },
3510 { "output:iec958-stereo+input:iec958-stereo", N_("Digital Stereo Duplex (IEC958)") },
3511 { "off", N_("Off") }
3512 };
3513
3514 pa_assert(p);
3515
3516 /* Replace the output mapping names by the actual mappings */
3517 if (p->output_mapping_names) {
3518 char **name;
3519
3520 pa_assert(!p->output_mappings);
3521 p->output_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
3522
3523 for (name = p->output_mapping_names; *name; name++) {
3524 pa_alsa_mapping *m;
3525 char **in;
3526 pa_bool_t duplicate = FALSE;
3527
3528 for (in = name + 1; *in; in++)
3529 if (pa_streq(*name, *in)) {
3530 duplicate = TRUE;
3531 break;
3532 }
3533
3534 if (duplicate)
3535 continue;
3536
3537 if (!(m = pa_hashmap_get(p->profile_set->mappings, *name)) || m->direction == PA_ALSA_DIRECTION_INPUT) {
3538 pa_log("Profile '%s' refers to unexistant mapping '%s'.", p->name, *name);
3539 return -1;
3540 }
3541
3542 pa_idxset_put(p->output_mappings, m, NULL);
3543
3544 if (p->supported)
3545 m->supported++;
3546 }
3547
3548 pa_xstrfreev(p->output_mapping_names);
3549 p->output_mapping_names = NULL;
3550 }
3551
3552 /* Replace the input mapping names by the actual mappings */
3553 if (p->input_mapping_names) {
3554 char **name;
3555
3556 pa_assert(!p->input_mappings);
3557 p->input_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
3558
3559 for (name = p->input_mapping_names; *name; name++) {
3560 pa_alsa_mapping *m;
3561 char **in;
3562 pa_bool_t duplicate = FALSE;
3563
3564 for (in = name + 1; *in; in++)
3565 if (pa_streq(*name, *in)) {
3566 duplicate = TRUE;
3567 break;
3568 }
3569
3570 if (duplicate)
3571 continue;
3572
3573 if (!(m = pa_hashmap_get(p->profile_set->mappings, *name)) || m->direction == PA_ALSA_DIRECTION_OUTPUT) {
3574 pa_log("Profile '%s' refers to unexistant mapping '%s'.", p->name, *name);
3575 return -1;
3576 }
3577
3578 pa_idxset_put(p->input_mappings, m, NULL);
3579
3580 if (p->supported)
3581 m->supported++;
3582 }
3583
3584 pa_xstrfreev(p->input_mapping_names);
3585 p->input_mapping_names = NULL;
3586 }
3587
3588 if (!p->input_mappings && !p->output_mappings) {
3589 pa_log("Profile '%s' lacks mappings.", p->name);
3590 return -1;
3591 }
3592
3593 if (!p->description)
3594 p->description = pa_xstrdup(lookup_description(p->name,
3595 well_known_descriptions,
3596 PA_ELEMENTSOF(well_known_descriptions)));
3597
3598 if (!p->description) {
3599 pa_strbuf *sb;
3600 uint32_t idx;
3601 pa_alsa_mapping *m;
3602
3603 sb = pa_strbuf_new();
3604
3605 if (p->output_mappings)
3606 PA_IDXSET_FOREACH(m, p->output_mappings, idx) {
3607 if (!pa_strbuf_isempty(sb))
3608 pa_strbuf_puts(sb, " + ");
3609
3610 pa_strbuf_printf(sb, _("%s Output"), m->description);
3611 }
3612
3613 if (p->input_mappings)
3614 PA_IDXSET_FOREACH(m, p->input_mappings, idx) {
3615 if (!pa_strbuf_isempty(sb))
3616 pa_strbuf_puts(sb, " + ");
3617
3618 pa_strbuf_printf(sb, _("%s Input"), m->description);
3619 }
3620
3621 p->description = pa_strbuf_tostring_free(sb);
3622 }
3623
3624 return 0;
3625 }
3626
3627 void pa_alsa_profile_dump(pa_alsa_profile *p) {
3628 uint32_t idx;
3629 pa_alsa_mapping *m;
3630 pa_assert(p);
3631
3632 pa_log_debug("Profile %s (%s), priority=%u, supported=%s n_input_mappings=%u, n_output_mappings=%u",
3633 p->name,
3634 pa_strnull(p->description),
3635 p->priority,
3636 pa_yes_no(p->supported),
3637 p->input_mappings ? pa_idxset_size(p->input_mappings) : 0,
3638 p->output_mappings ? pa_idxset_size(p->output_mappings) : 0);
3639
3640 if (p->input_mappings)
3641 PA_IDXSET_FOREACH(m, p->input_mappings, idx)
3642 pa_log_debug("Input %s", m->name);
3643
3644 if (p->output_mappings)
3645 PA_IDXSET_FOREACH(m, p->output_mappings, idx)
3646 pa_log_debug("Output %s", m->name);
3647 }
3648
3649 static int decibel_fix_verify(pa_alsa_decibel_fix *db_fix) {
3650 pa_assert(db_fix);
3651
3652 /* Check that the dB mapping has been configured. Since "db-values" is
3653 * currently the only option in the DecibelFix section, and decibel fix
3654 * objects don't get created if a DecibelFix section is empty, this is
3655 * actually a redundant check. Having this may prevent future bugs,
3656 * however. */
3657 if (!db_fix->db_values) {
3658 pa_log("Decibel fix for element %s lacks the dB values.", db_fix->name);
3659 return -1;
3660 }
3661
3662 return 0;
3663 }
3664
3665 void pa_alsa_decibel_fix_dump(pa_alsa_decibel_fix *db_fix) {
3666 char *db_values = NULL;
3667
3668 pa_assert(db_fix);
3669
3670 if (db_fix->db_values) {
3671 pa_strbuf *buf;
3672 long i;
3673 long max_i = db_fix->max_step - db_fix->min_step;
3674
3675 buf = pa_strbuf_new();
3676 pa_strbuf_printf(buf, "[%li]:%0.2f", db_fix->min_step, db_fix->db_values[0] / 100.0);
3677
3678 for (i = 1; i <= max_i; ++i)
3679 pa_strbuf_printf(buf, " [%li]:%0.2f", i + db_fix->min_step, db_fix->db_values[i] / 100.0);
3680
3681 db_values = pa_strbuf_tostring_free(buf);
3682 }
3683
3684 pa_log_debug("Decibel fix %s, min_step=%li, max_step=%li, db_values=%s",
3685 db_fix->name, db_fix->min_step, db_fix->max_step, pa_strnull(db_values));
3686
3687 pa_xfree(db_values);
3688 }
3689
3690 pa_alsa_profile_set* pa_alsa_profile_set_new(const char *fname, const pa_channel_map *bonus) {
3691 pa_alsa_profile_set *ps;
3692 pa_alsa_profile *p;
3693 pa_alsa_mapping *m;
3694 pa_alsa_decibel_fix *db_fix;
3695 char *fn;
3696 int r;
3697 void *state;
3698
3699 static pa_config_item items[] = {
3700 /* [General] */
3701 { "auto-profiles", pa_config_parse_bool, NULL, "General" },
3702
3703 /* [Mapping ...] */
3704 { "device-strings", mapping_parse_device_strings, NULL, NULL },
3705 { "channel-map", mapping_parse_channel_map, NULL, NULL },
3706 { "paths-input", mapping_parse_paths, NULL, NULL },
3707 { "paths-output", mapping_parse_paths, NULL, NULL },
3708 { "element-input", mapping_parse_element, NULL, NULL },
3709 { "element-output", mapping_parse_element, NULL, NULL },
3710 { "direction", mapping_parse_direction, NULL, NULL },
3711
3712 /* Shared by [Mapping ...] and [Profile ...] */
3713 { "description", mapping_parse_description, NULL, NULL },
3714 { "priority", mapping_parse_priority, NULL, NULL },
3715
3716 /* [Profile ...] */
3717 { "input-mappings", profile_parse_mappings, NULL, NULL },
3718 { "output-mappings", profile_parse_mappings, NULL, NULL },
3719 { "skip-probe", profile_parse_skip_probe, NULL, NULL },
3720
3721 /* [DecibelFix ...] */
3722 { "db-values", decibel_fix_parse_db_values, NULL, NULL },
3723 { NULL, NULL, NULL, NULL }
3724 };
3725
3726 ps = pa_xnew0(pa_alsa_profile_set, 1);
3727 ps->mappings = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
3728 ps->profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
3729 ps->decibel_fixes = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
3730
3731 items[0].data = &ps->auto_profiles;
3732
3733 if (!fname)
3734 fname = "default.conf";
3735
3736 fn = pa_maybe_prefix_path(fname,
3737 #if defined(__linux__) && !defined(__OPTIMIZE__)
3738 pa_run_from_build_tree() ? PA_BUILDDIR "/modules/alsa/mixer/profile-sets/" :
3739 #endif
3740 PA_ALSA_PROFILE_SETS_DIR);
3741
3742 r = pa_config_parse(fn, NULL, items, ps);
3743 pa_xfree(fn);
3744
3745 if (r < 0)
3746 goto fail;
3747
3748 PA_HASHMAP_FOREACH(m, ps->mappings, state)
3749 if (mapping_verify(m, bonus) < 0)
3750 goto fail;
3751
3752 if (ps->auto_profiles)
3753 profile_set_add_auto(ps);
3754
3755 PA_HASHMAP_FOREACH(p, ps->profiles, state)
3756 if (profile_verify(p) < 0)
3757 goto fail;
3758
3759 PA_HASHMAP_FOREACH(db_fix, ps->decibel_fixes, state)
3760 if (decibel_fix_verify(db_fix) < 0)
3761 goto fail;
3762
3763 return ps;
3764
3765 fail:
3766 pa_alsa_profile_set_free(ps);
3767 return NULL;
3768 }
3769
3770 void pa_alsa_profile_set_probe(
3771 pa_alsa_profile_set *ps,
3772 const char *dev_id,
3773 const pa_sample_spec *ss,
3774 unsigned default_n_fragments,
3775 unsigned default_fragment_size_msec) {
3776
3777 void *state;
3778 pa_alsa_profile *p, *last = NULL;
3779 pa_alsa_mapping *m;
3780
3781 pa_assert(ps);
3782 pa_assert(dev_id);
3783 pa_assert(ss);
3784
3785 if (ps->probed)
3786 return;
3787
3788 PA_HASHMAP_FOREACH(p, ps->profiles, state) {
3789 pa_sample_spec try_ss;
3790 pa_channel_map try_map;
3791 snd_pcm_uframes_t try_period_size, try_buffer_size;
3792 uint32_t idx;
3793
3794 /* Is this already marked that it is supported? (i.e. from the config file) */
3795 if (p->supported)
3796 continue;
3797
3798 pa_log_debug("Looking at profile %s", p->name);
3799
3800 /* Close PCMs from the last iteration we don't need anymore */
3801 if (last && last->output_mappings)
3802 PA_IDXSET_FOREACH(m, last->output_mappings, idx) {
3803
3804 if (!m->output_pcm)
3805 break;
3806
3807 if (last->supported)
3808 m->supported++;
3809
3810 if (!p->output_mappings || !pa_idxset_get_by_data(p->output_mappings, m, NULL)) {
3811 snd_pcm_close(m->output_pcm);
3812 m->output_pcm = NULL;
3813 }
3814 }
3815
3816 if (last && last->input_mappings)
3817 PA_IDXSET_FOREACH(m, last->input_mappings, idx) {
3818
3819 if (!m->input_pcm)
3820 break;
3821
3822 if (last->supported)
3823 m->supported++;
3824
3825 if (!p->input_mappings || !pa_idxset_get_by_data(p->input_mappings, m, NULL)) {
3826 snd_pcm_close(m->input_pcm);
3827 m->input_pcm = NULL;
3828 }
3829 }
3830
3831 p->supported = TRUE;
3832
3833 /* Check if we can open all new ones */
3834 if (p->output_mappings)
3835 PA_IDXSET_FOREACH(m, p->output_mappings, idx) {
3836
3837 if (m->output_pcm)
3838 continue;
3839
3840 pa_log_debug("Checking for playback on %s (%s)", m->description, m->name);
3841 try_map = m->channel_map;
3842 try_ss = *ss;
3843 try_ss.channels = try_map.channels;
3844
3845 try_period_size =
3846 pa_usec_to_bytes(default_fragment_size_msec * PA_USEC_PER_MSEC, &try_ss) /
3847 pa_frame_size(&try_ss);
3848 try_buffer_size = default_n_fragments * try_period_size;
3849
3850 if (!(m ->output_pcm = pa_alsa_open_by_template(
3851 m->device_strings,
3852 dev_id,
3853 NULL,
3854 &try_ss, &try_map,
3855 SND_PCM_STREAM_PLAYBACK,
3856 &try_period_size, &try_buffer_size, 0, NULL, NULL,
3857 TRUE))) {
3858 p->supported = FALSE;
3859 break;
3860 }
3861 }
3862
3863 if (p->input_mappings && p->supported)
3864 PA_IDXSET_FOREACH(m, p->input_mappings, idx) {
3865
3866 if (m->input_pcm)
3867 continue;
3868
3869 pa_log_debug("Checking for recording on %s (%s)", m->description, m->name);
3870 try_map = m->channel_map;
3871 try_ss = *ss;
3872 try_ss.channels = try_map.channels;
3873
3874 try_period_size =
3875 pa_usec_to_bytes(default_fragment_size_msec*PA_USEC_PER_MSEC, &try_ss) /
3876 pa_frame_size(&try_ss);
3877 try_buffer_size = default_n_fragments * try_period_size;
3878
3879 if (!(m ->input_pcm = pa_alsa_open_by_template(
3880 m->device_strings,
3881 dev_id,
3882 NULL,
3883 &try_ss, &try_map,
3884 SND_PCM_STREAM_CAPTURE,
3885 &try_period_size, &try_buffer_size, 0, NULL, NULL,
3886 TRUE))) {
3887 p->supported = FALSE;
3888 break;
3889 }
3890 }
3891
3892 last = p;
3893
3894 if (p->supported)
3895 pa_log_debug("Profile %s supported.", p->name);
3896 }
3897
3898 /* Clean up */
3899 if (last) {
3900 uint32_t idx;
3901
3902 if (last->output_mappings)
3903 PA_IDXSET_FOREACH(m, last->output_mappings, idx)
3904 if (m->output_pcm) {
3905
3906 if (last->supported)
3907 m->supported++;
3908
3909 snd_pcm_close(m->output_pcm);
3910 m->output_pcm = NULL;
3911 }
3912
3913 if (last->input_mappings)
3914 PA_IDXSET_FOREACH(m, last->input_mappings, idx)
3915 if (m->input_pcm) {
3916
3917 if (last->supported)
3918 m->supported++;
3919
3920 snd_pcm_close(m->input_pcm);
3921 m->input_pcm = NULL;
3922 }
3923 }
3924
3925 PA_HASHMAP_FOREACH(p, ps->profiles, state)
3926 if (!p->supported) {
3927 pa_hashmap_remove(ps->profiles, p->name);
3928 profile_free(p);
3929 }
3930
3931 PA_HASHMAP_FOREACH(m, ps->mappings, state)
3932 if (m->supported <= 0) {
3933 pa_hashmap_remove(ps->mappings, m->name);
3934 mapping_free(m);
3935 }
3936
3937 ps->probed = TRUE;
3938 }
3939
3940 void pa_alsa_profile_set_dump(pa_alsa_profile_set *ps) {
3941 pa_alsa_profile *p;
3942 pa_alsa_mapping *m;
3943 pa_alsa_decibel_fix *db_fix;
3944 void *state;
3945
3946 pa_assert(ps);
3947
3948 pa_log_debug("Profile set %p, auto_profiles=%s, probed=%s, n_mappings=%u, n_profiles=%u, n_decibel_fixes=%u",
3949 (void*)
3950 ps,
3951 pa_yes_no(ps->auto_profiles),
3952 pa_yes_no(ps->probed),
3953 pa_hashmap_size(ps->mappings),
3954 pa_hashmap_size(ps->profiles),
3955 pa_hashmap_size(ps->decibel_fixes));
3956
3957 PA_HASHMAP_FOREACH(m, ps->mappings, state)
3958 pa_alsa_mapping_dump(m);
3959
3960 PA_HASHMAP_FOREACH(p, ps->profiles, state)
3961 pa_alsa_profile_dump(p);
3962
3963 PA_HASHMAP_FOREACH(db_fix, ps->decibel_fixes, state)
3964 pa_alsa_decibel_fix_dump(db_fix);
3965 }
3966
3967 void pa_alsa_add_ports(pa_hashmap **p, pa_alsa_path_set *ps) {
3968 pa_alsa_path *path;
3969
3970 pa_assert(p);
3971 pa_assert(!*p);
3972 pa_assert(ps);
3973
3974 /* if there is no path, we don't want a port list */
3975 if (!ps->paths)
3976 return;
3977
3978 if (!ps->paths->next){
3979 pa_alsa_setting *s;
3980
3981 /* If there is only one path, but no or only one setting, then
3982 * we want a port list either */
3983 if (!ps->paths->settings || !ps->paths->settings->next)
3984 return;
3985
3986 /* Ok, there is only one path, however with multiple settings,
3987 * so let's create a port for each setting */
3988 *p = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
3989
3990 PA_LLIST_FOREACH(s, ps->paths->settings) {
3991 pa_device_port *port;
3992 pa_alsa_port_data *data;
3993
3994 port = pa_device_port_new(s->name, s->description, sizeof(pa_alsa_port_data));
3995 port->priority = s->priority;
3996
3997 data = PA_DEVICE_PORT_DATA(port);
3998 data->path = ps->paths;
3999 data->setting = s;
4000
4001 pa_hashmap_put(*p, port->name, port);
4002 }
4003
4004 } else {
4005
4006 /* We have multiple paths, so let's create a port for each
4007 * one, and each of each settings */
4008 *p = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
4009
4010 PA_LLIST_FOREACH(path, ps->paths) {
4011
4012 if (!path->settings || !path->settings->next) {
4013 pa_device_port *port;
4014 pa_alsa_port_data *data;
4015
4016 /* If there is no or just one setting we only need a
4017 * single entry */
4018
4019 port = pa_device_port_new(path->name, path->description, sizeof(pa_alsa_port_data));
4020 port->priority = path->priority * 100;
4021
4022
4023 data = PA_DEVICE_PORT_DATA(port);
4024 data->path = path;
4025 data->setting = path->settings;
4026
4027 pa_hashmap_put(*p, port->name, port);
4028 } else {
4029 pa_alsa_setting *s;
4030
4031 PA_LLIST_FOREACH(s, path->settings) {
4032 pa_device_port *port;
4033 pa_alsa_port_data *data;
4034 char *n, *d;
4035
4036 n = pa_sprintf_malloc("%s;%s", path->name, s->name);
4037
4038 if (s->description[0])
4039 d = pa_sprintf_malloc(_("%s / %s"), path->description, s->description);
4040 else
4041 d = pa_xstrdup(path->description);
4042
4043 port = pa_device_port_new(n, d, sizeof(pa_alsa_port_data));
4044 port->priority = path->priority * 100 + s->priority;
4045
4046 pa_xfree(n);
4047 pa_xfree(d);
4048
4049 data = PA_DEVICE_PORT_DATA(port);
4050 data->path = path;
4051 data->setting = s;
4052
4053 pa_hashmap_put(*p, port->name, port);
4054 }
4055 }
4056 }
4057 }
4058
4059 pa_log_debug("Added %u ports", pa_hashmap_size(*p));
4060 }