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