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