src/modules/alsa/alsa-mixer.c

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