src/modules/alsa/alsa-mixer.c

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