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