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