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 "audio.h"
  27
  28 #define AUDIO_CAP "alsa"
  29 #include "audio_int.h"
  30
  31 typedef struct ALSAVoiceOut {
  32     HWVoiceOut hw;
  33     void *pcm_buf;
  34     snd_pcm_t *handle;
  35 } ALSAVoiceOut;
  36
  37 typedef struct ALSAVoiceIn {
  38     HWVoiceIn hw;
  39     snd_pcm_t *handle;
  40     void *pcm_buf;
  41 } ALSAVoiceIn;
  42
  43 static struct {
  44     int size_in_usec_in;
  45     int size_in_usec_out;
  46     const char *pcm_name_in;
  47     const char *pcm_name_out;
  48     unsigned int buffer_size_in;
  49     unsigned int period_size_in;
  50     unsigned int buffer_size_out;
  51     unsigned int period_size_out;
  52     unsigned int threshold;
  53
  54     int buffer_size_in_overridden;
  55     int period_size_in_overridden;
  56
  57     int buffer_size_out_overridden;
  58     int period_size_out_overridden;
  59     int verbose;
  60 } conf = {
  61     .pcm_name_out = "default",
  62     .pcm_name_in = "default",
  63 };
  64
  65 struct alsa_params_req {
  66     int freq;
  67     snd_pcm_format_t fmt;
  68     int nchannels;
  69     int size_in_usec;
  70     unsigned int buffer_size;
  71     unsigned int period_size;
  72 };
  73
  74 struct alsa_params_obt {
  75     int freq;
  76     audfmt_e fmt;
  77     int endianness;
  78     int nchannels;
  79     snd_pcm_uframes_t samples;
  80 };
  81
  82 static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...)
  83 {
  84     va_list ap;
  85
  86     va_start (ap, fmt);
  87     AUD_vlog (AUDIO_CAP, fmt, ap);
  88     va_end (ap);
  89
  90     AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
  91 }
  92
  93 static void GCC_FMT_ATTR (3, 4) alsa_logerr2 (
  94     int err,
  95     const char *typ,
  96     const char *fmt,
  97     ...
  98     )
  99 {
 100     va_list ap;
 101
 102     AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
 103
 104     va_start (ap, fmt);
 105     AUD_vlog (AUDIO_CAP, fmt, ap);
 106     va_end (ap);
 107
 108     AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
 109 }
 110
 111 static void alsa_anal_close (snd_pcm_t **handlep)
 112 {
 113     int err = snd_pcm_close (*handlep);
 114     if (err) {
 115         alsa_logerr (err, "Failed to close PCM handle %p\n", *handlep);
 116     }
 117     *handlep = NULL;
 118 }
 119
 120 static int alsa_write (SWVoiceOut *sw, void *buf, int len)
 121 {
 122     return audio_pcm_sw_write (sw, buf, len);
 123 }
 124
 125 static snd_pcm_format_t aud_to_alsafmt (audfmt_e fmt)
 126 {
 127     switch (fmt) {
 128     case AUD_FMT_S8:
 129         return SND_PCM_FORMAT_S8;
 130
 131     case AUD_FMT_U8:
 132         return SND_PCM_FORMAT_U8;
 133
 134     case AUD_FMT_S16:
 135         return SND_PCM_FORMAT_S16_LE;
 136
 137     case AUD_FMT_U16:
 138         return SND_PCM_FORMAT_U16_LE;
 139
 140     case AUD_FMT_S32:
 141         return SND_PCM_FORMAT_S32_LE;
 142
 143     case AUD_FMT_U32:
 144         return SND_PCM_FORMAT_U32_LE;
 145
 146     default:
 147         dolog ("Internal logic error: Bad audio format %d\n", fmt);
 148 #ifdef DEBUG_AUDIO
 149         abort ();
 150 #endif
 151         return SND_PCM_FORMAT_U8;
 152     }
 153 }
 154
 155 static int alsa_to_audfmt (snd_pcm_format_t alsafmt, audfmt_e *fmt,
 156                            int *endianness)
 157 {
 158     switch (alsafmt) {
 159     case SND_PCM_FORMAT_S8:
 160         *endianness = 0;
 161         *fmt = AUD_FMT_S8;
 162         break;
 163
 164     case SND_PCM_FORMAT_U8:
 165         *endianness = 0;
 166         *fmt = AUD_FMT_U8;
 167         break;
 168
 169     case SND_PCM_FORMAT_S16_LE:
 170         *endianness = 0;
 171         *fmt = AUD_FMT_S16;
 172         break;
 173
 174     case SND_PCM_FORMAT_U16_LE:
 175         *endianness = 0;
 176         *fmt = AUD_FMT_U16;
 177         break;
 178
 179     case SND_PCM_FORMAT_S16_BE:
 180         *endianness = 1;
 181         *fmt = AUD_FMT_S16;
 182         break;
 183
 184     case SND_PCM_FORMAT_U16_BE:
 185         *endianness = 1;
 186         *fmt = AUD_FMT_U16;
 187         break;
 188
 189     case SND_PCM_FORMAT_S32_LE:
 190         *endianness = 0;
 191         *fmt = AUD_FMT_S32;
 192         break;
 193
 194     case SND_PCM_FORMAT_U32_LE:
 195         *endianness = 0;
 196         *fmt = AUD_FMT_U32;
 197         break;
 198
 199     case SND_PCM_FORMAT_S32_BE:
 200         *endianness = 1;
 201         *fmt = AUD_FMT_S32;
 202         break;
 203
 204     case SND_PCM_FORMAT_U32_BE:
 205         *endianness = 1;
 206         *fmt = AUD_FMT_U32;
 207         break;
 208
 209     default:
 210         dolog ("Unrecognized audio format %d\n", alsafmt);
 211         return -1;
 212     }
 213
 214     return 0;
 215 }
 216
 217 static void alsa_dump_info (struct alsa_params_req *req,
 218                             struct alsa_params_obt *obt)
 219 {
 220     dolog ("parameter | requested value | obtained value\n");
 221     dolog ("format    |      %10d |     %10d\n", req->fmt, obt->fmt);
 222     dolog ("channels  |      %10d |     %10d\n",
 223            req->nchannels, obt->nchannels);
 224     dolog ("frequency |      %10d |     %10d\n", req->freq, obt->freq);
 225     dolog ("============================================\n");
 226     dolog ("requested: buffer size %d period size %d\n",
 227            req->buffer_size, req->period_size);
 228     dolog ("obtained: samples %ld\n", obt->samples);
 229 }
 230
 231 static void alsa_set_threshold (snd_pcm_t *handle, snd_pcm_uframes_t threshold)
 232 {
 233     int err;
 234     snd_pcm_sw_params_t *sw_params;
 235
 236     snd_pcm_sw_params_alloca (&sw_params);
 237
 238     err = snd_pcm_sw_params_current (handle, sw_params);
 239     if (err < 0) {
 240         dolog ("Could not fully initialize DAC\n");
 241         alsa_logerr (err, "Failed to get current software parameters\n");
 242         return;
 243     }
 244
 245     err = snd_pcm_sw_params_set_start_threshold (handle, sw_params, threshold);
 246     if (err < 0) {
 247         dolog ("Could not fully initialize DAC\n");
 248         alsa_logerr (err, "Failed to set software threshold to %ld\n",
 249                      threshold);
 250         return;
 251     }
 252
 253     err = snd_pcm_sw_params (handle, sw_params);
 254     if (err < 0) {
 255         dolog ("Could not fully initialize DAC\n");
 256         alsa_logerr (err, "Failed to set software parameters\n");
 257         return;
 258     }
 259 }
 260
 261 static int alsa_open (int in, struct alsa_params_req *req,
 262                       struct alsa_params_obt *obt, snd_pcm_t **handlep)
 263 {
 264     snd_pcm_t *handle;
 265     snd_pcm_hw_params_t *hw_params;
 266     int err;
 267     int size_in_usec;
 268     unsigned int freq, nchannels;
 269     const char *pcm_name = in ? conf.pcm_name_in : conf.pcm_name_out;
 270     snd_pcm_uframes_t obt_buffer_size;
 271     const char *typ = in ? "ADC" : "DAC";
 272     snd_pcm_format_t obtfmt;
 273
 274     freq = req->freq;
 275     nchannels = req->nchannels;
 276     size_in_usec = req->size_in_usec;
 277
 278     snd_pcm_hw_params_alloca (&hw_params);
 279
 280     err = snd_pcm_open (
 281         &handle,
 282         pcm_name,
 283         in ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK,
 284         SND_PCM_NONBLOCK
 285         );
 286     if (err < 0) {
 287         alsa_logerr2 (err, typ, "Failed to open `%s':\n", pcm_name);
 288         return -1;
 289     }
 290
 291     err = snd_pcm_hw_params_any (handle, hw_params);
 292     if (err < 0) {
 293         alsa_logerr2 (err, typ, "Failed to initialize hardware parameters\n");
 294         goto err;
 295     }
 296
 297     err = snd_pcm_hw_params_set_access (
 298         handle,
 299         hw_params,
 300         SND_PCM_ACCESS_RW_INTERLEAVED
 301         );
 302     if (err < 0) {
 303         alsa_logerr2 (err, typ, "Failed to set access type\n");
 304         goto err;
 305     }
 306
 307     err = snd_pcm_hw_params_set_format (handle, hw_params, req->fmt);
 308     if (err < 0 && conf.verbose) {
 309         alsa_logerr2 (err, typ, "Failed to set format %d\n", req->fmt);
 310     }
 311
 312     err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0);
 313     if (err < 0) {
 314         alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq);
 315         goto err;
 316     }
 317
 318     err = snd_pcm_hw_params_set_channels_near (
 319         handle,
 320         hw_params,
 321         &nchannels
 322         );
 323     if (err < 0) {
 324         alsa_logerr2 (err, typ, "Failed to set number of channels %d\n",
 325                       req->nchannels);
 326         goto err;
 327     }
 328
 329     if (nchannels != 1 && nchannels != 2) {
 330         alsa_logerr2 (err, typ,
 331                       "Can not handle obtained number of channels %d\n",
 332                       nchannels);
 333         goto err;
 334     }
 335
 336     if (req->buffer_size) {
 337         unsigned long obt;
 338
 339         if (size_in_usec) {
 340             int dir = 0;
 341             unsigned int btime = req->buffer_size;
 342
 343             err = snd_pcm_hw_params_set_buffer_time_near (
 344                 handle,
 345                 hw_params,
 346                 &btime,
 347                 &dir
 348                 );
 349             obt = btime;
 350         }
 351         else {
 352             snd_pcm_uframes_t bsize = req->buffer_size;
 353
 354             err = snd_pcm_hw_params_set_buffer_size_near (
 355                 handle,
 356                 hw_params,
 357                 &bsize
 358                 );
 359             obt = bsize;
 360         }
 361         if (err < 0) {
 362             alsa_logerr2 (err, typ, "Failed to set buffer %s to %d\n",
 363                           size_in_usec ? "time" : "size", req->buffer_size);
 364             goto err;
 365         }
 366
 367         if (obt - req->buffer_size)
 368             dolog ("Requested buffer %s %u was rejected, using %lu\n",
 369                    size_in_usec ? "time" : "size", req->buffer_size, obt);
 370     }
 371
 372     if (req->period_size) {
 373         unsigned long obt;
 374
 375         if (size_in_usec) {
 376             int dir = 0;
 377             unsigned int ptime = req->period_size;
 378
 379             err = snd_pcm_hw_params_set_period_time_near (
 380                 handle,
 381                 hw_params,
 382                 &ptime,
 383                 &dir
 384                 );
 385             obt = ptime;
 386         }
 387         else {
 388             int dir = 0;
 389             snd_pcm_uframes_t psize = req->period_size;
 390
 391             err = snd_pcm_hw_params_set_period_size_near (
 392                 handle,
 393                 hw_params,
 394                 &psize,
 395                 &dir
 396                 );
 397             obt = psize;
 398         }
 399
 400         if (err < 0) {
 401             alsa_logerr2 (err, typ, "Failed to set period %s to %d\n",
 402                           size_in_usec ? "time" : "size", req->period_size);
 403             goto err;
 404         }
 405
 406         if (obt - req->period_size)
 407             dolog ("Requested period %s %u was rejected, using %lu\n",
 408                    size_in_usec ? "time" : "size", req->period_size, obt);
 409     }
 410
 411     err = snd_pcm_hw_params (handle, hw_params);
 412     if (err < 0) {
 413         alsa_logerr2 (err, typ, "Failed to apply audio parameters\n");
 414         goto err;
 415     }
 416
 417     err = snd_pcm_hw_params_get_buffer_size (hw_params, &obt_buffer_size);
 418     if (err < 0) {
 419         alsa_logerr2 (err, typ, "Failed to get buffer size\n");
 420         goto err;
 421     }
 422
 423     err = snd_pcm_hw_params_get_format (hw_params, &obtfmt);
 424     if (err < 0) {
 425         alsa_logerr2 (err, typ, "Failed to get format\n");
 426         goto err;
 427     }
 428
 429     if (alsa_to_audfmt (obtfmt, &obt->fmt, &obt->endianness)) {
 430         dolog ("Invalid format was returned %d\n", obtfmt);
 431         goto err;
 432     }
 433
 434     err = snd_pcm_prepare (handle);
 435     if (err < 0) {
 436         alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle);
 437         goto err;
 438     }
 439
 440     if (!in && conf.threshold) {
 441         snd_pcm_uframes_t threshold;
 442         int bytes_per_sec;
 443
 444         bytes_per_sec = freq << (nchannels == 2);
 445
 446         switch (obt->fmt) {
 447         case AUD_FMT_S8:
 448         case AUD_FMT_U8:
 449             break;
 450
 451         case AUD_FMT_S16:
 452         case AUD_FMT_U16:
 453             bytes_per_sec <<= 1;
 454             break;
 455
 456         case AUD_FMT_S32:
 457         case AUD_FMT_U32:
 458             bytes_per_sec <<= 2;
 459             break;
 460         }
 461
 462         threshold = (conf.threshold * bytes_per_sec) / 1000;
 463         alsa_set_threshold (handle, threshold);
 464     }
 465
 466     obt->nchannels = nchannels;
 467     obt->freq = freq;
 468     obt->samples = obt_buffer_size;
 469
 470     *handlep = handle;
 471
 472     if (conf.verbose &&
 473         (obt->fmt != req->fmt ||
 474          obt->nchannels != req->nchannels ||
 475          obt->freq != req->freq)) {
 476         dolog ("Audio paramters for %s\n", typ);
 477         alsa_dump_info (req, obt);
 478     }
 479
 480 #ifdef DEBUG
 481     alsa_dump_info (req, obt);
 482 #endif
 483     return 0;
 484
 485  err:
 486     alsa_anal_close (&handle);
 487     return -1;
 488 }
 489
 490 static int alsa_recover (snd_pcm_t *handle)
 491 {
 492     int err = snd_pcm_prepare (handle);
 493     if (err < 0) {
 494         alsa_logerr (err, "Failed to prepare handle %p\n", handle);
 495         return -1;
 496     }
 497     return 0;
 498 }
 499
 500 static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle)
 501 {
 502     snd_pcm_sframes_t avail;
 503
 504     avail = snd_pcm_avail_update (handle);
 505     if (avail < 0) {
 506         if (avail == -EPIPE) {
 507             if (!alsa_recover (handle)) {
 508                 avail = snd_pcm_avail_update (handle);
 509             }
 510         }
 511
 512         if (avail < 0) {
 513             alsa_logerr (avail,
 514                          "Could not obtain number of available frames\n");
 515             return -1;
 516         }
 517     }
 518
 519     return avail;
 520 }
 521
 522 static int alsa_run_out (HWVoiceOut *hw)
 523 {
 524     ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
 525     int rpos, live, decr;
 526     int samples;
 527     uint8_t *dst;
 528     st_sample_t *src;
 529     snd_pcm_sframes_t avail;
 530
 531     live = audio_pcm_hw_get_live_out (hw);
 532     if (!live) {
 533         return 0;
 534     }
 535
 536     avail = alsa_get_avail (alsa->handle);
 537     if (avail < 0) {
 538         dolog ("Could not get number of available playback frames\n");
 539         return 0;
 540     }
 541
 542     decr = audio_MIN (live, avail);
 543     samples = decr;
 544     rpos = hw->rpos;
 545     while (samples) {
 546         int left_till_end_samples = hw->samples - rpos;
 547         int len = audio_MIN (samples, left_till_end_samples);
 548         snd_pcm_sframes_t written;
 549
 550         src = hw->mix_buf + rpos;
 551         dst = advance (alsa->pcm_buf, rpos << hw->info.shift);
 552
 553         hw->clip (dst, src, len);
 554
 555         while (len) {
 556             written = snd_pcm_writei (alsa->handle, dst, len);
 557
 558             if (written <= 0) {
 559                 switch (written) {
 560                 case 0:
 561                     if (conf.verbose) {
 562                         dolog ("Failed to write %d frames (wrote zero)\n", len);
 563                     }
 564                     goto exit;
 565
 566                 case -EPIPE:
 567                     if (alsa_recover (alsa->handle)) {
 568                         alsa_logerr (written, "Failed to write %d frames\n",
 569                                      len);
 570                         goto exit;
 571                     }
 572                     if (conf.verbose) {
 573                         dolog ("Recovering from playback xrun\n");
 574                     }
 575                     continue;
 576
 577                 case -EAGAIN:
 578                     goto exit;
 579
 580                 default:
 581                     alsa_logerr (written, "Failed to write %d frames to %p\n",
 582                                  len, dst);
 583                     goto exit;
 584                 }
 585             }
 586
 587             rpos = (rpos + written) % hw->samples;
 588             samples -= written;
 589             len -= written;
 590             dst = advance (dst, written << hw->info.shift);
 591             src += written;
 592         }
 593     }
 594
 595  exit:
 596     hw->rpos = rpos;
 597     return decr;
 598 }
 599
 600 static void alsa_fini_out (HWVoiceOut *hw)
 601 {
 602     ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
 603
 604     ldebug ("alsa_fini\n");
 605     alsa_anal_close (&alsa->handle);
 606
 607     if (alsa->pcm_buf) {
 608         qemu_free (alsa->pcm_buf);
 609         alsa->pcm_buf = NULL;
 610     }
 611 }
 612
 613 static int alsa_init_out (HWVoiceOut *hw, audsettings_t *as)
 614 {
 615     ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
 616     struct alsa_params_req req;
 617     struct alsa_params_obt obt;
 618     snd_pcm_t *handle;
 619     audsettings_t obt_as;
 620
 621     req.fmt = aud_to_alsafmt (as->fmt);
 622     req.freq = as->freq;
 623     req.nchannels = as->nchannels;
 624     req.period_size = conf.period_size_out;
 625     req.buffer_size = conf.buffer_size_out;
 626     req.size_in_usec = conf.size_in_usec_out;
 627
 628     if (alsa_open (0, &req, &obt, &handle)) {
 629         return -1;
 630     }
 631
 632     obt_as.freq = obt.freq;
 633     obt_as.nchannels = obt.nchannels;
 634     obt_as.fmt = obt.fmt;
 635     obt_as.endianness = obt.endianness;
 636
 637     audio_pcm_init_info (&hw->info, &obt_as);
 638     hw->samples = obt.samples;
 639
 640     alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift);
 641     if (!alsa->pcm_buf) {
 642         dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n",
 643                hw->samples, 1 << hw->info.shift);
 644         alsa_anal_close (&handle);
 645         return -1;
 646     }
 647
 648     alsa->handle = handle;
 649     return 0;
 650 }
 651
 652 static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int pause)
 653 {
 654     int err;
 655
 656     if (pause) {
 657         err = snd_pcm_drop (handle);
 658         if (err < 0) {
 659             alsa_logerr (err, "Could not stop %s\n", typ);
 660             return -1;
 661         }
 662     }
 663     else {
 664         err = snd_pcm_prepare (handle);
 665         if (err < 0) {
 666             alsa_logerr (err, "Could not prepare handle for %s\n", typ);
 667             return -1;
 668         }
 669     }
 670
 671     return 0;
 672 }
 673
 674 static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)
 675 {
 676     ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
 677
 678     switch (cmd) {
 679     case VOICE_ENABLE:
 680         ldebug ("enabling voice\n");
 681         return alsa_voice_ctl (alsa->handle, "playback", 0);
 682
 683     case VOICE_DISABLE:
 684         ldebug ("disabling voice\n");
 685         return alsa_voice_ctl (alsa->handle, "playback", 1);
 686     }
 687
 688     return -1;
 689 }
 690
 691 static int alsa_init_in (HWVoiceIn *hw, audsettings_t *as)
 692 {
 693     ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
 694     struct alsa_params_req req;
 695     struct alsa_params_obt obt;
 696     snd_pcm_t *handle;
 697     audsettings_t obt_as;
 698
 699     req.fmt = aud_to_alsafmt (as->fmt);
 700     req.freq = as->freq;
 701     req.nchannels = as->nchannels;
 702     req.period_size = conf.period_size_in;
 703     req.buffer_size = conf.buffer_size_in;
 704     req.size_in_usec = conf.size_in_usec_in;
 705
 706     if (alsa_open (1, &req, &obt, &handle)) {
 707         return -1;
 708     }
 709
 710     obt_as.freq = obt.freq;
 711     obt_as.nchannels = obt.nchannels;
 712     obt_as.fmt = obt.fmt;
 713     obt_as.endianness = obt.endianness;
 714
 715     audio_pcm_init_info (&hw->info, &obt_as);
 716     hw->samples = obt.samples;
 717
 718     alsa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
 719     if (!alsa->pcm_buf) {
 720         dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
 721                hw->samples, 1 << hw->info.shift);
 722         alsa_anal_close (&handle);
 723         return -1;
 724     }
 725
 726     alsa->handle = handle;
 727     return 0;
 728 }
 729
 730 static void alsa_fini_in (HWVoiceIn *hw)
 731 {
 732     ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
 733
 734     alsa_anal_close (&alsa->handle);
 735
 736     if (alsa->pcm_buf) {
 737         qemu_free (alsa->pcm_buf);
 738         alsa->pcm_buf = NULL;
 739     }
 740 }
 741
 742 static int alsa_run_in (HWVoiceIn *hw)
 743 {
 744     ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
 745     int hwshift = hw->info.shift;
 746     int i;
 747     int live = audio_pcm_hw_get_live_in (hw);
 748     int dead = hw->samples - live;
 749     int decr;
 750     struct {
 751         int add;
 752         int len;
 753     } bufs[2] = {
 754         { hw->wpos, 0 },
 755         { 0, 0 }
 756     };
 757     snd_pcm_sframes_t avail;
 758     snd_pcm_uframes_t read_samples = 0;
 759
 760     if (!dead) {
 761         return 0;
 762     }
 763
 764     avail = alsa_get_avail (alsa->handle);
 765     if (avail < 0) {
 766         dolog ("Could not get number of captured frames\n");
 767         return 0;
 768     }
 769
 770     if (!avail && (snd_pcm_state (alsa->handle) == SND_PCM_STATE_PREPARED)) {
 771         avail = hw->samples;
 772     }
 773
 774     decr = audio_MIN (dead, avail);
 775     if (!decr) {
 776         return 0;
 777     }
 778
 779     if (hw->wpos + decr > hw->samples) {
 780         bufs[0].len = (hw->samples - hw->wpos);
 781         bufs[1].len = (decr - (hw->samples - hw->wpos));
 782     }
 783     else {
 784         bufs[0].len = decr;
 785     }
 786
 787     for (i = 0; i < 2; ++i) {
 788         void *src;
 789         st_sample_t *dst;
 790         snd_pcm_sframes_t nread;
 791         snd_pcm_uframes_t len;
 792
 793         len = bufs[i].len;
 794
 795         src = advance (alsa->pcm_buf, bufs[i].add << hwshift);
 796         dst = hw->conv_buf + bufs[i].add;
 797
 798         while (len) {
 799             nread = snd_pcm_readi (alsa->handle, src, len);
 800
 801             if (nread <= 0) {
 802                 switch (nread) {
 803                 case 0:
 804                     if (conf.verbose) {
 805                         dolog ("Failed to read %ld frames (read zero)\n", len);
 806                     }
 807                     goto exit;
 808
 809                 case -EPIPE:
 810                     if (alsa_recover (alsa->handle)) {
 811                         alsa_logerr (nread, "Failed to read %ld frames\n", len);
 812                         goto exit;
 813                     }
 814                     if (conf.verbose) {
 815                         dolog ("Recovering from capture xrun\n");
 816                     }
 817                     continue;
 818
 819                 case -EAGAIN:
 820                     goto exit;
 821
 822                 default:
 823                     alsa_logerr (
 824                         nread,
 825                         "Failed to read %ld frames from %p\n",
 826                         len,
 827                         src
 828                         );
 829                     goto exit;
 830                 }
 831             }
 832
 833             hw->conv (dst, src, nread, &nominal_volume);
 834
 835             src = advance (src, nread << hwshift);
 836             dst += nread;
 837
 838             read_samples += nread;
 839             len -= nread;
 840         }
 841     }
 842
 843  exit:
 844     hw->wpos = (hw->wpos + read_samples) % hw->samples;
 845     return read_samples;
 846 }
 847
 848 static int alsa_read (SWVoiceIn *sw, void *buf, int size)
 849 {
 850     return audio_pcm_sw_read (sw, buf, size);
 851 }
 852
 853 static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...)
 854 {
 855     ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
 856
 857     switch (cmd) {
 858     case VOICE_ENABLE:
 859         ldebug ("enabling voice\n");
 860         return alsa_voice_ctl (alsa->handle, "capture", 0);
 861
 862     case VOICE_DISABLE:
 863         ldebug ("disabling voice\n");
 864         return alsa_voice_ctl (alsa->handle, "capture", 1);
 865     }
 866
 867     return -1;
 868 }
 869
 870 static void *alsa_audio_init (void)
 871 {
 872     return &conf;
 873 }
 874
 875 static void alsa_audio_fini (void *opaque)
 876 {
 877     (void) opaque;
 878 }
 879
 880 static struct audio_option alsa_options[] = {
 881     {"DAC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_out,
 882      "DAC period/buffer size in microseconds (otherwise in frames)", NULL, 0},
 883     {"DAC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_out,
 884      "DAC period size (0 to go with system default)",
 885      &conf.period_size_out_overridden, 0},
 886     {"DAC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_out,
 887      "DAC buffer size (0 to go with system default)",
 888      &conf.buffer_size_out_overridden, 0},
 889
 890     {"ADC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_in,
 891      "ADC period/buffer size in microseconds (otherwise in frames)", NULL, 0},
 892     {"ADC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_in,
 893      "ADC period size (0 to go with system default)",
 894      &conf.period_size_in_overridden, 0},
 895     {"ADC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_in,
 896      "ADC buffer size (0 to go with system default)",
 897      &conf.buffer_size_in_overridden, 0},
 898
 899     {"THRESHOLD", AUD_OPT_INT, &conf.threshold,
 900      "(undocumented)", NULL, 0},
 901
 902     {"DAC_DEV", AUD_OPT_STR, &conf.pcm_name_out,
 903      "DAC device name (for instance dmix)", NULL, 0},
 904
 905     {"ADC_DEV", AUD_OPT_STR, &conf.pcm_name_in,
 906      "ADC device name", NULL, 0},
 907
 908     {"VERBOSE", AUD_OPT_BOOL, &conf.verbose,
 909      "Behave in a more verbose way", NULL, 0},
 910
 911     {NULL, 0, NULL, NULL, NULL, 0}
 912 };
 913
 914 static struct audio_pcm_ops alsa_pcm_ops = {
 915     alsa_init_out,
 916     alsa_fini_out,
 917     alsa_run_out,
 918     alsa_write,
 919     alsa_ctl_out,
 920
 921     alsa_init_in,
 922     alsa_fini_in,
 923     alsa_run_in,
 924     alsa_read,
 925     alsa_ctl_in
 926 };
 927
 928 struct audio_driver alsa_audio_driver = {
 929     INIT_FIELD (name           = ) "alsa",
 930     INIT_FIELD (descr          = ) "ALSA http://www.alsa-project.org",
 931     INIT_FIELD (options        = ) alsa_options,
 932     INIT_FIELD (init           = ) alsa_audio_init,
 933     INIT_FIELD (fini           = ) alsa_audio_fini,
 934     INIT_FIELD (pcm_ops        = ) &alsa_pcm_ops,
 935     INIT_FIELD (can_be_default = ) 1,
 936     INIT_FIELD (max_voices_out = ) INT_MAX,
 937     INIT_FIELD (max_voices_in  = ) INT_MAX,
 938     INIT_FIELD (voice_size_out = ) sizeof (ALSAVoiceOut),
 939     INIT_FIELD (voice_size_in  = ) sizeof (ALSAVoiceIn)
 940 };