src/modules/alsa/alsa-mixer.c

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