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.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <sys/types.h>
  28 #include <limits.h>
  29 #include <asoundlib.h>
  30
  31 #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 #include <pulse/utf8.h>
  37
  38 #include <pulsecore/log.h>
  39 #include <pulsecore/macro.h>
  40 #include <pulsecore/core-util.h>
  41 #include <pulsecore/atomic.h>
  42 #include <pulsecore/core-error.h>
  43 #include <pulsecore/once.h>
  44 #include <pulsecore/thread.h>
  45 #include <pulsecore/conf-parser.h>
  46
  47 #include "alsa-util.h"
  48 #include "alsa-mixer.h"
  49
  50 #ifdef HAVE_HAL
  51 #include "hal-util.h"
  52 #endif
  53
  54 #ifdef HAVE_UDEV
  55 #include "udev-util.h"
  56 #endif
  57
  58 static int set_format(snd_pcm_t *pcm_handle, snd_pcm_hw_params_t *hwparams, pa_sample_format_t *f) {
  59
  60     static const snd_pcm_format_t format_trans[] = {
  61         [PA_SAMPLE_U8] = SND_PCM_FORMAT_U8,
  62         [PA_SAMPLE_ALAW] = SND_PCM_FORMAT_A_LAW,
  63         [PA_SAMPLE_ULAW] = SND_PCM_FORMAT_MU_LAW,
  64         [PA_SAMPLE_S16LE] = SND_PCM_FORMAT_S16_LE,
  65         [PA_SAMPLE_S16BE] = SND_PCM_FORMAT_S16_BE,
  66         [PA_SAMPLE_FLOAT32LE] = SND_PCM_FORMAT_FLOAT_LE,
  67         [PA_SAMPLE_FLOAT32BE] = SND_PCM_FORMAT_FLOAT_BE,
  68         [PA_SAMPLE_S32LE] = SND_PCM_FORMAT_S32_LE,
  69         [PA_SAMPLE_S32BE] = SND_PCM_FORMAT_S32_BE,
  70         [PA_SAMPLE_S24LE] = SND_PCM_FORMAT_S24_3LE,
  71         [PA_SAMPLE_S24BE] = SND_PCM_FORMAT_S24_3BE,
  72         [PA_SAMPLE_S24_32LE] = SND_PCM_FORMAT_S24_LE,
  73         [PA_SAMPLE_S24_32BE] = SND_PCM_FORMAT_S24_BE,
  74     };
  75
  76     static const pa_sample_format_t try_order[] = {
  77         PA_SAMPLE_FLOAT32NE,
  78         PA_SAMPLE_FLOAT32RE,
  79         PA_SAMPLE_S32NE,
  80         PA_SAMPLE_S32RE,
  81         PA_SAMPLE_S24_32NE,
  82         PA_SAMPLE_S24_32RE,
  83         PA_SAMPLE_S24NE,
  84         PA_SAMPLE_S24RE,
  85         PA_SAMPLE_S16NE,
  86         PA_SAMPLE_S16RE,
  87         PA_SAMPLE_ALAW,
  88         PA_SAMPLE_ULAW,
  89         PA_SAMPLE_U8
  90     };
  91
  92     unsigned i;
  93     int ret;
  94
  95     pa_assert(pcm_handle);
  96     pa_assert(f);
  97
  98     if ((ret = snd_pcm_hw_params_set_format(pcm_handle, hwparams, format_trans[*f])) >= 0)
  99         return ret;
 100
 101     pa_log_debug("snd_pcm_hw_params_set_format(%s) failed: %s",
 102                  snd_pcm_format_description(format_trans[*f]),
 103                  pa_alsa_strerror(ret));
 104
 105     if (*f == PA_SAMPLE_FLOAT32BE)
 106         *f = PA_SAMPLE_FLOAT32LE;
 107     else if (*f == PA_SAMPLE_FLOAT32LE)
 108         *f = PA_SAMPLE_FLOAT32BE;
 109     else if (*f == PA_SAMPLE_S24BE)
 110         *f = PA_SAMPLE_S24LE;
 111     else if (*f == PA_SAMPLE_S24LE)
 112         *f = PA_SAMPLE_S24BE;
 113     else if (*f == PA_SAMPLE_S24_32BE)
 114         *f = PA_SAMPLE_S24_32LE;
 115     else if (*f == PA_SAMPLE_S24_32LE)
 116         *f = PA_SAMPLE_S24_32BE;
 117     else if (*f == PA_SAMPLE_S16BE)
 118         *f = PA_SAMPLE_S16LE;
 119     else if (*f == PA_SAMPLE_S16LE)
 120         *f = PA_SAMPLE_S16BE;
 121     else if (*f == PA_SAMPLE_S32BE)
 122         *f = PA_SAMPLE_S32LE;
 123     else if (*f == PA_SAMPLE_S32LE)
 124         *f = PA_SAMPLE_S32BE;
 125     else
 126         goto try_auto;
 127
 128     if ((ret = snd_pcm_hw_params_set_format(pcm_handle, hwparams, format_trans[*f])) >= 0)
 129         return ret;
 130
 131     pa_log_debug("snd_pcm_hw_params_set_format(%s) failed: %s",
 132                  snd_pcm_format_description(format_trans[*f]),
 133                  pa_alsa_strerror(ret));
 134
 135 try_auto:
 136
 137     for (i = 0; i < PA_ELEMENTSOF(try_order); i++) {
 138         *f = try_order[i];
 139
 140         if ((ret = snd_pcm_hw_params_set_format(pcm_handle, hwparams, format_trans[*f])) >= 0)
 141             return ret;
 142
 143         pa_log_debug("snd_pcm_hw_params_set_format(%s) failed: %s",
 144                      snd_pcm_format_description(format_trans[*f]),
 145                      pa_alsa_strerror(ret));
 146     }
 147
 148     return -1;
 149 }
 150
 151 /* Set the hardware parameters of the given ALSA device. Returns the
 152  * selected fragment settings in *period and *period_size */
 153 int pa_alsa_set_hw_params(
 154         snd_pcm_t *pcm_handle,
 155         pa_sample_spec *ss,
 156         uint32_t *periods,
 157         snd_pcm_uframes_t *period_size,
 158         snd_pcm_uframes_t tsched_size,
 159         pa_bool_t *use_mmap,
 160         pa_bool_t *use_tsched,
 161         pa_bool_t require_exact_channel_number) {
 162
 163     int ret = -1;
 164     snd_pcm_uframes_t _period_size = period_size ? *period_size : 0;
 165     unsigned int _periods = periods ? *periods : 0;
 166     unsigned int r = ss->rate;
 167     unsigned int c = ss->channels;
 168     pa_sample_format_t f = ss->format;
 169     snd_pcm_hw_params_t *hwparams;
 170     pa_bool_t _use_mmap = use_mmap && *use_mmap;
 171     pa_bool_t _use_tsched = use_tsched && *use_tsched;
 172     int dir;
 173
 174     pa_assert(pcm_handle);
 175     pa_assert(ss);
 176
 177     snd_pcm_hw_params_alloca(&hwparams);
 178
 179     if ((ret = snd_pcm_hw_params_any(pcm_handle, hwparams)) < 0) {
 180         pa_log_debug("snd_pcm_hw_params_any() failed: %s", pa_alsa_strerror(ret));
 181         goto finish;
 182     }
 183
 184     if ((ret = snd_pcm_hw_params_set_rate_resample(pcm_handle, hwparams, 0)) < 0) {
 185         pa_log_debug("snd_pcm_hw_params_set_rate_resample() failed: %s", pa_alsa_strerror(ret));
 186         goto finish;
 187     }
 188
 189     if (_use_mmap) {
 190
 191         if (snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0) {
 192
 193             /* mmap() didn't work, fall back to interleaved */
 194
 195             if ((ret = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
 196                 pa_log_debug("snd_pcm_hw_params_set_access() failed: %s", pa_alsa_strerror(ret));
 197                 goto finish;
 198             }
 199
 200             _use_mmap = FALSE;
 201         }
 202
 203     } else if ((ret = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
 204         pa_log_debug("snd_pcm_hw_params_set_access() failed: %s", pa_alsa_strerror(ret));
 205         goto finish;
 206     }
 207
 208     if (!_use_mmap)
 209         _use_tsched = FALSE;
 210
 211     if ((ret = set_format(pcm_handle, hwparams, &f)) < 0)
 212         goto finish;
 213
 214     if ((ret = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, &r, NULL)) < 0) {
 215         pa_log_debug("snd_pcm_hw_params_set_rate_near() failed: %s", pa_alsa_strerror(ret));
 216         goto finish;
 217     }
 218
 219     if (require_exact_channel_number) {
 220         if ((ret = snd_pcm_hw_params_set_channels(pcm_handle, hwparams, c)) < 0) {
 221             pa_log_debug("snd_pcm_hw_params_set_channels(%u) failed: %s", c, pa_alsa_strerror(ret));
 222             goto finish;
 223         }
 224     } else {
 225         if ((ret = snd_pcm_hw_params_set_channels_near(pcm_handle, hwparams, &c)) < 0) {
 226             pa_log_debug("snd_pcm_hw_params_set_channels_near(%u) failed: %s", c, pa_alsa_strerror(ret));
 227             goto finish;
 228         }
 229     }
 230
 231     if ((ret = snd_pcm_hw_params_set_periods_integer(pcm_handle, hwparams)) < 0) {
 232         pa_log_debug("snd_pcm_hw_params_set_periods_integer() failed: %s", pa_alsa_strerror(ret));
 233         goto finish;
 234     }
 235
 236     if (_period_size && tsched_size && _periods) {
 237
 238         /* Adjust the buffer sizes, if we didn't get the rate we were asking for */
 239         _period_size = (snd_pcm_uframes_t) (((uint64_t) _period_size * r) / ss->rate);
 240         tsched_size = (snd_pcm_uframes_t) (((uint64_t) tsched_size * r) / ss->rate);
 241
 242         if (_use_tsched) {
 243             snd_pcm_uframes_t buffer_size = 0;
 244
 245             if ((ret = snd_pcm_hw_params_get_buffer_size_max(hwparams, &buffer_size)) < 0)
 246                 pa_log_warn("snd_pcm_hw_params_get_buffer_size_max() failed: %s", pa_alsa_strerror(ret));
 247             else
 248                 pa_log_debug("Maximum hw buffer size is %u ms", (unsigned) buffer_size * 1000 / r);
 249
 250             _period_size = tsched_size;
 251             _periods = 1;
 252         }
 253
 254         if (_period_size > 0 && _periods > 0) {
 255             snd_pcm_uframes_t buffer_size;
 256
 257             buffer_size = _periods * _period_size;
 258
 259             if ((ret = snd_pcm_hw_params_set_buffer_size_near(pcm_handle, hwparams, &buffer_size)) < 0)
 260                 pa_log_info("snd_pcm_hw_params_set_buffer_size_near() failed: %s", pa_alsa_strerror(ret));
 261         }
 262
 263         if (_periods > 0) {
 264
 265             /* First we pass 0 as direction to get exactly what we
 266              * asked for. That this is necessary is presumably a bug
 267              * in ALSA. All in all this is mostly a hint to ALSA, so
 268              * we don't care if this fails. */
 269
 270             dir = 0;
 271             if (snd_pcm_hw_params_set_periods_near(pcm_handle, hwparams, &_periods, &dir) < 0) {
 272                 dir = 1;
 273                 if (snd_pcm_hw_params_set_periods_near(pcm_handle, hwparams, &_periods, &dir) < 0) {
 274                     dir = -1;
 275                     if ((ret = snd_pcm_hw_params_set_periods_near(pcm_handle, hwparams, &_periods, &dir)) < 0)
 276                         pa_log_info("snd_pcm_hw_params_set_periods_near() failed: %s", pa_alsa_strerror(ret));
 277                 }
 278             }
 279         }
 280     }
 281
 282     if  ((ret = snd_pcm_hw_params(pcm_handle, hwparams)) < 0)
 283         goto finish;
 284
 285     if (ss->rate != r)
 286         pa_log_info("Device %s doesn't support %u Hz, changed to %u Hz.", snd_pcm_name(pcm_handle), ss->rate, r);
 287
 288     if (ss->channels != c)
 289         pa_log_info("Device %s doesn't support %u channels, changed to %u.", snd_pcm_name(pcm_handle), ss->channels, c);
 290
 291     if (ss->format != f)
 292         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));
 293
 294     if ((ret = snd_pcm_prepare(pcm_handle)) < 0) {
 295         pa_log_info("snd_pcm_prepare() failed: %s", pa_alsa_strerror(ret));
 296         goto finish;
 297     }
 298
 299     if ((ret = snd_pcm_hw_params_get_period_size(hwparams, &_period_size, &dir)) < 0 ||
 300         (ret = snd_pcm_hw_params_get_periods(hwparams, &_periods, &dir)) < 0) {
 301         pa_log_info("snd_pcm_hw_params_get_period{s|_size}() failed: %s", pa_alsa_strerror(ret));
 302         goto finish;
 303     }
 304
 305     /* If the sample rate deviates too much, we need to resample */
 306     if (r < ss->rate*.95 || r > ss->rate*1.05)
 307         ss->rate = r;
 308     ss->channels = (uint8_t) c;
 309     ss->format = f;
 310
 311     pa_assert(_periods > 0);
 312     pa_assert(_period_size > 0);
 313
 314     if (periods)
 315         *periods = _periods;
 316
 317     if (period_size)
 318         *period_size = _period_size;
 319
 320     if (use_mmap)
 321         *use_mmap = _use_mmap;
 322
 323     if (use_tsched)
 324         *use_tsched = _use_tsched;
 325
 326     ret = 0;
 327
 328     snd_pcm_nonblock(pcm_handle, 1);
 329
 330 finish:
 331
 332     return ret;
 333 }
 334
 335 int pa_alsa_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min) {
 336     snd_pcm_sw_params_t *swparams;
 337     snd_pcm_uframes_t boundary;
 338     int err;
 339
 340     pa_assert(pcm);
 341
 342     snd_pcm_sw_params_alloca(&swparams);
 343
 344     if ((err = snd_pcm_sw_params_current(pcm, swparams) < 0)) {
 345         pa_log_warn("Unable to determine current swparams: %s\n", pa_alsa_strerror(err));
 346         return err;
 347     }
 348
 349     if ((err = snd_pcm_sw_params_set_period_event(pcm, swparams, 0)) < 0) {
 350         pa_log_warn("Unable to disable period event: %s\n", pa_alsa_strerror(err));
 351         return err;
 352     }
 353
 354     if ((err = snd_pcm_sw_params_set_tstamp_mode(pcm, swparams, SND_PCM_TSTAMP_ENABLE)) < 0) {
 355         pa_log_warn("Unable to enable time stamping: %s\n", pa_alsa_strerror(err));
 356         return err;
 357     }
 358
 359     if ((err = snd_pcm_sw_params_get_boundary(swparams, &boundary)) < 0) {
 360         pa_log_warn("Unable to get boundary: %s\n", pa_alsa_strerror(err));
 361         return err;
 362     }
 363
 364     if ((err = snd_pcm_sw_params_set_stop_threshold(pcm, swparams, boundary)) < 0) {
 365         pa_log_warn("Unable to set stop threshold: %s\n", pa_alsa_strerror(err));
 366         return err;
 367     }
 368
 369     if ((err = snd_pcm_sw_params_set_start_threshold(pcm, swparams, (snd_pcm_uframes_t) -1)) < 0) {
 370         pa_log_warn("Unable to set start threshold: %s\n", pa_alsa_strerror(err));
 371         return err;
 372     }
 373
 374     if ((err = snd_pcm_sw_params_set_avail_min(pcm, swparams, avail_min)) < 0) {
 375         pa_log_error("snd_pcm_sw_params_set_avail_min() failed: %s", pa_alsa_strerror(err));
 376         return err;
 377     }
 378
 379     if ((err = snd_pcm_sw_params(pcm, swparams)) < 0) {
 380         pa_log_warn("Unable to set sw params: %s\n", pa_alsa_strerror(err));
 381         return err;
 382     }
 383
 384     return 0;
 385 }
 386
 387 snd_pcm_t *pa_alsa_open_by_device_id_auto(
 388         const char *dev_id,
 389         char **dev,
 390         pa_sample_spec *ss,
 391         pa_channel_map* map,
 392         int mode,
 393         uint32_t *nfrags,
 394         snd_pcm_uframes_t *period_size,
 395         snd_pcm_uframes_t tsched_size,
 396         pa_bool_t *use_mmap,
 397         pa_bool_t *use_tsched,
 398         pa_alsa_profile_set *ps,
 399         pa_alsa_mapping **mapping) {
 400
 401     char *d;
 402     snd_pcm_t *pcm_handle;
 403     void *state;
 404     pa_alsa_mapping *m;
 405
 406     pa_assert(dev_id);
 407     pa_assert(dev);
 408     pa_assert(ss);
 409     pa_assert(map);
 410     pa_assert(nfrags);
 411     pa_assert(period_size);
 412     pa_assert(ps);
 413
 414     /* First we try to find a device string with a superset of the
 415      * requested channel map. We iterate through our device table from
 416      * top to bottom and take the first that matches. If we didn't
 417      * find a working device that way, we iterate backwards, and check
 418      * all devices that do not provide a superset of the requested
 419      * channel map.*/
 420
 421     PA_HASHMAP_FOREACH(m, ps->mappings, state) {
 422         if (!pa_channel_map_superset(&m->channel_map, map))
 423             continue;
 424
 425         pa_log_debug("Checking for superset %s (%s)", m->name, m->device_strings[0]);
 426
 427         pcm_handle = pa_alsa_open_by_device_id_mapping(
 428                 dev_id,
 429                 dev,
 430                 ss,
 431                 map,
 432                 mode,
 433                 nfrags,
 434                 period_size,
 435                 tsched_size,
 436                 use_mmap,
 437                 use_tsched,
 438                 m);
 439
 440         if (pcm_handle) {
 441             if (mapping)
 442                 *mapping = m;
 443
 444             return pcm_handle;
 445         }
 446     }
 447
 448     PA_HASHMAP_FOREACH_BACKWARDS(m, ps->mappings, state) {
 449         if (pa_channel_map_superset(&m->channel_map, map))
 450             continue;
 451
 452         pa_log_debug("Checking for subset %s (%s)", m->name, m->device_strings[0]);
 453
 454         pcm_handle = pa_alsa_open_by_device_id_mapping(
 455                 dev_id,
 456                 dev,
 457                 ss,
 458                 map,
 459                 mode,
 460                 nfrags,
 461                 period_size,
 462                 tsched_size,
 463                 use_mmap,
 464                 use_tsched,
 465                 m);
 466
 467         if (pcm_handle) {
 468             if (mapping)
 469                 *mapping = m;
 470
 471             return pcm_handle;
 472         }
 473     }
 474
 475     /* OK, we didn't find any good device, so let's try the raw hw: stuff */
 476     d = pa_sprintf_malloc("hw:%s", dev_id);
 477     pa_log_debug("Trying %s as last resort...", d);
 478     pcm_handle = pa_alsa_open_by_device_string(d, dev, ss, map, mode, nfrags, period_size, tsched_size, use_mmap, use_tsched, FALSE);
 479     pa_xfree(d);
 480
 481     if (pcm_handle && mapping)
 482         *mapping = NULL;
 483
 484     return pcm_handle;
 485 }
 486
 487 snd_pcm_t *pa_alsa_open_by_device_id_mapping(
 488         const char *dev_id,
 489         char **dev,
 490         pa_sample_spec *ss,
 491         pa_channel_map* map,
 492         int mode,
 493         uint32_t *nfrags,
 494         snd_pcm_uframes_t *period_size,
 495         snd_pcm_uframes_t tsched_size,
 496         pa_bool_t *use_mmap,
 497         pa_bool_t *use_tsched,
 498         pa_alsa_mapping *m) {
 499
 500     snd_pcm_t *pcm_handle;
 501     pa_sample_spec try_ss;
 502     pa_channel_map try_map;
 503
 504     pa_assert(dev_id);
 505     pa_assert(dev);
 506     pa_assert(ss);
 507     pa_assert(map);
 508     pa_assert(nfrags);
 509     pa_assert(period_size);
 510     pa_assert(m);
 511
 512     try_ss.channels = m->channel_map.channels;
 513     try_ss.rate = ss->rate;
 514     try_ss.format = ss->format;
 515     try_map = m->channel_map;
 516
 517     pcm_handle = pa_alsa_open_by_template(
 518             m->device_strings,
 519             dev_id,
 520             dev,
 521             &try_ss,
 522             &try_map,
 523             mode,
 524             nfrags,
 525             period_size,
 526             tsched_size,
 527             use_mmap,
 528             use_tsched,
 529             TRUE);
 530
 531     if (!pcm_handle)
 532         return NULL;
 533
 534     *ss = try_ss;
 535     *map = try_map;
 536     pa_assert(map->channels == ss->channels);
 537
 538     return pcm_handle;
 539 }
 540
 541 snd_pcm_t *pa_alsa_open_by_device_string(
 542         const char *device,
 543         char **dev,
 544         pa_sample_spec *ss,
 545         pa_channel_map* map,
 546         int mode,
 547         uint32_t *nfrags,
 548         snd_pcm_uframes_t *period_size,
 549         snd_pcm_uframes_t tsched_size,
 550         pa_bool_t *use_mmap,
 551         pa_bool_t *use_tsched,
 552         pa_bool_t require_exact_channel_number) {
 553
 554     int err;
 555     char *d;
 556     snd_pcm_t *pcm_handle;
 557     pa_bool_t reformat = FALSE;
 558
 559     pa_assert(device);
 560     pa_assert(ss);
 561     pa_assert(map);
 562
 563     d = pa_xstrdup(device);
 564
 565     for (;;) {
 566         pa_log_debug("Trying %s %s SND_PCM_NO_AUTO_FORMAT ...", d, reformat ? "without" : "with");
 567
 568         if ((err = snd_pcm_open(&pcm_handle, d, mode,
 569                                 SND_PCM_NONBLOCK|
 570                                 SND_PCM_NO_AUTO_RESAMPLE|
 571                                 SND_PCM_NO_AUTO_CHANNELS|
 572                                 (reformat ? 0 : SND_PCM_NO_AUTO_FORMAT))) < 0) {
 573             pa_log_info("Error opening PCM device %s: %s", d, pa_alsa_strerror(err));
 574             goto fail;
 575         }
 576
 577         pa_log_debug("Managed to open %s", d);
 578
 579         if ((err = pa_alsa_set_hw_params(pcm_handle, ss, nfrags, period_size, tsched_size, use_mmap, use_tsched, require_exact_channel_number)) < 0) {
 580
 581             if (!reformat) {
 582                 reformat = TRUE;
 583
 584                 snd_pcm_close(pcm_handle);
 585                 continue;
 586             }
 587
 588             /* Hmm, some hw is very exotic, so we retry with plug, if without it didn't work */
 589             if (!pa_startswith(d, "plug:") && !pa_startswith(d, "plughw:")) {
 590                 char *t;
 591
 592                 t = pa_sprintf_malloc("plug:%s", d);
 593                 pa_xfree(d);
 594                 d = t;
 595
 596                 reformat = FALSE;
 597
 598                 snd_pcm_close(pcm_handle);
 599                 continue;
 600             }
 601
 602             pa_log_info("Failed to set hardware parameters on %s: %s", d, pa_alsa_strerror(err));
 603             snd_pcm_close(pcm_handle);
 604
 605             goto fail;
 606         }
 607
 608         if (dev)
 609             *dev = d;
 610         else
 611             pa_xfree(d);
 612
 613         if (ss->channels != map->channels)
 614             pa_channel_map_init_extend(map, ss->channels, PA_CHANNEL_MAP_ALSA);
 615
 616         return pcm_handle;
 617     }
 618
 619 fail:
 620     pa_xfree(d);
 621
 622     return NULL;
 623 }
 624
 625 snd_pcm_t *pa_alsa_open_by_template(
 626         char **template,
 627         const char *dev_id,
 628         char **dev,
 629         pa_sample_spec *ss,
 630         pa_channel_map* map,
 631         int mode,
 632         uint32_t *nfrags,
 633         snd_pcm_uframes_t *period_size,
 634         snd_pcm_uframes_t tsched_size,
 635         pa_bool_t *use_mmap,
 636         pa_bool_t *use_tsched,
 637         pa_bool_t require_exact_channel_number) {
 638
 639     snd_pcm_t *pcm_handle;
 640     char **i;
 641
 642     for (i = template; *i; i++) {
 643         char *d;
 644
 645         d = pa_replace(*i, "%f", dev_id);
 646
 647         pcm_handle = pa_alsa_open_by_device_string(
 648                 d,
 649                 dev,
 650                 ss,
 651                 map,
 652                 mode,
 653                 nfrags,
 654                 period_size,
 655                 tsched_size,
 656                 use_mmap,
 657                 use_tsched,
 658                 require_exact_channel_number);
 659
 660         pa_xfree(d);
 661
 662         if (pcm_handle)
 663             return pcm_handle;
 664     }
 665
 666     return NULL;
 667 }
 668
 669 void pa_alsa_dump(pa_log_level_t level, snd_pcm_t *pcm) {
 670     int err;
 671     snd_output_t *out;
 672
 673     pa_assert(pcm);
 674
 675     pa_assert_se(snd_output_buffer_open(&out) == 0);
 676
 677     if ((err = snd_pcm_dump(pcm, out)) < 0)
 678         pa_logl(level, "snd_pcm_dump(): %s", pa_alsa_strerror(err));
 679     else {
 680         char *s = NULL;
 681         snd_output_buffer_string(out, &s);
 682         pa_logl(level, "snd_pcm_dump():\n%s", pa_strnull(s));
 683     }
 684
 685     pa_assert_se(snd_output_close(out) == 0);
 686 }
 687
 688 void pa_alsa_dump_status(snd_pcm_t *pcm) {
 689     int err;
 690     snd_output_t *out;
 691     snd_pcm_status_t *status;
 692     char *s = NULL;
 693
 694     pa_assert(pcm);
 695
 696     snd_pcm_status_alloca(&status);
 697
 698     if ((err = snd_output_buffer_open(&out)) < 0) {
 699         pa_log_debug("snd_output_buffer_open() failed: %s", pa_cstrerror(err));
 700         return;
 701     }
 702
 703     if ((err = snd_pcm_status(pcm, status)) < 0) {
 704         pa_log_debug("snd_pcm_status() failed: %s", pa_cstrerror(err));
 705         goto finish;
 706     }
 707
 708     if ((err = snd_pcm_status_dump(status, out)) < 0) {
 709         pa_log_debug("snd_pcm_dump(): %s", pa_alsa_strerror(err));
 710         goto finish;
 711     }
 712
 713     snd_output_buffer_string(out, &s);
 714     pa_log_debug("snd_pcm_dump():\n%s", pa_strnull(s));
 715
 716 finish:
 717
 718     snd_output_close(out);
 719 }
 720
 721 static void alsa_error_handler(const char *file, int line, const char *function, int err, const char *fmt,...) {
 722     va_list ap;
 723     char *alsa_file;
 724
 725     alsa_file = pa_sprintf_malloc("(alsa-lib)%s", file);
 726
 727     va_start(ap, fmt);
 728
 729     pa_log_levelv_meta(PA_LOG_INFO, alsa_file, line, function, fmt, ap);
 730
 731     va_end(ap);
 732
 733     pa_xfree(alsa_file);
 734 }
 735
 736 static pa_atomic_t n_error_handler_installed = PA_ATOMIC_INIT(0);
 737
 738 void pa_alsa_redirect_errors_inc(void) {
 739     /* This is not really thread safe, but we do our best */
 740
 741     if (pa_atomic_inc(&n_error_handler_installed) == 0)
 742         snd_lib_error_set_handler(alsa_error_handler);
 743 }
 744
 745 void pa_alsa_redirect_errors_dec(void) {
 746     int r;
 747
 748     pa_assert_se((r = pa_atomic_dec(&n_error_handler_installed)) >= 1);
 749
 750     if (r == 1)
 751         snd_lib_error_set_handler(NULL);
 752 }
 753
 754 pa_bool_t pa_alsa_init_description(pa_proplist *p) {
 755     const char *d, *k;
 756     pa_assert(p);
 757
 758     if (pa_device_init_description(p))
 759         return TRUE;
 760
 761     if (!(d = pa_proplist_gets(p, "alsa.card_name")))
 762         d = pa_proplist_gets(p, "alsa.name");
 763
 764     if (!d)
 765         return FALSE;
 766
 767     k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
 768
 769     if (d && k)
 770         pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, _("%s %s"), d, k);
 771     else if (d)
 772         pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
 773
 774     return FALSE;
 775 }
 776
 777 void pa_alsa_init_proplist_card(pa_core *c, pa_proplist *p, int card) {
 778     char *cn, *lcn, *dn;
 779
 780     pa_assert(p);
 781     pa_assert(card >= 0);
 782
 783     pa_proplist_setf(p, "alsa.card", "%i", card);
 784
 785     if (snd_card_get_name(card, &cn) >= 0) {
 786         pa_proplist_sets(p, "alsa.card_name", cn);
 787         free(cn);
 788     }
 789
 790     if (snd_card_get_longname(card, &lcn) >= 0) {
 791         pa_proplist_sets(p, "alsa.long_card_name", lcn);
 792         free(lcn);
 793     }
 794
 795     if ((dn = pa_alsa_get_driver_name(card))) {
 796         pa_proplist_sets(p, "alsa.driver_name", dn);
 797         pa_xfree(dn);
 798     }
 799
 800 #ifdef HAVE_UDEV
 801     pa_udev_get_info(card, p);
 802 #endif
 803
 804 #ifdef HAVE_HAL
 805     pa_hal_get_info(c, p, card);
 806 #endif
 807 }
 808
 809 void pa_alsa_init_proplist_pcm_info(pa_core *c, pa_proplist *p, snd_pcm_info_t *pcm_info) {
 810
 811     static const char * const alsa_class_table[SND_PCM_CLASS_LAST+1] = {
 812         [SND_PCM_CLASS_GENERIC] = "generic",
 813         [SND_PCM_CLASS_MULTI] = "multi",
 814         [SND_PCM_CLASS_MODEM] = "modem",
 815         [SND_PCM_CLASS_DIGITIZER] = "digitizer"
 816     };
 817     static const char * const class_table[SND_PCM_CLASS_LAST+1] = {
 818         [SND_PCM_CLASS_GENERIC] = "sound",
 819         [SND_PCM_CLASS_MULTI] = NULL,
 820         [SND_PCM_CLASS_MODEM] = "modem",
 821         [SND_PCM_CLASS_DIGITIZER] = NULL
 822     };
 823     static const char * const alsa_subclass_table[SND_PCM_SUBCLASS_LAST+1] = {
 824         [SND_PCM_SUBCLASS_GENERIC_MIX] = "generic-mix",
 825         [SND_PCM_SUBCLASS_MULTI_MIX] = "multi-mix"
 826     };
 827
 828     snd_pcm_class_t class;
 829     snd_pcm_subclass_t subclass;
 830     const char *n, *id, *sdn;
 831     int card;
 832
 833     pa_assert(p);
 834     pa_assert(pcm_info);
 835
 836     pa_proplist_sets(p, PA_PROP_DEVICE_API, "alsa");
 837
 838     if ((class = snd_pcm_info_get_class(pcm_info)) <= SND_PCM_CLASS_LAST) {
 839         if (class_table[class])
 840             pa_proplist_sets(p, PA_PROP_DEVICE_CLASS, class_table[class]);
 841         if (alsa_class_table[class])
 842             pa_proplist_sets(p, "alsa.class", alsa_class_table[class]);
 843     }
 844
 845     if ((subclass = snd_pcm_info_get_subclass(pcm_info)) <= SND_PCM_SUBCLASS_LAST)
 846         if (alsa_subclass_table[subclass])
 847             pa_proplist_sets(p, "alsa.subclass", alsa_subclass_table[subclass]);
 848
 849     if ((n = snd_pcm_info_get_name(pcm_info)))
 850         pa_proplist_sets(p, "alsa.name", n);
 851
 852     if ((id = snd_pcm_info_get_id(pcm_info)))
 853         pa_proplist_sets(p, "alsa.id", id);
 854
 855     pa_proplist_setf(p, "alsa.subdevice", "%u", snd_pcm_info_get_subdevice(pcm_info));
 856     if ((sdn = snd_pcm_info_get_subdevice_name(pcm_info)))
 857         pa_proplist_sets(p, "alsa.subdevice_name", sdn);
 858
 859     pa_proplist_setf(p, "alsa.device", "%u", snd_pcm_info_get_device(pcm_info));
 860
 861     if ((card = snd_pcm_info_get_card(pcm_info)) >= 0)
 862         pa_alsa_init_proplist_card(c, p, card);
 863 }
 864
 865 void pa_alsa_init_proplist_pcm(pa_core *c, pa_proplist *p, snd_pcm_t *pcm) {
 866     snd_pcm_hw_params_t *hwparams;
 867     snd_pcm_info_t *info;
 868     int bits, err;
 869
 870     snd_pcm_hw_params_alloca(&hwparams);
 871     snd_pcm_info_alloca(&info);
 872
 873     if ((err = snd_pcm_hw_params_current(pcm, hwparams)) < 0)
 874         pa_log_warn("Error fetching hardware parameter info: %s", pa_alsa_strerror(err));
 875     else {
 876
 877         if ((bits = snd_pcm_hw_params_get_sbits(hwparams)) >= 0)
 878             pa_proplist_setf(p, "alsa.resolution_bits", "%i", bits);
 879     }
 880
 881     if ((err = snd_pcm_info(pcm, info)) < 0)
 882         pa_log_warn("Error fetching PCM info: %s", pa_alsa_strerror(err));
 883     else
 884         pa_alsa_init_proplist_pcm_info(c, p, info);
 885 }
 886
 887 void pa_alsa_init_proplist_ctl(pa_proplist *p, const char *name) {
 888     int err;
 889     snd_ctl_t *ctl;
 890     snd_ctl_card_info_t *info;
 891     const char *t;
 892
 893     pa_assert(p);
 894
 895     snd_ctl_card_info_alloca(&info);
 896
 897     if ((err = snd_ctl_open(&ctl, name, 0)) < 0) {
 898         pa_log_warn("Error opening low-level control device '%s'", name);
 899         return;
 900     }
 901
 902     if ((err = snd_ctl_card_info(ctl, info)) < 0) {
 903         pa_log_warn("Control device %s card info: %s", name, snd_strerror(err));
 904         snd_ctl_close(ctl);
 905         return;
 906     }
 907
 908     if ((t = snd_ctl_card_info_get_mixername(info)) && *t)
 909         pa_proplist_sets(p, "alsa.mixer_name", t);
 910
 911     if ((t = snd_ctl_card_info_get_components(info)) && *t)
 912         pa_proplist_sets(p, "alsa.components", t);
 913
 914     snd_ctl_close(ctl);
 915 }
 916
 917 int pa_alsa_recover_from_poll(snd_pcm_t *pcm, int revents) {
 918     snd_pcm_state_t state;
 919     int err;
 920
 921     pa_assert(pcm);
 922
 923     if (revents & POLLERR)
 924         pa_log_debug("Got POLLERR from ALSA");
 925     if (revents & POLLNVAL)
 926         pa_log_warn("Got POLLNVAL from ALSA");
 927     if (revents & POLLHUP)
 928         pa_log_warn("Got POLLHUP from ALSA");
 929     if (revents & POLLPRI)
 930         pa_log_warn("Got POLLPRI from ALSA");
 931     if (revents & POLLIN)
 932         pa_log_debug("Got POLLIN from ALSA");
 933     if (revents & POLLOUT)
 934         pa_log_debug("Got POLLOUT from ALSA");
 935
 936     state = snd_pcm_state(pcm);
 937     pa_log_debug("PCM state is %s", snd_pcm_state_name(state));
 938
 939     /* Try to recover from this error */
 940
 941     switch (state) {
 942
 943         case SND_PCM_STATE_XRUN:
 944             if ((err = snd_pcm_recover(pcm, -EPIPE, 1)) != 0) {
 945                 pa_log_warn("Could not recover from POLLERR|POLLNVAL|POLLHUP and XRUN: %s", pa_alsa_strerror(err));
 946                 return -1;
 947             }
 948             break;
 949
 950         case SND_PCM_STATE_SUSPENDED:
 951             if ((err = snd_pcm_recover(pcm, -ESTRPIPE, 1)) != 0) {
 952                 pa_log_warn("Could not recover from POLLERR|POLLNVAL|POLLHUP and SUSPENDED: %s", pa_alsa_strerror(err));
 953                 return -1;
 954             }
 955             break;
 956
 957         default:
 958
 959             snd_pcm_drop(pcm);
 960
 961             if ((err = snd_pcm_prepare(pcm)) < 0) {
 962                 pa_log_warn("Could not recover from POLLERR|POLLNVAL|POLLHUP with snd_pcm_prepare(): %s", pa_alsa_strerror(err));
 963                 return -1;
 964             }
 965             break;
 966     }
 967
 968     return 0;
 969 }
 970
 971 pa_rtpoll_item* pa_alsa_build_pollfd(snd_pcm_t *pcm, pa_rtpoll *rtpoll) {
 972     int n, err;
 973     struct pollfd *pollfd;
 974     pa_rtpoll_item *item;
 975
 976     pa_assert(pcm);
 977
 978     if ((n = snd_pcm_poll_descriptors_count(pcm)) < 0) {
 979         pa_log("snd_pcm_poll_descriptors_count() failed: %s", pa_alsa_strerror(n));
 980         return NULL;
 981     }
 982
 983     item = pa_rtpoll_item_new(rtpoll, PA_RTPOLL_NEVER, (unsigned) n);
 984     pollfd = pa_rtpoll_item_get_pollfd(item, NULL);
 985
 986     if ((err = snd_pcm_poll_descriptors(pcm, pollfd, (unsigned) n)) < 0) {
 987         pa_log("snd_pcm_poll_descriptors() failed: %s", pa_alsa_strerror(err));
 988         pa_rtpoll_item_free(item);
 989         return NULL;
 990     }
 991
 992     return item;
 993 }
 994
 995 snd_pcm_sframes_t pa_alsa_safe_avail(snd_pcm_t *pcm, size_t hwbuf_size, const pa_sample_spec *ss) {
 996     snd_pcm_sframes_t n;
 997     size_t k;
 998
 999     pa_assert(pcm);
1000     pa_assert(hwbuf_size > 0);
1001     pa_assert(ss);
1002
1003     /* Some ALSA driver expose weird bugs, let's inform the user about
1004      * what is going on */
1005
1006     n = snd_pcm_avail(pcm);
1007
1008     if (n <= 0)
1009         return n;
1010
1011     k = (size_t) n * pa_frame_size(ss);
1012
1013     if (k >= hwbuf_size * 5 ||
1014         k >= pa_bytes_per_second(ss)*10) {
1015
1016         PA_ONCE_BEGIN {
1017             char *dn = pa_alsa_get_driver_name_by_pcm(pcm);
1018             pa_log(_("snd_pcm_avail() returned a value that is exceptionally large: %lu bytes (%lu ms).\n"
1019                      "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers."),
1020                    (unsigned long) k,
1021                    (unsigned long) (pa_bytes_to_usec(k, ss) / PA_USEC_PER_MSEC),
1022                    pa_strnull(dn));
1023             pa_xfree(dn);
1024             pa_alsa_dump(PA_LOG_ERROR, pcm);
1025         } PA_ONCE_END;
1026
1027         /* Mhmm, let's try not to fail completely */
1028         n = (snd_pcm_sframes_t) (hwbuf_size / pa_frame_size(ss));
1029     }
1030
1031     return n;
1032 }
1033
1034 int pa_alsa_safe_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delay, size_t hwbuf_size, const pa_sample_spec *ss) {
1035     ssize_t k;
1036     size_t abs_k;
1037     int r;
1038
1039     pa_assert(pcm);
1040     pa_assert(delay);
1041     pa_assert(hwbuf_size > 0);
1042     pa_assert(ss);
1043
1044     /* Some ALSA driver expose weird bugs, let's inform the user about
1045      * what is going on */
1046
1047     if ((r = snd_pcm_delay(pcm, delay)) < 0)
1048         return r;
1049
1050     k = (ssize_t) *delay * (ssize_t) pa_frame_size(ss);
1051
1052     abs_k = k >= 0 ? (size_t) k : (size_t) -k;
1053
1054     if (abs_k >= hwbuf_size * 5 ||
1055         abs_k >= pa_bytes_per_second(ss)*10) {
1056
1057         PA_ONCE_BEGIN {
1058             char *dn = pa_alsa_get_driver_name_by_pcm(pcm);
1059             pa_log(_("snd_pcm_delay() returned a value that is exceptionally large: %li bytes (%s%lu ms).\n"
1060                      "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers."),
1061                    (signed long) k,
1062                    k < 0 ? "-" : "",
1063                    (unsigned long) (pa_bytes_to_usec(abs_k, ss) / PA_USEC_PER_MSEC),
1064                    pa_strnull(dn));
1065             pa_xfree(dn);
1066             pa_alsa_dump(PA_LOG_ERROR, pcm);
1067         } PA_ONCE_END;
1068
1069         /* Mhmm, let's try not to fail completely */
1070         if (k < 0)
1071             *delay = -(snd_pcm_sframes_t) (hwbuf_size / pa_frame_size(ss));
1072         else
1073             *delay = (snd_pcm_sframes_t) (hwbuf_size / pa_frame_size(ss));
1074     }
1075
1076     return 0;
1077 }
1078
1079 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) {
1080     int r;
1081     snd_pcm_uframes_t before;
1082     size_t k;
1083
1084     pa_assert(pcm);
1085     pa_assert(areas);
1086     pa_assert(offset);
1087     pa_assert(frames);
1088     pa_assert(hwbuf_size > 0);
1089     pa_assert(ss);
1090
1091     before = *frames;
1092
1093     r = snd_pcm_mmap_begin(pcm, areas, offset, frames);
1094
1095     if (r < 0)
1096         return r;
1097
1098     k = (size_t) *frames * pa_frame_size(ss);
1099
1100     if (*frames > before ||
1101         k >= hwbuf_size * 3 ||
1102         k >= pa_bytes_per_second(ss)*10)
1103
1104         PA_ONCE_BEGIN {
1105             char *dn = pa_alsa_get_driver_name_by_pcm(pcm);
1106             pa_log(_("snd_pcm_mmap_begin() returned a value that is exceptionally large: %lu bytes (%lu ms).\n"
1107                      "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers."),
1108                    (unsigned long) k,
1109                    (unsigned long) (pa_bytes_to_usec(k, ss) / PA_USEC_PER_MSEC),
1110                    pa_strnull(dn));
1111             pa_xfree(dn);
1112             pa_alsa_dump(PA_LOG_ERROR, pcm);
1113         } PA_ONCE_END;
1114
1115     return r;
1116 }
1117
1118 char *pa_alsa_get_driver_name(int card) {
1119     char *t, *m, *n;
1120
1121     pa_assert(card >= 0);
1122
1123     t = pa_sprintf_malloc("/sys/class/sound/card%i/device/driver/module", card);
1124     m = pa_readlink(t);
1125     pa_xfree(t);
1126
1127     if (!m)
1128         return NULL;
1129
1130     n = pa_xstrdup(pa_path_get_filename(m));
1131     pa_xfree(m);
1132
1133     return n;
1134 }
1135
1136 char *pa_alsa_get_driver_name_by_pcm(snd_pcm_t *pcm) {
1137     int card;
1138     snd_pcm_info_t* info;
1139     snd_pcm_info_alloca(&info);
1140
1141     pa_assert(pcm);
1142
1143     if (snd_pcm_info(pcm, info) < 0)
1144         return NULL;
1145
1146     if ((card = snd_pcm_info_get_card(info)) < 0)
1147         return NULL;
1148
1149     return pa_alsa_get_driver_name(card);
1150 }
1151
1152 char *pa_alsa_get_reserve_name(const char *device) {
1153     const char *t;
1154     int i;
1155
1156     pa_assert(device);
1157
1158     if ((t = strchr(device, ':')))
1159         device = t+1;
1160
1161     if ((i = snd_card_get_index(device)) < 0) {
1162         int32_t k;
1163
1164         if (pa_atoi(device, &k) < 0)
1165             return NULL;
1166
1167         i = (int) k;
1168     }
1169
1170     return pa_sprintf_malloc("Audio%i", i);
1171 }
1172
1173 pa_bool_t pa_alsa_pcm_is_hw(snd_pcm_t *pcm) {
1174     snd_pcm_info_t* info;
1175     snd_pcm_info_alloca(&info);
1176
1177     pa_assert(pcm);
1178
1179     if (snd_pcm_info(pcm, info) < 0)
1180         return FALSE;
1181
1182     return snd_pcm_info_get_card(info) >= 0;
1183 }
1184
1185 pa_bool_t pa_alsa_pcm_is_modem(snd_pcm_t *pcm) {
1186     snd_pcm_info_t* info;
1187     snd_pcm_info_alloca(&info);
1188
1189     pa_assert(pcm);
1190
1191     if (snd_pcm_info(pcm, info) < 0)
1192         return FALSE;
1193
1194     return snd_pcm_info_get_class(info) == SND_PCM_CLASS_MODEM;
1195 }
1196
1197 PA_STATIC_TLS_DECLARE(cstrerror, pa_xfree);
1198
1199 const char* pa_alsa_strerror(int errnum) {
1200     const char *original = NULL;
1201     char *translated, *t;
1202     char errbuf[128];
1203
1204     if ((t = PA_STATIC_TLS_GET(cstrerror)))
1205         pa_xfree(t);
1206
1207     original = snd_strerror(errnum);
1208
1209     if (!original) {
1210         pa_snprintf(errbuf, sizeof(errbuf), "Unknown error %i", errnum);
1211         original = errbuf;
1212     }
1213
1214     if (!(translated = pa_locale_to_utf8(original))) {
1215         pa_log_warn("Unable to convert error string to locale, filtering.");
1216         translated = pa_utf8_filter(original);
1217     }
1218
1219     PA_STATIC_TLS_SET(cstrerror, translated);
1220
1221     return translated;
1222 }