code.delx.au - pulseaudio/blob - src/modules/alsa/alsa-util.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 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <sys/types.h>
  28 #include <limits.h>
  29 #include <asoundlib.h>
  30
  31 #include <pulse/sample.h>
  32 #include <pulse/xmalloc.h>
  33 #include <pulse/timeval.h>
  34 #include <pulse/util.h>
  35 #include <pulse/i18n.h>
  36
  37 #include <pulsecore/log.h>
  38 #include <pulsecore/macro.h>
  39 #include <pulsecore/core-util.h>
  40 #include <pulsecore/atomic.h>
  41 #include <pulsecore/core-error.h>
  42 #include <pulsecore/once.h>
  43
  44 #include "alsa-util.h"
  45
  46 #ifdef HAVE_HAL
  47 #include "hal-util.h"
  48 #endif
  49
  50 struct pa_alsa_fdlist {
  51     unsigned num_fds;
  52     struct pollfd *fds;
  53     /* This is a temporary buffer used to avoid lots of mallocs */
  54     struct pollfd *work_fds;
  55
  56     snd_mixer_t *mixer;
  57
  58     pa_mainloop_api *m;
  59     pa_defer_event *defer;
  60     pa_io_event **ios;
  61
  62     pa_bool_t polled;
  63
  64     void (*cb)(void *userdata);
  65     void *userdata;
  66 };
  67
  68 static void io_cb(pa_mainloop_api*a, pa_io_event* e, int fd, pa_io_event_flags_t events, void *userdata) {
  69
  70     struct pa_alsa_fdlist *fdl = userdata;
  71     int err;
  72     unsigned i;
  73     unsigned short revents;
  74
  75     pa_assert(a);
  76     pa_assert(fdl);
  77     pa_assert(fdl->mixer);
  78     pa_assert(fdl->fds);
  79     pa_assert(fdl->work_fds);
  80
  81     if (fdl->polled)
  82         return;
  83
  84     fdl->polled = TRUE;
  85
  86     memcpy(fdl->work_fds, fdl->fds, sizeof(struct pollfd) * fdl->num_fds);
  87
  88     for (i = 0; i < fdl->num_fds; i++) {
  89         if (e == fdl->ios[i]) {
  90             if (events & PA_IO_EVENT_INPUT)
  91                 fdl->work_fds[i].revents |= POLLIN;
  92             if (events & PA_IO_EVENT_OUTPUT)
  93                 fdl->work_fds[i].revents |= POLLOUT;
  94             if (events & PA_IO_EVENT_ERROR)
  95                 fdl->work_fds[i].revents |= POLLERR;
  96             if (events & PA_IO_EVENT_HANGUP)
  97                 fdl->work_fds[i].revents |= POLLHUP;
  98             break;
  99         }
 100     }
 101
 102     pa_assert(i != fdl->num_fds);
 103
 104     if ((err = snd_mixer_poll_descriptors_revents(fdl->mixer, fdl->work_fds, fdl->num_fds, &revents)) < 0) {
 105         pa_log_error("Unable to get poll revent: %s", snd_strerror(err));
 106         return;
 107     }
 108
 109     a->defer_enable(fdl->defer, 1);
 110
 111     if (revents)
 112         snd_mixer_handle_events(fdl->mixer);
 113 }
 114
 115 static void defer_cb(pa_mainloop_api*a, pa_defer_event* e, void *userdata) {
 116     struct pa_alsa_fdlist *fdl = userdata;
 117     unsigned num_fds, i;
 118     int err, n;
 119     struct pollfd *temp;
 120
 121     pa_assert(a);
 122     pa_assert(fdl);
 123     pa_assert(fdl->mixer);
 124
 125     a->defer_enable(fdl->defer, 0);
 126
 127     if ((n = snd_mixer_poll_descriptors_count(fdl->mixer)) < 0) {
 128         pa_log("snd_mixer_poll_descriptors_count() failed: %s", snd_strerror(n));
 129         return;
 130     }
 131     num_fds = (unsigned) n;
 132
 133     if (num_fds != fdl->num_fds) {
 134         if (fdl->fds)
 135             pa_xfree(fdl->fds);
 136         if (fdl->work_fds)
 137             pa_xfree(fdl->work_fds);
 138         fdl->fds = pa_xnew0(struct pollfd, num_fds);
 139         fdl->work_fds = pa_xnew(struct pollfd, num_fds);
 140     }
 141
 142     memset(fdl->work_fds, 0, sizeof(struct pollfd) * num_fds);
 143
 144     if ((err = snd_mixer_poll_descriptors(fdl->mixer, fdl->work_fds, num_fds)) < 0) {
 145         pa_log_error("Unable to get poll descriptors: %s", snd_strerror(err));
 146         return;
 147     }
 148
 149     fdl->polled = FALSE;
 150
 151     if (memcmp(fdl->fds, fdl->work_fds, sizeof(struct pollfd) * num_fds) == 0)
 152         return;
 153
 154     if (fdl->ios) {
 155         for (i = 0; i < fdl->num_fds; i++)
 156             a->io_free(fdl->ios[i]);
 157
 158         if (num_fds != fdl->num_fds) {
 159             pa_xfree(fdl->ios);
 160             fdl->ios = NULL;
 161         }
 162     }
 163
 164     if (!fdl->ios)
 165         fdl->ios = pa_xnew(pa_io_event*, num_fds);
 166
 167     /* Swap pointers */
 168     temp = fdl->work_fds;
 169     fdl->work_fds = fdl->fds;
 170     fdl->fds = temp;
 171
 172     fdl->num_fds = num_fds;
 173
 174     for (i = 0;i < num_fds;i++)
 175         fdl->ios[i] = a->io_new(a, fdl->fds[i].fd,
 176             ((fdl->fds[i].events & POLLIN) ? PA_IO_EVENT_INPUT : 0) |
 177             ((fdl->fds[i].events & POLLOUT) ? PA_IO_EVENT_OUTPUT : 0),
 178             io_cb, fdl);
 179 }
 180
 181 struct pa_alsa_fdlist *pa_alsa_fdlist_new(void) {
 182     struct pa_alsa_fdlist *fdl;
 183
 184     fdl = pa_xnew0(struct pa_alsa_fdlist, 1);
 185
 186     fdl->num_fds = 0;
 187     fdl->fds = NULL;
 188     fdl->work_fds = NULL;
 189     fdl->mixer = NULL;
 190     fdl->m = NULL;
 191     fdl->defer = NULL;
 192     fdl->ios = NULL;
 193     fdl->polled = FALSE;
 194
 195     return fdl;
 196 }
 197
 198 void pa_alsa_fdlist_free(struct pa_alsa_fdlist *fdl) {
 199     pa_assert(fdl);
 200
 201     if (fdl->defer) {
 202         pa_assert(fdl->m);
 203         fdl->m->defer_free(fdl->defer);
 204     }
 205
 206     if (fdl->ios) {
 207         unsigned i;
 208         pa_assert(fdl->m);
 209         for (i = 0; i < fdl->num_fds; i++)
 210             fdl->m->io_free(fdl->ios[i]);
 211         pa_xfree(fdl->ios);
 212     }
 213
 214     if (fdl->fds)
 215         pa_xfree(fdl->fds);
 216     if (fdl->work_fds)
 217         pa_xfree(fdl->work_fds);
 218
 219     pa_xfree(fdl);
 220 }
 221
 222 int pa_alsa_fdlist_set_mixer(struct pa_alsa_fdlist *fdl, snd_mixer_t *mixer_handle, pa_mainloop_api* m) {
 223     pa_assert(fdl);
 224     pa_assert(mixer_handle);
 225     pa_assert(m);
 226     pa_assert(!fdl->m);
 227
 228     fdl->mixer = mixer_handle;
 229     fdl->m = m;
 230     fdl->defer = m->defer_new(m, defer_cb, fdl);
 231
 232     return 0;
 233 }
 234
 235 static int set_format(snd_pcm_t *pcm_handle, snd_pcm_hw_params_t *hwparams, pa_sample_format_t *f) {
 236
 237     static const snd_pcm_format_t format_trans[] = {
 238         [PA_SAMPLE_U8] = SND_PCM_FORMAT_U8,
 239         [PA_SAMPLE_ALAW] = SND_PCM_FORMAT_A_LAW,
 240         [PA_SAMPLE_ULAW] = SND_PCM_FORMAT_MU_LAW,
 241         [PA_SAMPLE_S16LE] = SND_PCM_FORMAT_S16_LE,
 242         [PA_SAMPLE_S16BE] = SND_PCM_FORMAT_S16_BE,
 243         [PA_SAMPLE_FLOAT32LE] = SND_PCM_FORMAT_FLOAT_LE,
 244         [PA_SAMPLE_FLOAT32BE] = SND_PCM_FORMAT_FLOAT_BE,
 245         [PA_SAMPLE_S32LE] = SND_PCM_FORMAT_S32_LE,
 246         [PA_SAMPLE_S32BE] = SND_PCM_FORMAT_S32_BE,
 247         [PA_SAMPLE_S24LE] = SND_PCM_FORMAT_S24_3LE,
 248         [PA_SAMPLE_S24BE] = SND_PCM_FORMAT_S24_3BE,
 249         [PA_SAMPLE_S24_32LE] = SND_PCM_FORMAT_S24_LE,
 250         [PA_SAMPLE_S24_32BE] = SND_PCM_FORMAT_S24_BE,
 251     };
 252
 253     static const pa_sample_format_t try_order[] = {
 254         PA_SAMPLE_FLOAT32NE,
 255         PA_SAMPLE_FLOAT32RE,
 256         PA_SAMPLE_S32NE,
 257         PA_SAMPLE_S32RE,
 258         PA_SAMPLE_S24_32NE,
 259         PA_SAMPLE_S24_32RE,
 260         PA_SAMPLE_S24NE,
 261         PA_SAMPLE_S24RE,
 262         PA_SAMPLE_S16NE,
 263         PA_SAMPLE_S16RE,
 264         PA_SAMPLE_ALAW,
 265         PA_SAMPLE_ULAW,
 266         PA_SAMPLE_U8,
 267         PA_SAMPLE_INVALID
 268     };
 269
 270     int i, ret;
 271
 272     pa_assert(pcm_handle);
 273     pa_assert(f);
 274
 275     if ((ret = snd_pcm_hw_params_set_format(pcm_handle, hwparams, format_trans[*f])) >= 0)
 276         return ret;
 277
 278     if (*f == PA_SAMPLE_FLOAT32BE)
 279         *f = PA_SAMPLE_FLOAT32LE;
 280     else if (*f == PA_SAMPLE_FLOAT32LE)
 281         *f = PA_SAMPLE_FLOAT32BE;
 282     else if (*f == PA_SAMPLE_S24BE)
 283         *f = PA_SAMPLE_S24LE;
 284     else if (*f == PA_SAMPLE_S24LE)
 285         *f = PA_SAMPLE_S24BE;
 286     else if (*f == PA_SAMPLE_S24_32BE)
 287         *f = PA_SAMPLE_S24_32LE;
 288     else if (*f == PA_SAMPLE_S24_32LE)
 289         *f = PA_SAMPLE_S24_32BE;
 290     else if (*f == PA_SAMPLE_S16BE)
 291         *f = PA_SAMPLE_S16LE;
 292     else if (*f == PA_SAMPLE_S16LE)
 293         *f = PA_SAMPLE_S16BE;
 294     else if (*f == PA_SAMPLE_S32BE)
 295         *f = PA_SAMPLE_S32LE;
 296     else if (*f == PA_SAMPLE_S32LE)
 297         *f = PA_SAMPLE_S32BE;
 298     else
 299         goto try_auto;
 300
 301     if ((ret = snd_pcm_hw_params_set_format(pcm_handle, hwparams, format_trans[*f])) >= 0)
 302         return ret;
 303
 304 try_auto:
 305
 306     for (i = 0; try_order[i] != PA_SAMPLE_INVALID; i++) {
 307         *f = try_order[i];
 308
 309         if ((ret = snd_pcm_hw_params_set_format(pcm_handle, hwparams, format_trans[*f])) >= 0)
 310             return ret;
 311     }
 312
 313     return -1;
 314 }
 315
 316 /* Set the hardware parameters of the given ALSA device. Returns the
 317  * selected fragment settings in *period and *period_size */
 318 int pa_alsa_set_hw_params(
 319         snd_pcm_t *pcm_handle,
 320         pa_sample_spec *ss,
 321         uint32_t *periods,
 322         snd_pcm_uframes_t *period_size,
 323         snd_pcm_uframes_t tsched_size,
 324         pa_bool_t *use_mmap,
 325         pa_bool_t *use_tsched,
 326         pa_bool_t require_exact_channel_number) {
 327
 328     int ret = -1;
 329     snd_pcm_uframes_t _period_size = period_size ? *period_size : 0;
 330     unsigned int _periods = periods ? *periods : 0;
 331     snd_pcm_uframes_t buffer_size;
 332     unsigned int r = ss->rate;
 333     unsigned int c = ss->channels;
 334     pa_sample_format_t f = ss->format;
 335     snd_pcm_hw_params_t *hwparams;
 336     pa_bool_t _use_mmap = use_mmap && *use_mmap;
 337     pa_bool_t _use_tsched = use_tsched && *use_tsched;
 338     int dir;
 339
 340     pa_assert(pcm_handle);
 341     pa_assert(ss);
 342
 343     snd_pcm_hw_params_alloca(&hwparams);
 344
 345     if ((ret = snd_pcm_hw_params_any(pcm_handle, hwparams)) < 0)
 346         goto finish;
 347
 348     if ((ret = snd_pcm_hw_params_set_rate_resample(pcm_handle, hwparams, 0)) < 0)
 349         goto finish;
 350
 351     if (_use_mmap) {
 352
 353         if (snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0) {
 354
 355             /* mmap() didn't work, fall back to interleaved */
 356
 357             if ((ret = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
 358                 goto finish;
 359
 360             _use_mmap = FALSE;
 361         }
 362
 363     } else if ((ret = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
 364         goto finish;
 365
 366     if (!_use_mmap)
 367         _use_tsched = FALSE;
 368
 369     if ((ret = set_format(pcm_handle, hwparams, &f)) < 0)
 370         goto finish;
 371
 372     if ((ret = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, &r, NULL)) < 0)
 373         goto finish;
 374
 375     if (require_exact_channel_number) {
 376         if ((ret = snd_pcm_hw_params_set_channels(pcm_handle, hwparams, c)) < 0)
 377             goto finish;
 378     } else {
 379         if ((ret = snd_pcm_hw_params_set_channels_near(pcm_handle, hwparams, &c)) < 0)
 380             goto finish;
 381     }
 382
 383     if ((ret = snd_pcm_hw_params_set_periods_integer(pcm_handle, hwparams)) < 0)
 384         goto finish;
 385
 386     if (_period_size && tsched_size && _periods) {
 387         /* Adjust the buffer sizes, if we didn't get the rate we were asking for */
 388         _period_size = (snd_pcm_uframes_t) (((uint64_t) _period_size * r) / ss->rate);
 389         tsched_size = (snd_pcm_uframes_t) (((uint64_t) tsched_size * r) / ss->rate);
 390
 391         if (_use_tsched) {
 392             _period_size = tsched_size;
 393             _periods = 1;
 394
 395             pa_assert_se(snd_pcm_hw_params_get_buffer_size_max(hwparams, &buffer_size) == 0);
 396             pa_log_debug("Maximum hw buffer size is %u ms", (unsigned) buffer_size * 1000 / r);
 397         }
 398
 399         buffer_size = _periods * _period_size;
 400
 401         if (_periods > 0) {
 402
 403             /* First we pass 0 as direction to get exactly what we asked
 404              * for. That this is necessary is presumably a bug in ALSA */
 405
 406             dir = 0;
 407             if ((ret = snd_pcm_hw_params_set_periods_near(pcm_handle, hwparams, &_periods, &dir)) < 0) {
 408                 dir = 1;
 409                 if ((ret = snd_pcm_hw_params_set_periods_near(pcm_handle, hwparams, &_periods, &dir)) < 0) {
 410                     dir = -1;
 411                     if ((ret = snd_pcm_hw_params_set_periods_near(pcm_handle, hwparams, &_periods, &dir)) < 0)
 412                         goto finish;
 413                 }
 414             }
 415         }
 416
 417         if (_period_size > 0)
 418             if ((ret = snd_pcm_hw_params_set_buffer_size_near(pcm_handle, hwparams, &buffer_size)) < 0)
 419                 goto finish;
 420     }
 421
 422     if  ((ret = snd_pcm_hw_params(pcm_handle, hwparams)) < 0)
 423         goto finish;
 424
 425     if (ss->rate != r)
 426         pa_log_info("Device %s doesn't support %u Hz, changed to %u Hz.", snd_pcm_name(pcm_handle), ss->rate, r);
 427
 428     if (ss->channels != c)
 429         pa_log_info("Device %s doesn't support %u channels, changed to %u.", snd_pcm_name(pcm_handle), ss->channels, c);
 430
 431     if (ss->format != f)
 432         pa_log_info("Device %s doesn't support sample format %s, changed to %s.", snd_pcm_name(pcm_handle), pa_sample_format_to_string(ss->format), pa_sample_format_to_string(f));
 433
 434     if ((ret = snd_pcm_prepare(pcm_handle)) < 0)
 435         goto finish;
 436
 437     if ((ret = snd_pcm_hw_params_get_period_size(hwparams, &_period_size, &dir)) < 0 ||
 438         (ret = snd_pcm_hw_params_get_periods(hwparams, &_periods, &dir)) < 0)
 439         goto finish;
 440
 441     /* If the sample rate deviates too much, we need to resample */
 442     if (r < ss->rate*.95 || r > ss->rate*1.05)
 443         ss->rate = r;
 444     ss->channels = (uint8_t) c;
 445     ss->format = f;
 446
 447     pa_assert(_periods > 0);
 448     pa_assert(_period_size > 0);
 449
 450     if (periods)
 451         *periods = _periods;
 452
 453     if (period_size)
 454         *period_size = _period_size;
 455
 456     if (use_mmap)
 457         *use_mmap = _use_mmap;
 458
 459     if (use_tsched)
 460         *use_tsched = _use_tsched;
 461
 462     ret = 0;
 463
 464     snd_pcm_nonblock(pcm_handle, 1);
 465
 466 finish:
 467
 468     return ret;
 469 }
 470
 471 int pa_alsa_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min) {
 472     snd_pcm_sw_params_t *swparams;
 473     snd_pcm_uframes_t boundary;
 474     int err;
 475
 476     pa_assert(pcm);
 477
 478     snd_pcm_sw_params_alloca(&swparams);
 479
 480     if ((err = snd_pcm_sw_params_current(pcm, swparams) < 0)) {
 481         pa_log_warn("Unable to determine current swparams: %s\n", snd_strerror(err));
 482         return err;
 483     }
 484
 485     if ((err = snd_pcm_sw_params_set_period_event(pcm, swparams, 0)) < 0) {
 486         pa_log_warn("Unable to disable period event: %s\n", snd_strerror(err));
 487         return err;
 488     }
 489
 490     if ((err = snd_pcm_sw_params_set_tstamp_mode(pcm, swparams, SND_PCM_TSTAMP_ENABLE)) < 0) {
 491         pa_log_warn("Unable to enable time stamping: %s\n", snd_strerror(err));
 492         return err;
 493     }
 494
 495     if ((err = snd_pcm_sw_params_get_boundary(swparams, &boundary)) < 0) {
 496         pa_log_warn("Unable to get boundary: %s\n", snd_strerror(err));
 497         return err;
 498     }
 499
 500     if ((err = snd_pcm_sw_params_set_stop_threshold(pcm, swparams, boundary)) < 0) {
 501         pa_log_warn("Unable to set stop threshold: %s\n", snd_strerror(err));
 502         return err;
 503     }
 504
 505     if ((err = snd_pcm_sw_params_set_start_threshold(pcm, swparams, (snd_pcm_uframes_t) -1)) < 0) {
 506         pa_log_warn("Unable to set start threshold: %s\n", snd_strerror(err));
 507         return err;
 508     }
 509
 510     if ((err = snd_pcm_sw_params_set_avail_min(pcm, swparams, avail_min)) < 0) {
 511         pa_log_error("snd_pcm_sw_params_set_avail_min() failed: %s", snd_strerror(err));
 512         return err;
 513     }
 514
 515     if ((err = snd_pcm_sw_params(pcm, swparams)) < 0) {
 516         pa_log_warn("Unable to set sw params: %s\n", snd_strerror(err));
 517         return err;
 518     }
 519
 520     return 0;
 521 }
 522
 523 static const struct pa_alsa_profile_info device_table[] = {
 524     {{ 1, { PA_CHANNEL_POSITION_MONO }},
 525      "hw",
 526      N_("Analog Mono"),
 527      "analog-mono",
 528      1 },
 529
 530     {{ 2, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT }},
 531      "front",
 532      N_("Analog Stereo"),
 533      "analog-stereo",
 534      10 },
 535
 536     {{ 2, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT }},
 537      "iec958",
 538      N_("Digital Stereo (IEC958)"),
 539      "iec958-stereo",
 540      5 },
 541
 542     {{ 2, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT }},
 543      "hdmi",
 544      N_("Digital Stereo (HDMI)"),
 545      "hdmi-stereo",
 546      4 },
 547
 548     {{ 4, { PA_CHANNEL_POSITION_FRONT_LEFT, PA_CHANNEL_POSITION_FRONT_RIGHT,
 549             PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT }},
 550      "surround40",
 551      N_("Analog Surround 4.0"),
 552      "analog-surround-40",
 553      7 },
 554
 555     {{ 4, { PA_CHANNEL_POSITION_FRONT_LEFT, PA_CHANNEL_POSITION_FRONT_RIGHT,
 556             PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT }},
 557      "a52",
 558      N_("Digital Surround 4.0 (IEC958/AC3)"),
 559      "iec958-ac3-surround-40",
 560      2 },
 561
 562     {{ 5, { PA_CHANNEL_POSITION_FRONT_LEFT, PA_CHANNEL_POSITION_FRONT_RIGHT,
 563             PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT,
 564             PA_CHANNEL_POSITION_LFE }},
 565      "surround41",
 566      N_("Analog Surround 4.1"),
 567      "analog-surround-41",
 568      7 },
 569
 570     {{ 5, { PA_CHANNEL_POSITION_FRONT_LEFT, PA_CHANNEL_POSITION_FRONT_RIGHT,
 571             PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT,
 572             PA_CHANNEL_POSITION_CENTER }},
 573      "surround50",
 574      N_("Analog Surround 5.0"),
 575      "analog-surround-50",
 576      7 },
 577
 578     {{ 6, { PA_CHANNEL_POSITION_FRONT_LEFT, PA_CHANNEL_POSITION_FRONT_RIGHT,
 579             PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT,
 580             PA_CHANNEL_POSITION_CENTER, PA_CHANNEL_POSITION_LFE }},
 581      "surround51",
 582      N_("Analog Surround 5.1"),
 583      "analog-surround-51",
 584      8 },
 585
 586     {{ 6, { PA_CHANNEL_POSITION_FRONT_LEFT, PA_CHANNEL_POSITION_FRONT_CENTER,
 587             PA_CHANNEL_POSITION_FRONT_RIGHT, PA_CHANNEL_POSITION_REAR_LEFT,
 588             PA_CHANNEL_POSITION_REAR_RIGHT, PA_CHANNEL_POSITION_LFE}},
 589      "a52",
 590      N_("Digital Surround 5.1 (IEC958/AC3)"),
 591      "iec958-ac3-surround-51",
 592      3 },
 593
 594     {{ 8, { PA_CHANNEL_POSITION_FRONT_LEFT, PA_CHANNEL_POSITION_FRONT_RIGHT,
 595             PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT,
 596             PA_CHANNEL_POSITION_CENTER, PA_CHANNEL_POSITION_LFE,
 597             PA_CHANNEL_POSITION_SIDE_LEFT, PA_CHANNEL_POSITION_SIDE_RIGHT }},
 598      "surround71",
 599      N_("Analog Surround 7.1"),
 600      "analog-surround-71",
 601      7 },
 602
 603     {{ 0, { 0 }}, NULL, NULL, NULL, 0 }
 604 };
 605
 606 snd_pcm_t *pa_alsa_open_by_device_id_auto(
 607         const char *dev_id,
 608         char **dev,
 609         pa_sample_spec *ss,
 610         pa_channel_map* map,
 611         int mode,
 612         uint32_t *nfrags,
 613         snd_pcm_uframes_t *period_size,
 614         snd_pcm_uframes_t tsched_size,
 615         pa_bool_t *use_mmap,
 616         pa_bool_t *use_tsched,
 617         const pa_alsa_profile_info **profile) {
 618
 619     int i;
 620     int direction = 1;
 621     char *d;
 622     snd_pcm_t *pcm_handle;
 623
 624     pa_assert(dev_id);
 625     pa_assert(dev);
 626     pa_assert(ss);
 627     pa_assert(map);
 628     pa_assert(nfrags);
 629     pa_assert(period_size);
 630
 631     /* First we try to find a device string with a superset of the
 632      * requested channel map and open it without the plug: prefix. We
 633      * iterate through our device table from top to bottom and take
 634      * the first that matches. If we didn't find a working device that
 635      * way, we iterate backwards, and check all devices that do not
 636      * provide a superset of the requested channel map.*/
 637
 638     i = 0;
 639     for (;;) {
 640
 641         if ((direction > 0) == pa_channel_map_superset(&device_table[i].map, map)) {
 642             pa_sample_spec try_ss;
 643
 644             pa_log_debug("Checking for %s (%s)", device_table[i].name, device_table[i].alsa_name);
 645
 646             d = pa_sprintf_malloc("%s:%s", device_table[i].alsa_name, dev_id);
 647
 648             try_ss.channels = device_table[i].map.channels;
 649             try_ss.rate = ss->rate;
 650             try_ss.format = ss->format;
 651
 652             pcm_handle = pa_alsa_open_by_device_string(
 653                     d,
 654                     dev,
 655                     &try_ss,
 656                     map,
 657                     mode,
 658                     nfrags,
 659                     period_size,
 660                     tsched_size,
 661                     use_mmap,
 662                     use_tsched,
 663                     TRUE);
 664
 665             pa_xfree(d);
 666
 667             if (pcm_handle) {
 668
 669                 *ss = try_ss;
 670                 *map = device_table[i].map;
 671                 pa_assert(map->channels == ss->channels);
 672
 673                 if (profile)
 674                     *profile = &device_table[i];
 675
 676                 return pcm_handle;
 677             }
 678         }
 679
 680         if (direction > 0) {
 681             if (!device_table[i+1].alsa_name) {
 682                 /* OK, so we are at the end of our list. Let's turn
 683                  * back. */
 684                 direction = -1;
 685             } else {
 686                 /* We are not at the end of the list, so let's simply
 687                  * try the next entry */
 688                 i++;
 689             }
 690         }
 691
 692         if (direction < 0) {
 693
 694             if (device_table[i+1].alsa_name &&
 695                 device_table[i].map.channels == device_table[i+1].map.channels) {
 696
 697                 /* OK, the next entry has the same number of channels,
 698                  * let's try it */
 699                 i++;
 700
 701             } else {
 702                 /* Hmm, so the next entry does not have the same
 703                  * number of channels, so let's go backwards until we
 704                  * find the next entry with a differnt number of
 705                  * channels */
 706
 707                 for (i--; i >= 0; i--)
 708                     if (device_table[i].map.channels != device_table[i+1].map.channels)
 709                         break;
 710
 711                 /* Hmm, there is no entry with a different number of
 712                  * entries, then we're done */
 713                 if (i < 0)
 714                     break;
 715
 716                 /* OK, now lets find go back as long as we have the same number of channels */
 717                 for (; i > 0; i--)
 718                     if (device_table[i].map.channels != device_table[i-1].map.channels)
 719                         break;
 720             }
 721         }
 722     }
 723
 724     /* OK, we didn't find any good device, so let's try the raw plughw: stuff */
 725
 726     d = pa_sprintf_malloc("hw:%s", dev_id);
 727     pa_log_debug("Trying %s as last resort...", d);
 728     pcm_handle = pa_alsa_open_by_device_string(d, dev, ss, map, mode, nfrags, period_size, tsched_size, use_mmap, use_tsched, FALSE);
 729     pa_xfree(d);
 730
 731     if (pcm_handle && profile)
 732         *profile = NULL;
 733
 734     return pcm_handle;
 735 }
 736
 737 snd_pcm_t *pa_alsa_open_by_device_id_profile(
 738         const char *dev_id,
 739         char **dev,
 740         pa_sample_spec *ss,
 741         pa_channel_map* map,
 742         int mode,
 743         uint32_t *nfrags,
 744         snd_pcm_uframes_t *period_size,
 745         snd_pcm_uframes_t tsched_size,
 746         pa_bool_t *use_mmap,
 747         pa_bool_t *use_tsched,
 748         const pa_alsa_profile_info *profile) {
 749
 750     char *d;
 751     snd_pcm_t *pcm_handle;
 752     pa_sample_spec try_ss;
 753
 754     pa_assert(dev_id);
 755     pa_assert(dev);
 756     pa_assert(ss);
 757     pa_assert(map);
 758     pa_assert(nfrags);
 759     pa_assert(period_size);
 760     pa_assert(profile);
 761
 762     d = pa_sprintf_malloc("%s:%s", profile->alsa_name, dev_id);
 763
 764     try_ss.channels = profile->map.channels;
 765     try_ss.rate = ss->rate;
 766     try_ss.format = ss->format;
 767
 768     pcm_handle = pa_alsa_open_by_device_string(
 769             d,
 770             dev,
 771             &try_ss,
 772             map,
 773             mode,
 774             nfrags,
 775             period_size,
 776             tsched_size,
 777             use_mmap,
 778             use_tsched,
 779             TRUE);
 780
 781     pa_xfree(d);
 782
 783     if (!pcm_handle)
 784         return NULL;
 785
 786     *ss = try_ss;
 787     *map = profile->map;
 788     pa_assert(map->channels == ss->channels);
 789
 790     return pcm_handle;
 791 }
 792
 793 snd_pcm_t *pa_alsa_open_by_device_string(
 794         const char *device,
 795         char **dev,
 796         pa_sample_spec *ss,
 797         pa_channel_map* map,
 798         int mode,
 799         uint32_t *nfrags,
 800         snd_pcm_uframes_t *period_size,
 801         snd_pcm_uframes_t tsched_size,
 802         pa_bool_t *use_mmap,
 803         pa_bool_t *use_tsched,
 804         pa_bool_t require_exact_channel_number) {
 805
 806     int err;
 807     char *d;
 808     snd_pcm_t *pcm_handle;
 809     pa_bool_t reformat = FALSE;
 810
 811     pa_assert(device);
 812     pa_assert(ss);
 813     pa_assert(map);
 814
 815     d = pa_xstrdup(device);
 816
 817     for (;;) {
 818         pa_log_debug("Trying %s %s SND_PCM_NO_AUTO_FORMAT ...", d, reformat ? "without" : "with");
 819
 820         /* We don't pass SND_PCM_NONBLOCK here, since alsa-lib <=
 821          * 1.0.17a would then ignore the SND_PCM_NO_xxx flags. Instead
 822          * we enable nonblock mode afterwards via
 823          * snd_pcm_nonblock(). Also see
 824          * http://mailman.alsa-project.org/pipermail/alsa-devel/2008-August/010258.html */
 825
 826         if ((err = snd_pcm_open(&pcm_handle, d, mode,
 827                                 /*SND_PCM_NONBLOCK|*/
 828                                 SND_PCM_NO_AUTO_RESAMPLE|
 829                                 SND_PCM_NO_AUTO_CHANNELS|
 830                                 (reformat ? 0 : SND_PCM_NO_AUTO_FORMAT))) < 0) {
 831             pa_log_info("Error opening PCM device %s: %s", d, snd_strerror(err));
 832             goto fail;
 833         }
 834
 835         if ((err = pa_alsa_set_hw_params(pcm_handle, ss, nfrags, period_size, tsched_size, use_mmap, use_tsched, require_exact_channel_number)) < 0) {
 836
 837             if (!reformat) {
 838                 reformat = TRUE;
 839
 840                 snd_pcm_close(pcm_handle);
 841                 continue;
 842             }
 843
 844             /* Hmm, some hw is very exotic, so we retry with plug, if without it didn't work */
 845
 846             if (!pa_startswith(d, "plug:") && !pa_startswith(d, "plughw:")) {
 847                 char *t;
 848
 849                 t = pa_sprintf_malloc("plug:%s", d);
 850                 pa_xfree(d);
 851                 d = t;
 852
 853                 reformat = FALSE;
 854
 855                 snd_pcm_close(pcm_handle);
 856                 continue;
 857             }
 858
 859             pa_log_info("Failed to set hardware parameters on %s: %s", d, snd_strerror(err));
 860             snd_pcm_close(pcm_handle);
 861
 862             goto fail;
 863         }
 864
 865         if (dev)
 866             *dev = d;
 867         else
 868             pa_xfree(d);
 869
 870         if (ss->channels != map->channels)
 871             pa_channel_map_init_extend(map, ss->channels, PA_CHANNEL_MAP_ALSA);
 872
 873         return pcm_handle;
 874     }
 875
 876 fail:
 877     pa_xfree(d);
 878
 879     return NULL;
 880 }
 881
 882 int pa_alsa_probe_profiles(
 883         const char *dev_id,
 884         const pa_sample_spec *ss,
 885         void (*cb)(const pa_alsa_profile_info *sink, const pa_alsa_profile_info *source, void *userdata),
 886         void *userdata) {
 887
 888     const pa_alsa_profile_info *i;
 889
 890     pa_assert(dev_id);
 891     pa_assert(ss);
 892     pa_assert(cb);
 893
 894     /* We try each combination of playback/capture. We also try to
 895      * open only for capture resp. only for sink. Don't get confused
 896      * by the trailing entry in device_table we use for this! */
 897
 898     for (i = device_table; i < device_table + PA_ELEMENTSOF(device_table); i++) {
 899         const pa_alsa_profile_info *j;
 900         snd_pcm_t *pcm_i = NULL;
 901
 902         if (i->alsa_name) {
 903             char *id;
 904             pa_sample_spec try_ss;
 905             pa_channel_map try_map;
 906
 907             pa_log_debug("Checking for playback on %s (%s)", i->name, i->alsa_name);
 908             id = pa_sprintf_malloc("%s:%s", i->alsa_name, dev_id);
 909
 910             try_ss = *ss;
 911             try_ss.channels = i->map.channels;
 912             try_map = i->map;
 913
 914             pcm_i = pa_alsa_open_by_device_string(
 915                     id, NULL,
 916                     &try_ss, &try_map,
 917                     SND_PCM_STREAM_PLAYBACK,
 918                     NULL, NULL, 0, NULL, NULL,
 919                     TRUE);
 920
 921             pa_xfree(id);
 922
 923             if (!pcm_i)
 924                 continue;
 925         }
 926
 927         for (j = device_table; j < device_table + PA_ELEMENTSOF(device_table); j++) {
 928             snd_pcm_t *pcm_j = NULL;
 929
 930             if (j->alsa_name) {
 931                 char *jd;
 932                 pa_sample_spec try_ss;
 933                 pa_channel_map try_map;
 934
 935                 pa_log_debug("Checking for capture on %s (%s)", j->name, j->alsa_name);
 936                 jd = pa_sprintf_malloc("%s:%s", j->alsa_name, dev_id);
 937
 938                 try_ss = *ss;
 939                 try_ss.channels = j->map.channels;
 940                 try_map = j->map;
 941
 942                 pcm_j = pa_alsa_open_by_device_string(
 943                         jd, NULL,
 944                         &try_ss, &try_map,
 945                         SND_PCM_STREAM_CAPTURE,
 946                         NULL, NULL, 0, NULL, NULL,
 947                         TRUE);
 948
 949                 pa_xfree(jd);
 950
 951                 if (!pcm_j)
 952                     continue;
 953             }
 954
 955             if (pcm_j)
 956                 snd_pcm_close(pcm_j);
 957
 958             if (i->alsa_name || j->alsa_name)
 959                 cb(i->alsa_name ? i : NULL,
 960                    j->alsa_name ? j : NULL, userdata);
 961         }
 962
 963         if (pcm_i)
 964             snd_pcm_close(pcm_i);
 965     }
 966
 967     return TRUE;
 968 }
 969
 970 int pa_alsa_prepare_mixer(snd_mixer_t *mixer, const char *dev) {
 971     int err;
 972
 973     pa_assert(mixer);
 974     pa_assert(dev);
 975
 976     if ((err = snd_mixer_attach(mixer, dev)) < 0) {
 977         pa_log_info("Unable to attach to mixer %s: %s", dev, snd_strerror(err));
 978         return -1;
 979     }
 980
 981     if ((err = snd_mixer_selem_register(mixer, NULL, NULL)) < 0) {
 982         pa_log_warn("Unable to register mixer: %s", snd_strerror(err));
 983         return -1;
 984     }
 985
 986     if ((err = snd_mixer_load(mixer)) < 0) {
 987         pa_log_warn("Unable to load mixer: %s", snd_strerror(err));
 988         return -1;
 989     }
 990
 991     pa_log_info("Successfully attached to mixer '%s'", dev);
 992
 993     return 0;
 994 }
 995
 996 static pa_bool_t elem_has_volume(snd_mixer_elem_t *elem, pa_bool_t playback) {
 997     pa_assert(elem);
 998
 999     if (playback && snd_mixer_selem_has_playback_volume(elem))
1000         return TRUE;
1001
1002     if (!playback && snd_mixer_selem_has_capture_volume(elem))
1003         return TRUE;
1004
1005     return FALSE;
1006 }
1007
1008 static pa_bool_t elem_has_switch(snd_mixer_elem_t *elem, pa_bool_t playback) {
1009     pa_assert(elem);
1010
1011     if (playback && snd_mixer_selem_has_playback_switch(elem))
1012         return TRUE;
1013
1014     if (!playback && snd_mixer_selem_has_capture_switch(elem))
1015         return TRUE;
1016
1017     return FALSE;
1018 }
1019
1020 snd_mixer_elem_t *pa_alsa_find_elem(snd_mixer_t *mixer, const char *name, const char *fallback, pa_bool_t playback) {
1021     snd_mixer_elem_t *elem = NULL, *fallback_elem = NULL;
1022     snd_mixer_selem_id_t *sid = NULL;
1023
1024     snd_mixer_selem_id_alloca(&sid);
1025
1026     pa_assert(mixer);
1027     pa_assert(name);
1028
1029     snd_mixer_selem_id_set_name(sid, name);
1030     snd_mixer_selem_id_set_index(sid, 0);
1031
1032     if ((elem = snd_mixer_find_selem(mixer, sid))) {
1033
1034         if (elem_has_volume(elem, playback) &&
1035             elem_has_switch(elem, playback))
1036             goto success;
1037
1038         if (!elem_has_volume(elem, playback) &&
1039             !elem_has_switch(elem, playback))
1040             elem = NULL;
1041     }
1042
1043     pa_log_info("Cannot find mixer control \"%s\" or mixer control is no combination of switch/volume.", snd_mixer_selem_id_get_name(sid));
1044
1045     if (fallback) {
1046         snd_mixer_selem_id_set_name(sid, fallback);
1047         snd_mixer_selem_id_set_index(sid, 0);
1048
1049         if ((fallback_elem = snd_mixer_find_selem(mixer, sid))) {
1050
1051             if (elem_has_volume(fallback_elem, playback) &&
1052                 elem_has_switch(fallback_elem, playback)) {
1053                 elem = fallback_elem;
1054                 goto success;
1055             }
1056
1057             if (!elem_has_volume(fallback_elem, playback) &&
1058                 !elem_has_switch(fallback_elem, playback))
1059                 fallback_elem = NULL;
1060         }
1061
1062         pa_log_warn("Cannot find fallback mixer control \"%s\" or mixer control is no combination of switch/volume.", snd_mixer_selem_id_get_name(sid));
1063     }
1064
1065     if (elem && fallback_elem) {
1066
1067         /* Hmm, so we have both elements, but neither has both mute
1068          * and volume. Let's prefer the one with the volume */
1069
1070         if (elem_has_volume(elem, playback))
1071             goto success;
1072
1073         if (elem_has_volume(fallback_elem, playback)) {
1074             elem = fallback_elem;
1075             goto success;
1076         }
1077     }
1078
1079     if (!elem && fallback_elem)
1080         elem = fallback_elem;
1081
1082 success:
1083
1084     if (elem)
1085         pa_log_info("Using mixer control \"%s\".", snd_mixer_selem_id_get_name(sid));
1086
1087     return elem;
1088 }
1089
1090 int pa_alsa_find_mixer_and_elem(
1091         snd_pcm_t *pcm,
1092         snd_mixer_t **_m,
1093         snd_mixer_elem_t **_e) {
1094
1095     int err;
1096     snd_mixer_t *m;
1097     snd_mixer_elem_t *e;
1098     pa_bool_t found = FALSE;
1099     const char *dev;
1100
1101     pa_assert(pcm);
1102     pa_assert(_m);
1103     pa_assert(_e);
1104
1105     if ((err = snd_mixer_open(&m, 0)) < 0) {
1106         pa_log("Error opening mixer: %s", snd_strerror(err));
1107         return -1;
1108     }
1109
1110     /* First, try by name */
1111     if ((dev = snd_pcm_name(pcm)))
1112         if (pa_alsa_prepare_mixer(m, dev) >= 0)
1113             found = TRUE;
1114
1115     /* Then, try by card index */
1116     if (!found) {
1117         snd_pcm_info_t* info;
1118         snd_pcm_info_alloca(&info);
1119
1120         if (snd_pcm_info(pcm, info) >= 0) {
1121             char *md;
1122             int card_idx;
1123
1124             if ((card_idx = snd_pcm_info_get_card(info)) >= 0) {
1125
1126                 md = pa_sprintf_malloc("hw:%i", card_idx);
1127
1128                 if (!dev || !pa_streq(dev, md))
1129                     if (pa_alsa_prepare_mixer(m, md) >= 0)
1130                         found = TRUE;
1131
1132                 pa_xfree(md);
1133             }
1134         }
1135     }
1136
1137     if (!found) {
1138         snd_mixer_close(m);
1139         return -1;
1140     }
1141
1142     switch (snd_pcm_stream(pcm)) {
1143
1144         case SND_PCM_STREAM_PLAYBACK:
1145             e = pa_alsa_find_elem(m, "Master", "PCM", TRUE);
1146             break;
1147
1148         case SND_PCM_STREAM_CAPTURE:
1149             e = pa_alsa_find_elem(m, "Capture", "Mic", FALSE);
1150             break;
1151
1152         default:
1153             pa_assert_not_reached();
1154     }
1155
1156     if (!e) {
1157         snd_mixer_close(m);
1158         return -1;
1159     }
1160
1161     pa_assert(e && m);
1162
1163     *_m = m;
1164     *_e = e;
1165
1166     return 0;
1167 }
1168
1169 static const snd_mixer_selem_channel_id_t alsa_channel_ids[PA_CHANNEL_POSITION_MAX] = {
1170     [PA_CHANNEL_POSITION_MONO] = SND_MIXER_SCHN_MONO, /* The ALSA name is just an alias! */
1171
1172     [PA_CHANNEL_POSITION_FRONT_CENTER] = SND_MIXER_SCHN_FRONT_CENTER,
1173     [PA_CHANNEL_POSITION_FRONT_LEFT] = SND_MIXER_SCHN_FRONT_LEFT,
1174     [PA_CHANNEL_POSITION_FRONT_RIGHT] = SND_MIXER_SCHN_FRONT_RIGHT,
1175
1176     [PA_CHANNEL_POSITION_REAR_CENTER] = SND_MIXER_SCHN_REAR_CENTER,
1177     [PA_CHANNEL_POSITION_REAR_LEFT] = SND_MIXER_SCHN_REAR_LEFT,
1178     [PA_CHANNEL_POSITION_REAR_RIGHT] = SND_MIXER_SCHN_REAR_RIGHT,
1179
1180     [PA_CHANNEL_POSITION_LFE] = SND_MIXER_SCHN_WOOFER,
1181
1182     [PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER] = SND_MIXER_SCHN_UNKNOWN,
1183     [PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER] = SND_MIXER_SCHN_UNKNOWN,
1184
1185     [PA_CHANNEL_POSITION_SIDE_LEFT] = SND_MIXER_SCHN_SIDE_LEFT,
1186     [PA_CHANNEL_POSITION_SIDE_RIGHT] = SND_MIXER_SCHN_SIDE_RIGHT,
1187
1188     [PA_CHANNEL_POSITION_AUX0] = SND_MIXER_SCHN_UNKNOWN,
1189     [PA_CHANNEL_POSITION_AUX1] = SND_MIXER_SCHN_UNKNOWN,
1190     [PA_CHANNEL_POSITION_AUX2] = SND_MIXER_SCHN_UNKNOWN,
1191     [PA_CHANNEL_POSITION_AUX3] = SND_MIXER_SCHN_UNKNOWN,
1192     [PA_CHANNEL_POSITION_AUX4] = SND_MIXER_SCHN_UNKNOWN,
1193     [PA_CHANNEL_POSITION_AUX5] = SND_MIXER_SCHN_UNKNOWN,
1194     [PA_CHANNEL_POSITION_AUX6] = SND_MIXER_SCHN_UNKNOWN,
1195     [PA_CHANNEL_POSITION_AUX7] = SND_MIXER_SCHN_UNKNOWN,
1196     [PA_CHANNEL_POSITION_AUX8] = SND_MIXER_SCHN_UNKNOWN,
1197     [PA_CHANNEL_POSITION_AUX9] =  SND_MIXER_SCHN_UNKNOWN,
1198     [PA_CHANNEL_POSITION_AUX10] = SND_MIXER_SCHN_UNKNOWN,
1199     [PA_CHANNEL_POSITION_AUX11] = SND_MIXER_SCHN_UNKNOWN,
1200     [PA_CHANNEL_POSITION_AUX12] = SND_MIXER_SCHN_UNKNOWN,
1201     [PA_CHANNEL_POSITION_AUX13] = SND_MIXER_SCHN_UNKNOWN,
1202     [PA_CHANNEL_POSITION_AUX14] = SND_MIXER_SCHN_UNKNOWN,
1203     [PA_CHANNEL_POSITION_AUX15] = SND_MIXER_SCHN_UNKNOWN,
1204     [PA_CHANNEL_POSITION_AUX16] = SND_MIXER_SCHN_UNKNOWN,
1205     [PA_CHANNEL_POSITION_AUX17] = SND_MIXER_SCHN_UNKNOWN,
1206     [PA_CHANNEL_POSITION_AUX18] = SND_MIXER_SCHN_UNKNOWN,
1207     [PA_CHANNEL_POSITION_AUX19] = SND_MIXER_SCHN_UNKNOWN,
1208     [PA_CHANNEL_POSITION_AUX20] = SND_MIXER_SCHN_UNKNOWN,
1209     [PA_CHANNEL_POSITION_AUX21] = SND_MIXER_SCHN_UNKNOWN,
1210     [PA_CHANNEL_POSITION_AUX22] = SND_MIXER_SCHN_UNKNOWN,
1211     [PA_CHANNEL_POSITION_AUX23] = SND_MIXER_SCHN_UNKNOWN,
1212     [PA_CHANNEL_POSITION_AUX24] = SND_MIXER_SCHN_UNKNOWN,
1213     [PA_CHANNEL_POSITION_AUX25] = SND_MIXER_SCHN_UNKNOWN,
1214     [PA_CHANNEL_POSITION_AUX26] = SND_MIXER_SCHN_UNKNOWN,
1215     [PA_CHANNEL_POSITION_AUX27] = SND_MIXER_SCHN_UNKNOWN,
1216     [PA_CHANNEL_POSITION_AUX28] = SND_MIXER_SCHN_UNKNOWN,
1217     [PA_CHANNEL_POSITION_AUX29] = SND_MIXER_SCHN_UNKNOWN,
1218     [PA_CHANNEL_POSITION_AUX30] = SND_MIXER_SCHN_UNKNOWN,
1219     [PA_CHANNEL_POSITION_AUX31] = SND_MIXER_SCHN_UNKNOWN,
1220
1221     [PA_CHANNEL_POSITION_TOP_CENTER] = SND_MIXER_SCHN_UNKNOWN,
1222
1223     [PA_CHANNEL_POSITION_TOP_FRONT_CENTER] = SND_MIXER_SCHN_UNKNOWN,
1224     [PA_CHANNEL_POSITION_TOP_FRONT_LEFT] = SND_MIXER_SCHN_UNKNOWN,
1225     [PA_CHANNEL_POSITION_TOP_FRONT_RIGHT] = SND_MIXER_SCHN_UNKNOWN,
1226
1227     [PA_CHANNEL_POSITION_TOP_REAR_CENTER] = SND_MIXER_SCHN_UNKNOWN,
1228     [PA_CHANNEL_POSITION_TOP_REAR_LEFT] = SND_MIXER_SCHN_UNKNOWN,
1229     [PA_CHANNEL_POSITION_TOP_REAR_RIGHT] = SND_MIXER_SCHN_UNKNOWN
1230 };
1231
1232
1233 int pa_alsa_calc_mixer_map(snd_mixer_elem_t *elem, const pa_channel_map *channel_map, snd_mixer_selem_channel_id_t mixer_map[], pa_bool_t playback) {
1234     unsigned i;
1235     pa_bool_t alsa_channel_used[SND_MIXER_SCHN_LAST];
1236     pa_bool_t mono_used = FALSE;
1237
1238     pa_assert(elem);
1239     pa_assert(channel_map);
1240     pa_assert(mixer_map);
1241
1242     memset(&alsa_channel_used, 0, sizeof(alsa_channel_used));
1243
1244     if (channel_map->channels > 1 &&
1245         ((playback && snd_mixer_selem_has_playback_volume_joined(elem)) ||
1246          (!playback && snd_mixer_selem_has_capture_volume_joined(elem)))) {
1247         pa_log_info("ALSA device lacks independant volume controls for each channel.");
1248         return -1;
1249     }
1250
1251     for (i = 0; i < channel_map->channels; i++) {
1252         snd_mixer_selem_channel_id_t id;
1253         pa_bool_t is_mono;
1254
1255         is_mono = channel_map->map[i] == PA_CHANNEL_POSITION_MONO;
1256         id = alsa_channel_ids[channel_map->map[i]];
1257
1258         if (!is_mono && id == SND_MIXER_SCHN_UNKNOWN) {
1259             pa_log_info("Configured channel map contains channel '%s' that is unknown to the ALSA mixer.", pa_channel_position_to_string(channel_map->map[i]));
1260             return -1;
1261         }
1262
1263         if ((is_mono && mono_used) || (!is_mono && alsa_channel_used[id])) {
1264             pa_log_info("Channel map has duplicate channel '%s', falling back to software volume control.", pa_channel_position_to_string(channel_map->map[i]));
1265             return -1;
1266         }
1267
1268         if ((playback && (!snd_mixer_selem_has_playback_channel(elem, id) || (is_mono && !snd_mixer_selem_is_playback_mono(elem)))) ||
1269             (!playback && (!snd_mixer_selem_has_capture_channel(elem, id) || (is_mono && !snd_mixer_selem_is_capture_mono(elem))))) {
1270
1271             pa_log_info("ALSA device lacks separate volumes control for channel '%s'", pa_channel_position_to_string(channel_map->map[i]));
1272             return -1;
1273         }
1274
1275         if (is_mono) {
1276             mixer_map[i] = SND_MIXER_SCHN_MONO;
1277             mono_used = TRUE;
1278         } else {
1279             mixer_map[i] = id;
1280             alsa_channel_used[id] = TRUE;
1281         }
1282     }
1283
1284     pa_log_info("All %u channels can be mapped to mixer channels.", channel_map->channels);
1285
1286     return 0;
1287 }
1288
1289 void pa_alsa_dump(snd_pcm_t *pcm) {
1290     int err;
1291     snd_output_t *out;
1292
1293     pa_assert(pcm);
1294
1295     pa_assert_se(snd_output_buffer_open(&out) == 0);
1296
1297     if ((err = snd_pcm_dump(pcm, out)) < 0)
1298         pa_log_debug("snd_pcm_dump(): %s", snd_strerror(err));
1299     else {
1300         char *s = NULL;
1301         snd_output_buffer_string(out, &s);
1302         pa_log_debug("snd_pcm_dump():\n%s", pa_strnull(s));
1303     }
1304
1305     pa_assert_se(snd_output_close(out) == 0);
1306 }
1307
1308 void pa_alsa_dump_status(snd_pcm_t *pcm) {
1309     int err;
1310     snd_output_t *out;
1311     snd_pcm_status_t *status;
1312
1313     pa_assert(pcm);
1314
1315     snd_pcm_status_alloca(&status);
1316
1317     pa_assert_se(snd_output_buffer_open(&out) == 0);
1318
1319     pa_assert_se(snd_pcm_status(pcm, status) == 0);
1320
1321     if ((err = snd_pcm_status_dump(status, out)) < 0)
1322         pa_log_debug("snd_pcm_dump(): %s", snd_strerror(err));
1323     else {
1324         char *s = NULL;
1325         snd_output_buffer_string(out, &s);
1326         pa_log_debug("snd_pcm_dump():\n%s", pa_strnull(s));
1327     }
1328
1329     pa_assert_se(snd_output_close(out) == 0);
1330 }
1331
1332 static void alsa_error_handler(const char *file, int line, const char *function, int err, const char *fmt,...) {
1333     va_list ap;
1334     char *alsa_file;
1335
1336     alsa_file = pa_sprintf_malloc("(alsa-lib)%s", file);
1337
1338     va_start(ap, fmt);
1339
1340     pa_log_levelv_meta(PA_LOG_INFO, alsa_file, line, function, fmt, ap);
1341
1342     va_end(ap);
1343
1344     pa_xfree(alsa_file);
1345 }
1346
1347 static pa_atomic_t n_error_handler_installed = PA_ATOMIC_INIT(0);
1348
1349 void pa_alsa_redirect_errors_inc(void) {
1350     /* This is not really thread safe, but we do our best */
1351
1352     if (pa_atomic_inc(&n_error_handler_installed) == 0)
1353         snd_lib_error_set_handler(alsa_error_handler);
1354 }
1355
1356 void pa_alsa_redirect_errors_dec(void) {
1357     int r;
1358
1359     pa_assert_se((r = pa_atomic_dec(&n_error_handler_installed)) >= 1);
1360
1361     if (r == 1)
1362         snd_lib_error_set_handler(NULL);
1363 }
1364
1365 void pa_alsa_init_proplist_card(pa_core *c, pa_proplist *p, int card) {
1366     char *cn, *lcn, *dn;
1367
1368     pa_assert(p);
1369     pa_assert(card >= 0);
1370
1371     pa_proplist_setf(p, "alsa.card", "%i", card);
1372
1373     if (snd_card_get_name(card, &cn) >= 0) {
1374         pa_proplist_sets(p, "alsa.card_name", cn);
1375         free(cn);
1376     }
1377
1378     if (snd_card_get_longname(card, &lcn) >= 0) {
1379         pa_proplist_sets(p, "alsa.long_card_name", lcn);
1380         free(lcn);
1381     }
1382
1383     if ((dn = pa_alsa_get_driver_name(card))) {
1384         pa_proplist_sets(p, "alsa.driver_name", dn);
1385         pa_xfree(dn);
1386     }
1387
1388 #ifdef HAVE_HAL
1389     pa_hal_get_info(c, p, card);
1390 #endif
1391 }
1392
1393 void pa_alsa_init_proplist_pcm_info(pa_core *c, pa_proplist *p, snd_pcm_info_t *pcm_info) {
1394
1395     static const char * const alsa_class_table[SND_PCM_CLASS_LAST+1] = {
1396         [SND_PCM_CLASS_GENERIC] = "generic",
1397         [SND_PCM_CLASS_MULTI] = "multi",
1398         [SND_PCM_CLASS_MODEM] = "modem",
1399         [SND_PCM_CLASS_DIGITIZER] = "digitizer"
1400     };
1401     static const char * const class_table[SND_PCM_CLASS_LAST+1] = {
1402         [SND_PCM_CLASS_GENERIC] = "sound",
1403         [SND_PCM_CLASS_MULTI] = NULL,
1404         [SND_PCM_CLASS_MODEM] = "modem",
1405         [SND_PCM_CLASS_DIGITIZER] = NULL
1406     };
1407     static const char * const alsa_subclass_table[SND_PCM_SUBCLASS_LAST+1] = {
1408         [SND_PCM_SUBCLASS_GENERIC_MIX] = "generic-mix",
1409         [SND_PCM_SUBCLASS_MULTI_MIX] = "multi-mix"
1410     };
1411
1412     snd_pcm_class_t class;
1413     snd_pcm_subclass_t subclass;
1414     const char *n, *id, *sdn, *cn = NULL;
1415     int card;
1416
1417     pa_assert(p);
1418     pa_assert(pcm_info);
1419
1420     pa_proplist_sets(p, PA_PROP_DEVICE_API, "alsa");
1421
1422     class = snd_pcm_info_get_class(pcm_info);
1423     if (class <= SND_PCM_CLASS_LAST) {
1424         if (class_table[class])
1425             pa_proplist_sets(p, PA_PROP_DEVICE_CLASS, class_table[class]);
1426         if (alsa_class_table[class])
1427             pa_proplist_sets(p, "alsa.class", alsa_class_table[class]);
1428     }
1429     subclass = snd_pcm_info_get_subclass(pcm_info);
1430     if (subclass <= SND_PCM_SUBCLASS_LAST)
1431         if (alsa_subclass_table[subclass])
1432             pa_proplist_sets(p, "alsa.subclass", alsa_subclass_table[subclass]);
1433
1434     if ((n = snd_pcm_info_get_name(pcm_info)))
1435         pa_proplist_sets(p, "alsa.name", n);
1436
1437     if ((id = snd_pcm_info_get_id(pcm_info)))
1438         pa_proplist_sets(p, "alsa.id", id);
1439
1440     pa_proplist_setf(p, "alsa.subdevice", "%u", snd_pcm_info_get_subdevice(pcm_info));
1441     if ((sdn = snd_pcm_info_get_subdevice_name(pcm_info)))
1442         pa_proplist_sets(p, "alsa.subdevice_name", sdn);
1443
1444     pa_proplist_setf(p, "alsa.device", "%u", snd_pcm_info_get_device(pcm_info));
1445
1446     if ((card = snd_pcm_info_get_card(pcm_info)) >= 0) {
1447         pa_alsa_init_proplist_card(c, p, card);
1448         cn = pa_proplist_gets(p, "alsa.card_name");
1449     }
1450
1451     if (cn && n && !strstr(cn, n) && !strstr(n, cn))
1452         pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, "%s, %s", cn, n);
1453     else if (cn && (!n || strstr(cn, n)))
1454         pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, cn);
1455     else if (n)
1456         pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, n);
1457 }
1458
1459 void pa_alsa_init_proplist_pcm(pa_core *c, pa_proplist *p, snd_pcm_t *pcm) {
1460     snd_pcm_hw_params_t *hwparams;
1461     snd_pcm_info_t *info;
1462     int bits, err;
1463
1464     snd_pcm_hw_params_alloca(&hwparams);
1465     snd_pcm_info_alloca(&info);
1466
1467     if ((err = snd_pcm_hw_params_current(pcm, hwparams)) < 0)
1468         pa_log_warn("Error fetching hardware parameter info: %s", snd_strerror(err));
1469     else {
1470
1471         if ((bits = snd_pcm_hw_params_get_sbits(hwparams)) >= 0)
1472             pa_proplist_setf(p, "alsa.resolution_bits", "%i", bits);
1473     }
1474
1475     if ((err = snd_pcm_info(pcm, info)) < 0)
1476         pa_log_warn("Error fetching PCM info: %s", snd_strerror(err));
1477     else
1478         pa_alsa_init_proplist_pcm_info(c, p, info);
1479 }
1480
1481 int pa_alsa_recover_from_poll(snd_pcm_t *pcm, int revents) {
1482     snd_pcm_state_t state;
1483     int err;
1484
1485     pa_assert(pcm);
1486
1487     if (revents & POLLERR)
1488         pa_log_debug("Got POLLERR from ALSA");
1489     if (revents & POLLNVAL)
1490         pa_log_warn("Got POLLNVAL from ALSA");
1491     if (revents & POLLHUP)
1492         pa_log_warn("Got POLLHUP from ALSA");
1493     if (revents & POLLPRI)
1494         pa_log_warn("Got POLLPRI from ALSA");
1495     if (revents & POLLIN)
1496         pa_log_debug("Got POLLIN from ALSA");
1497     if (revents & POLLOUT)
1498         pa_log_debug("Got POLLOUT from ALSA");
1499
1500     state = snd_pcm_state(pcm);
1501     pa_log_debug("PCM state is %s", snd_pcm_state_name(state));
1502
1503     /* Try to recover from this error */
1504
1505     switch (state) {
1506
1507         case SND_PCM_STATE_XRUN:
1508             if ((err = snd_pcm_recover(pcm, -EPIPE, 1)) != 0) {
1509                 pa_log_warn("Could not recover from POLLERR|POLLNVAL|POLLHUP and XRUN: %s", snd_strerror(err));
1510                 return -1;
1511             }
1512             break;
1513
1514         case SND_PCM_STATE_SUSPENDED:
1515             if ((err = snd_pcm_recover(pcm, -ESTRPIPE, 1)) != 0) {
1516                 pa_log_warn("Could not recover from POLLERR|POLLNVAL|POLLHUP and SUSPENDED: %s", snd_strerror(err));
1517                 return -1;
1518             }
1519             break;
1520
1521         default:
1522
1523             snd_pcm_drop(pcm);
1524
1525             if ((err = snd_pcm_prepare(pcm)) < 0) {
1526                 pa_log_warn("Could not recover from POLLERR|POLLNVAL|POLLHUP with snd_pcm_prepare(): %s", snd_strerror(err));
1527                 return -1;
1528             }
1529             break;
1530     }
1531
1532     return 0;
1533 }
1534
1535 pa_rtpoll_item* pa_alsa_build_pollfd(snd_pcm_t *pcm, pa_rtpoll *rtpoll) {
1536     int n, err;
1537     struct pollfd *pollfd;
1538     pa_rtpoll_item *item;
1539
1540     pa_assert(pcm);
1541
1542     if ((n = snd_pcm_poll_descriptors_count(pcm)) < 0) {
1543         pa_log("snd_pcm_poll_descriptors_count() failed: %s", snd_strerror(n));
1544         return NULL;
1545     }
1546
1547     item = pa_rtpoll_item_new(rtpoll, PA_RTPOLL_NEVER, (unsigned) n);
1548     pollfd = pa_rtpoll_item_get_pollfd(item, NULL);
1549
1550     if ((err = snd_pcm_poll_descriptors(pcm, pollfd, (unsigned) n)) < 0) {
1551         pa_log("snd_pcm_poll_descriptors() failed: %s", snd_strerror(err));
1552         pa_rtpoll_item_free(item);
1553         return NULL;
1554     }
1555
1556     return item;
1557 }
1558
1559 snd_pcm_sframes_t pa_alsa_safe_avail(snd_pcm_t *pcm, size_t hwbuf_size, const pa_sample_spec *ss) {
1560     snd_pcm_sframes_t n;
1561     size_t k;
1562
1563     pa_assert(pcm);
1564     pa_assert(hwbuf_size > 0);
1565     pa_assert(ss);
1566
1567     /* Some ALSA driver expose weird bugs, let's inform the user about
1568      * what is going on */
1569
1570     n = snd_pcm_avail(pcm);
1571
1572     if (n <= 0)
1573         return n;
1574
1575     k = (size_t) n * pa_frame_size(ss);
1576
1577     if (k >= hwbuf_size * 5 ||
1578         k >= pa_bytes_per_second(ss)*10) {
1579
1580         PA_ONCE_BEGIN {
1581             char *dn = pa_alsa_get_driver_name_by_pcm(pcm);
1582             pa_log(_("snd_pcm_avail() returned a value that is exceptionally large: %lu bytes (%lu ms).\n"
1583                      "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers."),
1584                    (unsigned long) k,
1585                    (unsigned long) (pa_bytes_to_usec(k, ss) / PA_USEC_PER_MSEC),
1586                    pa_strnull(dn));
1587             pa_xfree(dn);
1588         } PA_ONCE_END;
1589
1590         /* Mhmm, let's try not to fail completely */
1591         n = (snd_pcm_sframes_t) (hwbuf_size / pa_frame_size(ss));
1592     }
1593
1594     return n;
1595 }
1596
1597 int pa_alsa_safe_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delay, size_t hwbuf_size, const pa_sample_spec *ss) {
1598     ssize_t k;
1599     size_t abs_k;
1600     int r;
1601
1602     pa_assert(pcm);
1603     pa_assert(delay);
1604     pa_assert(hwbuf_size > 0);
1605     pa_assert(ss);
1606
1607     /* Some ALSA driver expose weird bugs, let's inform the user about
1608      * what is going on */
1609
1610     if ((r = snd_pcm_delay(pcm, delay)) < 0)
1611         return r;
1612
1613     k = (ssize_t) *delay * (ssize_t) pa_frame_size(ss);
1614
1615     abs_k = k >= 0 ? (size_t) k : (size_t) -k;
1616
1617     if (abs_k >= hwbuf_size * 5 ||
1618         abs_k >= pa_bytes_per_second(ss)*10) {
1619
1620         PA_ONCE_BEGIN {
1621             char *dn = pa_alsa_get_driver_name_by_pcm(pcm);
1622             pa_log(_("snd_pcm_delay() returned a value that is exceptionally large: %li bytes (%s%lu ms).\n"
1623                      "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers."),
1624                    (signed long) k,
1625                    k < 0 ? "-" : "",
1626                    (unsigned long) (pa_bytes_to_usec(abs_k, ss) / PA_USEC_PER_MSEC),
1627                    pa_strnull(dn));
1628             pa_xfree(dn);
1629         } PA_ONCE_END;
1630
1631         /* Mhmm, let's try not to fail completely */
1632         if (k < 0)
1633             *delay = -(snd_pcm_sframes_t) (hwbuf_size / pa_frame_size(ss));
1634         else
1635             *delay = (snd_pcm_sframes_t) (hwbuf_size / pa_frame_size(ss));
1636     }
1637
1638     return 0;
1639 }
1640
1641 int pa_alsa_safe_mmap_begin(snd_pcm_t *pcm, const snd_pcm_channel_area_t **areas, snd_pcm_uframes_t *offset, snd_pcm_uframes_t *frames, size_t hwbuf_size, const pa_sample_spec *ss) {
1642     int r;
1643     snd_pcm_uframes_t before;
1644     size_t k;
1645
1646     pa_assert(pcm);
1647     pa_assert(areas);
1648     pa_assert(offset);
1649     pa_assert(frames);
1650     pa_assert(hwbuf_size > 0);
1651     pa_assert(ss);
1652
1653     before = *frames;
1654
1655     r = snd_pcm_mmap_begin(pcm, areas, offset, frames);
1656
1657     if (r < 0)
1658         return r;
1659
1660     k = (size_t) *frames * pa_frame_size(ss);
1661
1662     if (*frames > before ||
1663         k >= hwbuf_size * 3 ||
1664         k >= pa_bytes_per_second(ss)*10)
1665
1666         PA_ONCE_BEGIN {
1667             char *dn = pa_alsa_get_driver_name_by_pcm(pcm);
1668             pa_log(_("snd_pcm_mmap_begin() returned a value that is exceptionally large: %lu bytes (%lu ms).\n"
1669                      "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers."),
1670                    (unsigned long) k,
1671                    (unsigned long) (pa_bytes_to_usec(k, ss) / PA_USEC_PER_MSEC),
1672                    pa_strnull(dn));
1673             pa_xfree(dn);
1674         } PA_ONCE_END;
1675
1676     return r;
1677 }
1678
1679 char *pa_alsa_get_driver_name(int card) {
1680     char *t, *m, *n;
1681
1682     pa_assert(card >= 0);
1683
1684     t = pa_sprintf_malloc("/sys/class/sound/card%i/device/driver/module", card);
1685     m = pa_readlink(t);
1686     pa_xfree(t);
1687
1688     if (!m)
1689         return NULL;
1690
1691     n = pa_xstrdup(pa_path_get_filename(m));
1692     pa_xfree(m);
1693
1694     return n;
1695 }
1696
1697 char *pa_alsa_get_driver_name_by_pcm(snd_pcm_t *pcm) {
1698     int card;
1699
1700     snd_pcm_info_t* info;
1701     snd_pcm_info_alloca(&info);
1702
1703     if (snd_pcm_info(pcm, info) < 0)
1704         return NULL;
1705
1706     if ((card = snd_pcm_info_get_card(info)) < 0)
1707         return NULL;
1708
1709     return pa_alsa_get_driver_name(card);
1710 }
1711
1712 char *pa_alsa_get_reserve_name(const char *device) {
1713     const char *t;
1714     int i;
1715
1716     pa_assert(device);
1717
1718     if ((t = strchr(device, ':')))
1719         device = t+1;
1720
1721     if ((i = snd_card_get_index(device)) < 0) {
1722         int32_t k;
1723
1724         if (pa_atoi(device, &k) < 0)
1725             return NULL;
1726
1727         i = (int) k;
1728     }
1729
1730     return pa_sprintf_malloc("Audio%i", i);
1731 }