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