audio/alsaaudio.c

   1 /*
   2  * QEMU ALSA audio driver
   3  *
   4  * Copyright (c) 2005 Vassili Karpov (malc)
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qemu/osdep.h"
  25 #include <alsa/asoundlib.h>
  26 #include "qemu-common.h"
  27 #include "qemu/main-loop.h"
  28 #include "audio.h"
  29 #include "trace.h"
  30
  31 #if QEMU_GNUC_PREREQ(4, 3)
  32 #pragma GCC diagnostic ignored "-Waddress"
  33 #endif
  34
  35 #define AUDIO_CAP "alsa"
  36 #include "audio_int.h"
  37
  38 typedef struct ALSAConf {
  39     int size_in_usec_in;
  40     int size_in_usec_out;
  41     const char *pcm_name_in;
  42     const char *pcm_name_out;
  43     unsigned int buffer_size_in;
  44     unsigned int period_size_in;
  45     unsigned int buffer_size_out;
  46     unsigned int period_size_out;
  47     unsigned int threshold;
  48
  49     int buffer_size_in_overridden;
  50     int period_size_in_overridden;
  51
  52     int buffer_size_out_overridden;
  53     int period_size_out_overridden;
  54 } ALSAConf;
  55
  56 struct pollhlp {
  57     snd_pcm_t *handle;
  58     struct pollfd *pfds;
  59     ALSAConf *conf;
  60     int count;
  61     int mask;
  62 };
  63
  64 typedef struct ALSAVoiceOut {
  65     HWVoiceOut hw;
  66     int wpos;
  67     int pending;
  68     void *pcm_buf;
  69     snd_pcm_t *handle;
  70     struct pollhlp pollhlp;
  71 } ALSAVoiceOut;
  72
  73 typedef struct ALSAVoiceIn {
  74     HWVoiceIn hw;
  75     snd_pcm_t *handle;
  76     void *pcm_buf;
  77     struct pollhlp pollhlp;
  78 } ALSAVoiceIn;
  79
  80 struct alsa_params_req {
  81     int freq;
  82     snd_pcm_format_t fmt;
  83     int nchannels;
  84     int size_in_usec;
  85     int override_mask;
  86     unsigned int buffer_size;
  87     unsigned int period_size;
  88 };
  89
  90 struct alsa_params_obt {
  91     int freq;
  92     audfmt_e fmt;
  93     int endianness;
  94     int nchannels;
  95     snd_pcm_uframes_t samples;
  96 };
  97
  98 static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...)
  99 {
 100     va_list ap;
 101
 102     va_start (ap, fmt);
 103     AUD_vlog (AUDIO_CAP, fmt, ap);
 104     va_end (ap);
 105
 106     AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
 107 }
 108
 109 static void GCC_FMT_ATTR (3, 4) alsa_logerr2 (
 110     int err,
 111     const char *typ,
 112     const char *fmt,
 113     ...
 114     )
 115 {
 116     va_list ap;
 117
 118     AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
 119
 120     va_start (ap, fmt);
 121     AUD_vlog (AUDIO_CAP, fmt, ap);
 122     va_end (ap);
 123
 124     AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
 125 }
 126
 127 static void alsa_fini_poll (struct pollhlp *hlp)
 128 {
 129     int i;
 130     struct pollfd *pfds = hlp->pfds;
 131
 132     if (pfds) {
 133         for (i = 0; i < hlp->count; ++i) {
 134             qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);
 135         }
 136         g_free (pfds);
 137     }
 138     hlp->pfds = NULL;
 139     hlp->count = 0;
 140     hlp->handle = NULL;
 141 }
 142
 143 static void alsa_anal_close1 (snd_pcm_t **handlep)
 144 {
 145     int err = snd_pcm_close (*handlep);
 146     if (err) {
 147         alsa_logerr (err, "Failed to close PCM handle %p\n", *handlep);
 148     }
 149     *handlep = NULL;
 150 }
 151
 152 static void alsa_anal_close (snd_pcm_t **handlep, struct pollhlp *hlp)
 153 {
 154     alsa_fini_poll (hlp);
 155     alsa_anal_close1 (handlep);
 156 }
 157
 158 static int alsa_recover (snd_pcm_t *handle)
 159 {
 160     int err = snd_pcm_prepare (handle);
 161     if (err < 0) {
 162         alsa_logerr (err, "Failed to prepare handle %p\n", handle);
 163         return -1;
 164     }
 165     return 0;
 166 }
 167
 168 static int alsa_resume (snd_pcm_t *handle)
 169 {
 170     int err = snd_pcm_resume (handle);
 171     if (err < 0) {
 172         alsa_logerr (err, "Failed to resume handle %p\n", handle);
 173         return -1;
 174     }
 175     return 0;
 176 }
 177
 178 static void alsa_poll_handler (void *opaque)
 179 {
 180     int err, count;
 181     snd_pcm_state_t state;
 182     struct pollhlp *hlp = opaque;
 183     unsigned short revents;
 184
 185     count = poll (hlp->pfds, hlp->count, 0);
 186     if (count < 0) {
 187         dolog ("alsa_poll_handler: poll %s\n", strerror (errno));
 188         return;
 189     }
 190
 191     if (!count) {
 192         return;
 193     }
 194
 195     /* XXX: ALSA example uses initial count, not the one returned by
 196        poll, correct? */
 197     err = snd_pcm_poll_descriptors_revents (hlp->handle, hlp->pfds,
 198                                             hlp->count, &revents);
 199     if (err < 0) {
 200         alsa_logerr (err, "snd_pcm_poll_descriptors_revents");
 201         return;
 202     }
 203
 204     if (!(revents & hlp->mask)) {
 205         trace_alsa_revents(revents);
 206         return;
 207     }
 208
 209     state = snd_pcm_state (hlp->handle);
 210     switch (state) {
 211     case SND_PCM_STATE_SETUP:
 212         alsa_recover (hlp->handle);
 213         break;
 214
 215     case SND_PCM_STATE_XRUN:
 216         alsa_recover (hlp->handle);
 217         break;
 218
 219     case SND_PCM_STATE_SUSPENDED:
 220         alsa_resume (hlp->handle);
 221         break;
 222
 223     case SND_PCM_STATE_PREPARED:
 224         audio_run ("alsa run (prepared)");
 225         break;
 226
 227     case SND_PCM_STATE_RUNNING:
 228         audio_run ("alsa run (running)");
 229         break;
 230
 231     default:
 232         dolog ("Unexpected state %d\n", state);
 233     }
 234 }
 235
 236 static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp, int mask)
 237 {
 238     int i, count, err;
 239     struct pollfd *pfds;
 240
 241     count = snd_pcm_poll_descriptors_count (handle);
 242     if (count <= 0) {
 243         dolog ("Could not initialize poll mode\n"
 244                "Invalid number of poll descriptors %d\n", count);
 245         return -1;
 246     }
 247
 248     pfds = audio_calloc ("alsa_poll_helper", count, sizeof (*pfds));
 249     if (!pfds) {
 250         dolog ("Could not initialize poll mode\n");
 251         return -1;
 252     }
 253
 254     err = snd_pcm_poll_descriptors (handle, pfds, count);
 255     if (err < 0) {
 256         alsa_logerr (err, "Could not initialize poll mode\n"
 257                      "Could not obtain poll descriptors\n");
 258         g_free (pfds);
 259         return -1;
 260     }
 261
 262     for (i = 0; i < count; ++i) {
 263         if (pfds[i].events & POLLIN) {
 264             qemu_set_fd_handler (pfds[i].fd, alsa_poll_handler, NULL, hlp);
 265         }
 266         if (pfds[i].events & POLLOUT) {
 267             trace_alsa_pollout(i, pfds[i].fd);
 268             qemu_set_fd_handler (pfds[i].fd, NULL, alsa_poll_handler, hlp);
 269         }
 270         trace_alsa_set_handler(pfds[i].events, i, pfds[i].fd, err);
 271
 272     }
 273     hlp->pfds = pfds;
 274     hlp->count = count;
 275     hlp->handle = handle;
 276     hlp->mask = mask;
 277     return 0;
 278 }
 279
 280 static int alsa_poll_out (HWVoiceOut *hw)
 281 {
 282     ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
 283
 284     return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLOUT);
 285 }
 286
 287 static int alsa_poll_in (HWVoiceIn *hw)
 288 {
 289     ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
 290
 291     return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLIN);
 292 }
 293
 294 static int alsa_write (SWVoiceOut *sw, void *buf, int len)
 295 {
 296     return audio_pcm_sw_write (sw, buf, len);
 297 }
 298
 299 static snd_pcm_format_t aud_to_alsafmt (audfmt_e fmt, int endianness)
 300 {
 301     switch (fmt) {
 302     case AUD_FMT_S8:
 303         return SND_PCM_FORMAT_S8;
 304
 305     case AUD_FMT_U8:
 306         return SND_PCM_FORMAT_U8;
 307
 308     case AUD_FMT_S16:
 309         if (endianness) {
 310             return SND_PCM_FORMAT_S16_BE;
 311         }
 312         else {
 313             return SND_PCM_FORMAT_S16_LE;
 314         }
 315
 316     case AUD_FMT_U16:
 317         if (endianness) {
 318             return SND_PCM_FORMAT_U16_BE;
 319         }
 320         else {
 321             return SND_PCM_FORMAT_U16_LE;
 322         }
 323
 324     case AUD_FMT_S32:
 325         if (endianness) {
 326             return SND_PCM_FORMAT_S32_BE;
 327         }
 328         else {
 329             return SND_PCM_FORMAT_S32_LE;
 330         }
 331
 332     case AUD_FMT_U32:
 333         if (endianness) {
 334             return SND_PCM_FORMAT_U32_BE;
 335         }
 336         else {
 337             return SND_PCM_FORMAT_U32_LE;
 338         }
 339
 340     default:
 341         dolog ("Internal logic error: Bad audio format %d\n", fmt);
 342 #ifdef DEBUG_AUDIO
 343         abort ();
 344 #endif
 345         return SND_PCM_FORMAT_U8;
 346     }
 347 }
 348
 349 static int alsa_to_audfmt (snd_pcm_format_t alsafmt, audfmt_e *fmt,
 350                            int *endianness)
 351 {
 352     switch (alsafmt) {
 353     case SND_PCM_FORMAT_S8:
 354         *endianness = 0;
 355         *fmt = AUD_FMT_S8;
 356         break;
 357
 358     case SND_PCM_FORMAT_U8:
 359         *endianness = 0;
 360         *fmt = AUD_FMT_U8;
 361         break;
 362
 363     case SND_PCM_FORMAT_S16_LE:
 364         *endianness = 0;
 365         *fmt = AUD_FMT_S16;
 366         break;
 367
 368     case SND_PCM_FORMAT_U16_LE:
 369         *endianness = 0;
 370         *fmt = AUD_FMT_U16;
 371         break;
 372
 373     case SND_PCM_FORMAT_S16_BE:
 374         *endianness = 1;
 375         *fmt = AUD_FMT_S16;
 376         break;
 377
 378     case SND_PCM_FORMAT_U16_BE:
 379         *endianness = 1;
 380         *fmt = AUD_FMT_U16;
 381         break;
 382
 383     case SND_PCM_FORMAT_S32_LE:
 384         *endianness = 0;
 385         *fmt = AUD_FMT_S32;
 386         break;
 387
 388     case SND_PCM_FORMAT_U32_LE:
 389         *endianness = 0;
 390         *fmt = AUD_FMT_U32;
 391         break;
 392
 393     case SND_PCM_FORMAT_S32_BE:
 394         *endianness = 1;
 395         *fmt = AUD_FMT_S32;
 396         break;
 397
 398     case SND_PCM_FORMAT_U32_BE:
 399         *endianness = 1;
 400         *fmt = AUD_FMT_U32;
 401         break;
 402
 403     default:
 404         dolog ("Unrecognized audio format %d\n", alsafmt);
 405         return -1;
 406     }
 407
 408     return 0;
 409 }
 410
 411 static void alsa_dump_info (struct alsa_params_req *req,
 412                             struct alsa_params_obt *obt,
 413                             snd_pcm_format_t obtfmt)
 414 {
 415     dolog ("parameter | requested value | obtained value\n");
 416     dolog ("format    |      %10d |     %10d\n", req->fmt, obtfmt);
 417     dolog ("channels  |      %10d |     %10d\n",
 418            req->nchannels, obt->nchannels);
 419     dolog ("frequency |      %10d |     %10d\n", req->freq, obt->freq);
 420     dolog ("============================================\n");
 421     dolog ("requested: buffer size %d period size %d\n",
 422            req->buffer_size, req->period_size);
 423     dolog ("obtained: samples %ld\n", obt->samples);
 424 }
 425
 426 static void alsa_set_threshold (snd_pcm_t *handle, snd_pcm_uframes_t threshold)
 427 {
 428     int err;
 429     snd_pcm_sw_params_t *sw_params;
 430
 431     snd_pcm_sw_params_alloca (&sw_params);
 432
 433     err = snd_pcm_sw_params_current (handle, sw_params);
 434     if (err < 0) {
 435         dolog ("Could not fully initialize DAC\n");
 436         alsa_logerr (err, "Failed to get current software parameters\n");
 437         return;
 438     }
 439
 440     err = snd_pcm_sw_params_set_start_threshold (handle, sw_params, threshold);
 441     if (err < 0) {
 442         dolog ("Could not fully initialize DAC\n");
 443         alsa_logerr (err, "Failed to set software threshold to %ld\n",
 444                      threshold);
 445         return;
 446     }
 447
 448     err = snd_pcm_sw_params (handle, sw_params);
 449     if (err < 0) {
 450         dolog ("Could not fully initialize DAC\n");
 451         alsa_logerr (err, "Failed to set software parameters\n");
 452         return;
 453     }
 454 }
 455
 456 static int alsa_open (int in, struct alsa_params_req *req,
 457                       struct alsa_params_obt *obt, snd_pcm_t **handlep,
 458                       ALSAConf *conf)
 459 {
 460     snd_pcm_t *handle;
 461     snd_pcm_hw_params_t *hw_params;
 462     int err;
 463     int size_in_usec;
 464     unsigned int freq, nchannels;
 465     const char *pcm_name = in ? conf->pcm_name_in : conf->pcm_name_out;
 466     snd_pcm_uframes_t obt_buffer_size;
 467     const char *typ = in ? "ADC" : "DAC";
 468     snd_pcm_format_t obtfmt;
 469
 470     freq = req->freq;
 471     nchannels = req->nchannels;
 472     size_in_usec = req->size_in_usec;
 473
 474     snd_pcm_hw_params_alloca (&hw_params);
 475
 476     err = snd_pcm_open (
 477         &handle,
 478         pcm_name,
 479         in ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK,
 480         SND_PCM_NONBLOCK
 481         );
 482     if (err < 0) {
 483         alsa_logerr2 (err, typ, "Failed to open `%s':\n", pcm_name);
 484         return -1;
 485     }
 486
 487     err = snd_pcm_hw_params_any (handle, hw_params);
 488     if (err < 0) {
 489         alsa_logerr2 (err, typ, "Failed to initialize hardware parameters\n");
 490         goto err;
 491     }
 492
 493     err = snd_pcm_hw_params_set_access (
 494         handle,
 495         hw_params,
 496         SND_PCM_ACCESS_RW_INTERLEAVED
 497         );
 498     if (err < 0) {
 499         alsa_logerr2 (err, typ, "Failed to set access type\n");
 500         goto err;
 501     }
 502
 503     err = snd_pcm_hw_params_set_format (handle, hw_params, req->fmt);
 504     if (err < 0) {
 505         alsa_logerr2 (err, typ, "Failed to set format %d\n", req->fmt);
 506     }
 507
 508     err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0);
 509     if (err < 0) {
 510         alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq);
 511         goto err;
 512     }
 513
 514     err = snd_pcm_hw_params_set_channels_near (
 515         handle,
 516         hw_params,
 517         &nchannels
 518         );
 519     if (err < 0) {
 520         alsa_logerr2 (err, typ, "Failed to set number of channels %d\n",
 521                       req->nchannels);
 522         goto err;
 523     }
 524
 525     if (nchannels != 1 && nchannels != 2) {
 526         alsa_logerr2 (err, typ,
 527                       "Can not handle obtained number of channels %d\n",
 528                       nchannels);
 529         goto err;
 530     }
 531
 532     if (req->buffer_size) {
 533         unsigned long obt;
 534
 535         if (size_in_usec) {
 536             int dir = 0;
 537             unsigned int btime = req->buffer_size;
 538
 539             err = snd_pcm_hw_params_set_buffer_time_near (
 540                 handle,
 541                 hw_params,
 542                 &btime,
 543                 &dir
 544                 );
 545             obt = btime;
 546         }
 547         else {
 548             snd_pcm_uframes_t bsize = req->buffer_size;
 549
 550             err = snd_pcm_hw_params_set_buffer_size_near (
 551                 handle,
 552                 hw_params,
 553                 &bsize
 554                 );
 555             obt = bsize;
 556         }
 557         if (err < 0) {
 558             alsa_logerr2 (err, typ, "Failed to set buffer %s to %d\n",
 559                           size_in_usec ? "time" : "size", req->buffer_size);
 560             goto err;
 561         }
 562
 563         if ((req->override_mask & 2) && (obt - req->buffer_size))
 564             dolog ("Requested buffer %s %u was rejected, using %lu\n",
 565                    size_in_usec ? "time" : "size", req->buffer_size, obt);
 566     }
 567
 568     if (req->period_size) {
 569         unsigned long obt;
 570
 571         if (size_in_usec) {
 572             int dir = 0;
 573             unsigned int ptime = req->period_size;
 574
 575             err = snd_pcm_hw_params_set_period_time_near (
 576                 handle,
 577                 hw_params,
 578                 &ptime,
 579                 &dir
 580                 );
 581             obt = ptime;
 582         }
 583         else {
 584             int dir = 0;
 585             snd_pcm_uframes_t psize = req->period_size;
 586
 587             err = snd_pcm_hw_params_set_period_size_near (
 588                 handle,
 589                 hw_params,
 590                 &psize,
 591                 &dir
 592                 );
 593             obt = psize;
 594         }
 595
 596         if (err < 0) {
 597             alsa_logerr2 (err, typ, "Failed to set period %s to %d\n",
 598                           size_in_usec ? "time" : "size", req->period_size);
 599             goto err;
 600         }
 601
 602         if (((req->override_mask & 1) && (obt - req->period_size)))
 603             dolog ("Requested period %s %u was rejected, using %lu\n",
 604                    size_in_usec ? "time" : "size", req->period_size, obt);
 605     }
 606
 607     err = snd_pcm_hw_params (handle, hw_params);
 608     if (err < 0) {
 609         alsa_logerr2 (err, typ, "Failed to apply audio parameters\n");
 610         goto err;
 611     }
 612
 613     err = snd_pcm_hw_params_get_buffer_size (hw_params, &obt_buffer_size);
 614     if (err < 0) {
 615         alsa_logerr2 (err, typ, "Failed to get buffer size\n");
 616         goto err;
 617     }
 618
 619     err = snd_pcm_hw_params_get_format (hw_params, &obtfmt);
 620     if (err < 0) {
 621         alsa_logerr2 (err, typ, "Failed to get format\n");
 622         goto err;
 623     }
 624
 625     if (alsa_to_audfmt (obtfmt, &obt->fmt, &obt->endianness)) {
 626         dolog ("Invalid format was returned %d\n", obtfmt);
 627         goto err;
 628     }
 629
 630     err = snd_pcm_prepare (handle);
 631     if (err < 0) {
 632         alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle);
 633         goto err;
 634     }
 635
 636     if (!in && conf->threshold) {
 637         snd_pcm_uframes_t threshold;
 638         int bytes_per_sec;
 639
 640         bytes_per_sec = freq << (nchannels == 2);
 641
 642         switch (obt->fmt) {
 643         case AUD_FMT_S8:
 644         case AUD_FMT_U8:
 645             break;
 646
 647         case AUD_FMT_S16:
 648         case AUD_FMT_U16:
 649             bytes_per_sec <<= 1;
 650             break;
 651
 652         case AUD_FMT_S32:
 653         case AUD_FMT_U32:
 654             bytes_per_sec <<= 2;
 655             break;
 656         }
 657
 658         threshold = (conf->threshold * bytes_per_sec) / 1000;
 659         alsa_set_threshold (handle, threshold);
 660     }
 661
 662     obt->nchannels = nchannels;
 663     obt->freq = freq;
 664     obt->samples = obt_buffer_size;
 665
 666     *handlep = handle;
 667
 668     if (obtfmt != req->fmt ||
 669          obt->nchannels != req->nchannels ||
 670          obt->freq != req->freq) {
 671         dolog ("Audio parameters for %s\n", typ);
 672         alsa_dump_info (req, obt, obtfmt);
 673     }
 674
 675 #ifdef DEBUG
 676     alsa_dump_info (req, obt, obtfmt);
 677 #endif
 678     return 0;
 679
 680  err:
 681     alsa_anal_close1 (&handle);
 682     return -1;
 683 }
 684
 685 static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle)
 686 {
 687     snd_pcm_sframes_t avail;
 688
 689     avail = snd_pcm_avail_update (handle);
 690     if (avail < 0) {
 691         if (avail == -EPIPE) {
 692             if (!alsa_recover (handle)) {
 693                 avail = snd_pcm_avail_update (handle);
 694             }
 695         }
 696
 697         if (avail < 0) {
 698             alsa_logerr (avail,
 699                          "Could not obtain number of available frames\n");
 700             return -1;
 701         }
 702     }
 703
 704     return avail;
 705 }
 706
 707 static void alsa_write_pending (ALSAVoiceOut *alsa)
 708 {
 709     HWVoiceOut *hw = &alsa->hw;
 710
 711     while (alsa->pending) {
 712         int left_till_end_samples = hw->samples - alsa->wpos;
 713         int len = audio_MIN (alsa->pending, left_till_end_samples);
 714         char *src = advance (alsa->pcm_buf, alsa->wpos << hw->info.shift);
 715
 716         while (len) {
 717             snd_pcm_sframes_t written;
 718
 719             written = snd_pcm_writei (alsa->handle, src, len);
 720
 721             if (written <= 0) {
 722                 switch (written) {
 723                 case 0:
 724                     trace_alsa_wrote_zero(len);
 725                     return;
 726
 727                 case -EPIPE:
 728                     if (alsa_recover (alsa->handle)) {
 729                         alsa_logerr (written, "Failed to write %d frames\n",
 730                                      len);
 731                         return;
 732                     }
 733                     trace_alsa_xrun_out();
 734                     continue;
 735
 736                 case -ESTRPIPE:
 737                     /* stream is suspended and waiting for an
 738                        application recovery */
 739                     if (alsa_resume (alsa->handle)) {
 740                         alsa_logerr (written, "Failed to write %d frames\n",
 741                                      len);
 742                         return;
 743                     }
 744                     trace_alsa_resume_out();
 745                     continue;
 746
 747                 case -EAGAIN:
 748                     return;
 749
 750                 default:
 751                     alsa_logerr (written, "Failed to write %d frames from %p\n",
 752                                  len, src);
 753                     return;
 754                 }
 755             }
 756
 757             alsa->wpos = (alsa->wpos + written) % hw->samples;
 758             alsa->pending -= written;
 759             len -= written;
 760         }
 761     }
 762 }
 763
 764 static int alsa_run_out (HWVoiceOut *hw, int live)
 765 {
 766     ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
 767     int decr;
 768     snd_pcm_sframes_t avail;
 769
 770     avail = alsa_get_avail (alsa->handle);
 771     if (avail < 0) {
 772         dolog ("Could not get number of available playback frames\n");
 773         return 0;
 774     }
 775
 776     decr = audio_MIN (live, avail);
 777     decr = audio_pcm_hw_clip_out (hw, alsa->pcm_buf, decr, alsa->pending);
 778     alsa->pending += decr;
 779     alsa_write_pending (alsa);
 780     return decr;
 781 }
 782
 783 static void alsa_fini_out (HWVoiceOut *hw)
 784 {
 785     ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
 786
 787     ldebug ("alsa_fini\n");
 788     alsa_anal_close (&alsa->handle, &alsa->pollhlp);
 789
 790     g_free(alsa->pcm_buf);
 791     alsa->pcm_buf = NULL;
 792 }
 793
 794 static int alsa_init_out(HWVoiceOut *hw, struct audsettings *as,
 795                          void *drv_opaque)
 796 {
 797     ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
 798     struct alsa_params_req req;
 799     struct alsa_params_obt obt;
 800     snd_pcm_t *handle;
 801     struct audsettings obt_as;
 802     ALSAConf *conf = drv_opaque;
 803
 804     req.fmt = aud_to_alsafmt (as->fmt, as->endianness);
 805     req.freq = as->freq;
 806     req.nchannels = as->nchannels;
 807     req.period_size = conf->period_size_out;
 808     req.buffer_size = conf->buffer_size_out;
 809     req.size_in_usec = conf->size_in_usec_out;
 810     req.override_mask =
 811         (conf->period_size_out_overridden ? 1 : 0) |
 812         (conf->buffer_size_out_overridden ? 2 : 0);
 813
 814     if (alsa_open (0, &req, &obt, &handle, conf)) {
 815         return -1;
 816     }
 817
 818     obt_as.freq = obt.freq;
 819     obt_as.nchannels = obt.nchannels;
 820     obt_as.fmt = obt.fmt;
 821     obt_as.endianness = obt.endianness;
 822
 823     audio_pcm_init_info (&hw->info, &obt_as);
 824     hw->samples = obt.samples;
 825
 826     alsa->pcm_buf = audio_calloc(__func__, obt.samples, 1 << hw->info.shift);
 827     if (!alsa->pcm_buf) {
 828         dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n",
 829                hw->samples, 1 << hw->info.shift);
 830         alsa_anal_close1 (&handle);
 831         return -1;
 832     }
 833
 834     alsa->handle = handle;
 835     alsa->pollhlp.conf = conf;
 836     return 0;
 837 }
 838
 839 #define VOICE_CTL_PAUSE 0
 840 #define VOICE_CTL_PREPARE 1
 841 #define VOICE_CTL_START 2
 842
 843 static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int ctl)
 844 {
 845     int err;
 846
 847     if (ctl == VOICE_CTL_PAUSE) {
 848         err = snd_pcm_drop (handle);
 849         if (err < 0) {
 850             alsa_logerr (err, "Could not stop %s\n", typ);
 851             return -1;
 852         }
 853     }
 854     else {
 855         err = snd_pcm_prepare (handle);
 856         if (err < 0) {
 857             alsa_logerr (err, "Could not prepare handle for %s\n", typ);
 858             return -1;
 859         }
 860         if (ctl == VOICE_CTL_START) {
 861             err = snd_pcm_start(handle);
 862             if (err < 0) {
 863                 alsa_logerr (err, "Could not start handle for %s\n", typ);
 864                 return -1;
 865             }
 866         }
 867     }
 868
 869     return 0;
 870 }
 871
 872 static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)
 873 {
 874     ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
 875
 876     switch (cmd) {
 877     case VOICE_ENABLE:
 878         {
 879             va_list ap;
 880             int poll_mode;
 881
 882             va_start (ap, cmd);
 883             poll_mode = va_arg (ap, int);
 884             va_end (ap);
 885
 886             ldebug ("enabling voice\n");
 887             if (poll_mode && alsa_poll_out (hw)) {
 888                 poll_mode = 0;
 889             }
 890             hw->poll_mode = poll_mode;
 891             return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PREPARE);
 892         }
 893
 894     case VOICE_DISABLE:
 895         ldebug ("disabling voice\n");
 896         if (hw->poll_mode) {
 897             hw->poll_mode = 0;
 898             alsa_fini_poll (&alsa->pollhlp);
 899         }
 900         return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PAUSE);
 901     }
 902
 903     return -1;
 904 }
 905
 906 static int alsa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
 907 {
 908     ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
 909     struct alsa_params_req req;
 910     struct alsa_params_obt obt;
 911     snd_pcm_t *handle;
 912     struct audsettings obt_as;
 913     ALSAConf *conf = drv_opaque;
 914
 915     req.fmt = aud_to_alsafmt (as->fmt, as->endianness);
 916     req.freq = as->freq;
 917     req.nchannels = as->nchannels;
 918     req.period_size = conf->period_size_in;
 919     req.buffer_size = conf->buffer_size_in;
 920     req.size_in_usec = conf->size_in_usec_in;
 921     req.override_mask =
 922         (conf->period_size_in_overridden ? 1 : 0) |
 923         (conf->buffer_size_in_overridden ? 2 : 0);
 924
 925     if (alsa_open (1, &req, &obt, &handle, conf)) {
 926         return -1;
 927     }
 928
 929     obt_as.freq = obt.freq;
 930     obt_as.nchannels = obt.nchannels;
 931     obt_as.fmt = obt.fmt;
 932     obt_as.endianness = obt.endianness;
 933
 934     audio_pcm_init_info (&hw->info, &obt_as);
 935     hw->samples = obt.samples;
 936
 937     alsa->pcm_buf = audio_calloc(__func__, hw->samples, 1 << hw->info.shift);
 938     if (!alsa->pcm_buf) {
 939         dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
 940                hw->samples, 1 << hw->info.shift);
 941         alsa_anal_close1 (&handle);
 942         return -1;
 943     }
 944
 945     alsa->handle = handle;
 946     alsa->pollhlp.conf = conf;
 947     return 0;
 948 }
 949
 950 static void alsa_fini_in (HWVoiceIn *hw)
 951 {
 952     ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
 953
 954     alsa_anal_close (&alsa->handle, &alsa->pollhlp);
 955
 956     g_free(alsa->pcm_buf);
 957     alsa->pcm_buf = NULL;
 958 }
 959
 960 static int alsa_run_in (HWVoiceIn *hw)
 961 {
 962     ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
 963     int hwshift = hw->info.shift;
 964     int i;
 965     int live = audio_pcm_hw_get_live_in (hw);
 966     int dead = hw->samples - live;
 967     int decr;
 968     struct {
 969         int add;
 970         int len;
 971     } bufs[2] = {
 972         { .add = hw->wpos, .len = 0 },
 973         { .add = 0,        .len = 0 }
 974     };
 975     snd_pcm_sframes_t avail;
 976     snd_pcm_uframes_t read_samples = 0;
 977
 978     if (!dead) {
 979         return 0;
 980     }
 981
 982     avail = alsa_get_avail (alsa->handle);
 983     if (avail < 0) {
 984         dolog ("Could not get number of captured frames\n");
 985         return 0;
 986     }
 987
 988     if (!avail) {
 989         snd_pcm_state_t state;
 990
 991         state = snd_pcm_state (alsa->handle);
 992         switch (state) {
 993         case SND_PCM_STATE_PREPARED:
 994             avail = hw->samples;
 995             break;
 996         case SND_PCM_STATE_SUSPENDED:
 997             /* stream is suspended and waiting for an application recovery */
 998             if (alsa_resume (alsa->handle)) {
 999                 dolog ("Failed to resume suspended input stream\n");
1000                 return 0;
1001             }
1002             trace_alsa_resume_in();
1003             break;
1004         default:
1005             trace_alsa_no_frames(state);
1006             return 0;
1007         }
1008     }
1009
1010     decr = audio_MIN (dead, avail);
1011     if (!decr) {
1012         return 0;
1013     }
1014
1015     if (hw->wpos + decr > hw->samples) {
1016         bufs[0].len = (hw->samples - hw->wpos);
1017         bufs[1].len = (decr - (hw->samples - hw->wpos));
1018     }
1019     else {
1020         bufs[0].len = decr;
1021     }
1022
1023     for (i = 0; i < 2; ++i) {
1024         void *src;
1025         struct st_sample *dst;
1026         snd_pcm_sframes_t nread;
1027         snd_pcm_uframes_t len;
1028
1029         len = bufs[i].len;
1030
1031         src = advance (alsa->pcm_buf, bufs[i].add << hwshift);
1032         dst = hw->conv_buf + bufs[i].add;
1033
1034         while (len) {
1035             nread = snd_pcm_readi (alsa->handle, src, len);
1036
1037             if (nread <= 0) {
1038                 switch (nread) {
1039                 case 0:
1040                     trace_alsa_read_zero(len);
1041                     goto exit;
1042
1043                 case -EPIPE:
1044                     if (alsa_recover (alsa->handle)) {
1045                         alsa_logerr (nread, "Failed to read %ld frames\n", len);
1046                         goto exit;
1047                     }
1048                     trace_alsa_xrun_in();
1049                     continue;
1050
1051                 case -EAGAIN:
1052                     goto exit;
1053
1054                 default:
1055                     alsa_logerr (
1056                         nread,
1057                         "Failed to read %ld frames from %p\n",
1058                         len,
1059                         src
1060                         );
1061                     goto exit;
1062                 }
1063             }
1064
1065             hw->conv (dst, src, nread);
1066
1067             src = advance (src, nread << hwshift);
1068             dst += nread;
1069
1070             read_samples += nread;
1071             len -= nread;
1072         }
1073     }
1074
1075  exit:
1076     hw->wpos = (hw->wpos + read_samples) % hw->samples;
1077     return read_samples;
1078 }
1079
1080 static int alsa_read (SWVoiceIn *sw, void *buf, int size)
1081 {
1082     return audio_pcm_sw_read (sw, buf, size);
1083 }
1084
1085 static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...)
1086 {
1087     ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
1088
1089     switch (cmd) {
1090     case VOICE_ENABLE:
1091         {
1092             va_list ap;
1093             int poll_mode;
1094
1095             va_start (ap, cmd);
1096             poll_mode = va_arg (ap, int);
1097             va_end (ap);
1098
1099             ldebug ("enabling voice\n");
1100             if (poll_mode && alsa_poll_in (hw)) {
1101                 poll_mode = 0;
1102             }
1103             hw->poll_mode = poll_mode;
1104
1105             return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_START);
1106         }
1107
1108     case VOICE_DISABLE:
1109         ldebug ("disabling voice\n");
1110         if (hw->poll_mode) {
1111             hw->poll_mode = 0;
1112             alsa_fini_poll (&alsa->pollhlp);
1113         }
1114         return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_PAUSE);
1115     }
1116
1117     return -1;
1118 }
1119
1120 static ALSAConf glob_conf = {
1121     .buffer_size_out = 4096,
1122     .period_size_out = 1024,
1123     .pcm_name_out = "default",
1124     .pcm_name_in = "default",
1125 };
1126
1127 static void *alsa_audio_init (void)
1128 {
1129     ALSAConf *conf = g_malloc(sizeof(ALSAConf));
1130     *conf = glob_conf;
1131     return conf;
1132 }
1133
1134 static void alsa_audio_fini (void *opaque)
1135 {
1136     g_free(opaque);
1137 }
1138
1139 static struct audio_option alsa_options[] = {
1140     {
1141         .name        = "DAC_SIZE_IN_USEC",
1142         .tag         = AUD_OPT_BOOL,
1143         .valp        = &glob_conf.size_in_usec_out,
1144         .descr       = "DAC period/buffer size in microseconds (otherwise in frames)"
1145     },
1146     {
1147         .name        = "DAC_PERIOD_SIZE",
1148         .tag         = AUD_OPT_INT,
1149         .valp        = &glob_conf.period_size_out,
1150         .descr       = "DAC period size (0 to go with system default)",
1151         .overriddenp = &glob_conf.period_size_out_overridden
1152     },
1153     {
1154         .name        = "DAC_BUFFER_SIZE",
1155         .tag         = AUD_OPT_INT,
1156         .valp        = &glob_conf.buffer_size_out,
1157         .descr       = "DAC buffer size (0 to go with system default)",
1158         .overriddenp = &glob_conf.buffer_size_out_overridden
1159     },
1160     {
1161         .name        = "ADC_SIZE_IN_USEC",
1162         .tag         = AUD_OPT_BOOL,
1163         .valp        = &glob_conf.size_in_usec_in,
1164         .descr       =
1165         "ADC period/buffer size in microseconds (otherwise in frames)"
1166     },
1167     {
1168         .name        = "ADC_PERIOD_SIZE",
1169         .tag         = AUD_OPT_INT,
1170         .valp        = &glob_conf.period_size_in,
1171         .descr       = "ADC period size (0 to go with system default)",
1172         .overriddenp = &glob_conf.period_size_in_overridden
1173     },
1174     {
1175         .name        = "ADC_BUFFER_SIZE",
1176         .tag         = AUD_OPT_INT,
1177         .valp        = &glob_conf.buffer_size_in,
1178         .descr       = "ADC buffer size (0 to go with system default)",
1179         .overriddenp = &glob_conf.buffer_size_in_overridden
1180     },
1181     {
1182         .name        = "THRESHOLD",
1183         .tag         = AUD_OPT_INT,
1184         .valp        = &glob_conf.threshold,
1185         .descr       = "(undocumented)"
1186     },
1187     {
1188         .name        = "DAC_DEV",
1189         .tag         = AUD_OPT_STR,
1190         .valp        = &glob_conf.pcm_name_out,
1191         .descr       = "DAC device name (for instance dmix)"
1192     },
1193     {
1194         .name        = "ADC_DEV",
1195         .tag         = AUD_OPT_STR,
1196         .valp        = &glob_conf.pcm_name_in,
1197         .descr       = "ADC device name"
1198     },
1199     { /* End of list */ }
1200 };
1201
1202 static struct audio_pcm_ops alsa_pcm_ops = {
1203     .init_out = alsa_init_out,
1204     .fini_out = alsa_fini_out,
1205     .run_out  = alsa_run_out,
1206     .write    = alsa_write,
1207     .ctl_out  = alsa_ctl_out,
1208
1209     .init_in  = alsa_init_in,
1210     .fini_in  = alsa_fini_in,
1211     .run_in   = alsa_run_in,
1212     .read     = alsa_read,
1213     .ctl_in   = alsa_ctl_in,
1214 };
1215
1216 static struct audio_driver alsa_audio_driver = {
1217     .name           = "alsa",
1218     .descr          = "ALSA http://www.alsa-project.org",
1219     .options        = alsa_options,
1220     .init           = alsa_audio_init,
1221     .fini           = alsa_audio_fini,
1222     .pcm_ops        = &alsa_pcm_ops,
1223     .can_be_default = 1,
1224     .max_voices_out = INT_MAX,
1225     .max_voices_in  = INT_MAX,
1226     .voice_size_out = sizeof (ALSAVoiceOut),
1227     .voice_size_in  = sizeof (ALSAVoiceIn)
1228 };
1229
1230 static void register_audio_alsa(void)
1231 {
1232     audio_driver_register(&alsa_audio_driver);
1233 }
1234 type_init(register_audio_alsa);