Alc/alsa.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <memory.h>
  26 #ifdef HAVE_DLFCN_H
  27 #include <dlfcn.h>
  28 #endif
  29 #include "alMain.h"
  30 #include "AL/al.h"
  31 #include "AL/alc.h"
  32
  33 #include <alsa/asoundlib.h>
  34
  35
  36 typedef struct {
  37     snd_pcm_t *pcmHandle;
  38     snd_pcm_format_t format;
  39
  40     ALvoid *buffer;
  41     ALsizei size;
  42
  43     RingBuffer *ring;
  44     int doCapture;
  45
  46     volatile int killNow;
  47     ALvoid *thread;
  48 } alsa_data;
  49
  50 typedef struct {
  51     ALCchar *name;
  52     int card, dev;
  53 } DevMap;
  54
  55 static void *alsa_handle;
  56 #define MAKE_FUNC(f) static typeof(f) * p##f
  57 MAKE_FUNC(snd_strerror);
  58 MAKE_FUNC(snd_pcm_open);
  59 MAKE_FUNC(snd_pcm_close);
  60 MAKE_FUNC(snd_pcm_nonblock);
  61 MAKE_FUNC(snd_pcm_frames_to_bytes);
  62 MAKE_FUNC(snd_pcm_hw_params_malloc);
  63 MAKE_FUNC(snd_pcm_hw_params_free);
  64 MAKE_FUNC(snd_pcm_hw_params_any);
  65 MAKE_FUNC(snd_pcm_hw_params_set_access);
  66 MAKE_FUNC(snd_pcm_hw_params_set_format);
  67 MAKE_FUNC(snd_pcm_hw_params_set_channels);
  68 MAKE_FUNC(snd_pcm_hw_params_set_periods_near);
  69 MAKE_FUNC(snd_pcm_hw_params_set_rate_near);
  70 MAKE_FUNC(snd_pcm_hw_params_set_rate);
  71 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_near);
  72 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_min);
  73 MAKE_FUNC(snd_pcm_hw_params_get_buffer_size);
  74 MAKE_FUNC(snd_pcm_hw_params_get_period_size);
  75 MAKE_FUNC(snd_pcm_hw_params_get_access);
  76 MAKE_FUNC(snd_pcm_hw_params);
  77 MAKE_FUNC(snd_pcm_prepare);
  78 MAKE_FUNC(snd_pcm_start);
  79 MAKE_FUNC(snd_pcm_resume);
  80 MAKE_FUNC(snd_pcm_wait);
  81 MAKE_FUNC(snd_pcm_state);
  82 MAKE_FUNC(snd_pcm_avail_update);
  83 MAKE_FUNC(snd_pcm_areas_silence);
  84 MAKE_FUNC(snd_pcm_mmap_begin);
  85 MAKE_FUNC(snd_pcm_mmap_commit);
  86 MAKE_FUNC(snd_pcm_readi);
  87 MAKE_FUNC(snd_pcm_writei);
  88 MAKE_FUNC(snd_pcm_drain);
  89 MAKE_FUNC(snd_pcm_info_malloc);
  90 MAKE_FUNC(snd_pcm_info_free);
  91 MAKE_FUNC(snd_pcm_info_set_device);
  92 MAKE_FUNC(snd_pcm_info_set_subdevice);
  93 MAKE_FUNC(snd_pcm_info_set_stream);
  94 MAKE_FUNC(snd_pcm_info_get_name);
  95 MAKE_FUNC(snd_ctl_pcm_next_device);
  96 MAKE_FUNC(snd_ctl_pcm_info);
  97 MAKE_FUNC(snd_ctl_open);
  98 MAKE_FUNC(snd_ctl_close);
  99 MAKE_FUNC(snd_ctl_card_info_malloc);
 100 MAKE_FUNC(snd_ctl_card_info_free);
 101 MAKE_FUNC(snd_ctl_card_info);
 102 MAKE_FUNC(snd_ctl_card_info_get_name);
 103 MAKE_FUNC(snd_card_next);
 104 #undef MAKE_FUNC
 105
 106 #define MAX_ALL_DEVICES 32
 107
 108 static ALCchar *alsaDevice;
 109 static DevMap allDevNameMap[MAX_ALL_DEVICES];
 110 static DevMap allCaptureDevNameMap[MAX_ALL_DEVICES];
 111
 112 static int xrun_recovery(snd_pcm_t *handle, int err)
 113 {
 114     if (err == -EPIPE)
 115     {    /* under-run */
 116         err = psnd_pcm_prepare(handle);
 117         if (err < 0)
 118             AL_PRINT("prepare failed: %s\n", psnd_strerror(err));
 119     }
 120     else if (err == -ESTRPIPE)
 121     {
 122         while ((err = psnd_pcm_resume(handle)) == -EAGAIN)
 123             Sleep(1);       /* wait until the suspend flag is released */
 124         if (err < 0)
 125         {
 126             err = psnd_pcm_prepare(handle);
 127             if (err < 0)
 128                 AL_PRINT("prepare failed: %s\n", psnd_strerror(err));
 129         }
 130     }
 131     return err;
 132 }
 133
 134
 135 static ALuint ALSAProc(ALvoid *ptr)
 136 {
 137     ALCdevice *pDevice = (ALCdevice*)ptr;
 138     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 139     const snd_pcm_channel_area_t *areas = NULL;
 140     snd_pcm_sframes_t avail, commitres;
 141     snd_pcm_uframes_t offset, frames;
 142     char *WritePtr;
 143     int WriteCnt;
 144     int err;
 145
 146     while(!data->killNow)
 147     {
 148         snd_pcm_state_t state = psnd_pcm_state(data->pcmHandle);
 149         if(state == SND_PCM_STATE_XRUN)
 150         {
 151             err = xrun_recovery(data->pcmHandle, -EPIPE);
 152             if (err < 0)
 153             {
 154                 AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
 155                 break;
 156             }
 157         }
 158         else if (state == SND_PCM_STATE_SUSPENDED)
 159         {
 160             err = xrun_recovery(data->pcmHandle, -ESTRPIPE);
 161             if (err < 0)
 162             {
 163                 AL_PRINT("SUSPEND recovery failed: %s\n", psnd_strerror(err));
 164                 break;
 165             }
 166         }
 167
 168         avail = psnd_pcm_avail_update(data->pcmHandle);
 169         if(avail < 0)
 170         {
 171             err = xrun_recovery(data->pcmHandle, avail);
 172             if (err < 0)
 173             {
 174                 AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 175                 break;
 176             }
 177         }
 178
 179         // make sure there's frames to process
 180         if(avail == 0)
 181         {
 182             if(state != SND_PCM_STATE_RUNNING)
 183             {
 184                 err = psnd_pcm_start(data->pcmHandle);
 185                 if(err < 0)
 186                     err = xrun_recovery(data->pcmHandle, err);
 187                 if(err < 0)
 188                 {
 189                     AL_PRINT("start failed: %s\n", psnd_strerror(err));
 190                     break;
 191                 }
 192             }
 193             else if(psnd_pcm_wait(data->pcmHandle, 1000) == 0)
 194                 AL_PRINT("Wait timeout... buffer size too low?\n");
 195             continue;
 196         }
 197
 198         // it is possible that contiguous areas are smaller, thus we use a loop
 199         while (avail > 0)
 200         {
 201             frames = avail;
 202
 203             err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &frames);
 204             if (err < 0)
 205             {
 206                 err = xrun_recovery(data->pcmHandle, err);
 207                 if (err < 0)
 208                     AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 209                 break;
 210             }
 211
 212             SuspendContext(NULL);
 213             WritePtr = (char*)areas->addr + (offset * areas->step / 8);
 214             WriteCnt = psnd_pcm_frames_to_bytes(data->pcmHandle, frames);
 215             aluMixData(pDevice->Context, WritePtr, WriteCnt, pDevice->Format);
 216             ProcessContext(NULL);
 217
 218             commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, frames);
 219             if (commitres < 0 || (commitres-frames) != 0)
 220             {
 221                 AL_PRINT("mmap commit error: %s\n",
 222                          psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 223                 break;
 224             }
 225
 226             avail -= frames;
 227         }
 228     }
 229
 230     return 0;
 231 }
 232
 233 static ALuint ALSANoMMapProc(ALvoid *ptr)
 234 {
 235     ALCdevice *pDevice = (ALCdevice*)ptr;
 236     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 237     snd_pcm_sframes_t avail;
 238     char *WritePtr;
 239
 240     while(!data->killNow)
 241     {
 242         SuspendContext(NULL);
 243         aluMixData(pDevice->Context, data->buffer, data->size, pDevice->Format);
 244         ProcessContext(NULL);
 245
 246         WritePtr = data->buffer;
 247         avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
 248         while(avail > 0)
 249         {
 250             int ret = psnd_pcm_writei(data->pcmHandle, WritePtr, avail);
 251             switch (ret)
 252             {
 253             case -EAGAIN:
 254                 continue;
 255             case -ESTRPIPE:
 256                 while((ret=psnd_pcm_resume(data->pcmHandle)) == -EAGAIN)
 257                     Sleep(1);
 258                 break;
 259             case -EPIPE:
 260                 break;
 261             default:
 262                 if (ret >= 0)
 263                 {
 264                     WritePtr += psnd_pcm_frames_to_bytes(data->pcmHandle, ret);
 265                     avail -= ret;
 266                 }
 267                 break;
 268             }
 269             if (ret < 0)
 270             {
 271                 ret = psnd_pcm_prepare(data->pcmHandle);
 272                 if(ret < 0)
 273                     break;
 274             }
 275         }
 276     }
 277
 278     return 0;
 279 }
 280
 281 static ALuint ALSANoMMapCaptureProc(ALvoid *ptr)
 282 {
 283     ALCdevice *pDevice = (ALCdevice*)ptr;
 284     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 285     snd_pcm_sframes_t avail;
 286
 287     while(!data->killNow)
 288     {
 289         avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
 290         avail = psnd_pcm_readi(data->pcmHandle, data->buffer, avail);
 291         switch(avail)
 292         {
 293             case -EAGAIN:
 294                 continue;
 295             case -ESTRPIPE:
 296                 while((avail=psnd_pcm_resume(data->pcmHandle)) == -EAGAIN)
 297                     Sleep(1);
 298                 break;
 299             case -EPIPE:
 300                 break;
 301             default:
 302                 if (avail >= 0 && data->doCapture)
 303                     WriteRingBuffer(data->ring, data->buffer, avail);
 304                 break;
 305         }
 306         if(avail < 0)
 307         {
 308             avail = psnd_pcm_prepare(data->pcmHandle);
 309             if(avail < 0)
 310                 AL_PRINT("prepare error: %s\n", psnd_strerror(avail));
 311         }
 312     }
 313
 314     return 0;
 315 }
 316
 317 static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
 318 {
 319     snd_pcm_uframes_t bufferSizeInFrames;
 320     snd_pcm_hw_params_t *p = NULL;
 321     snd_pcm_access_t access;
 322     unsigned int periods;
 323     alsa_data *data;
 324     char driver[64];
 325     const char *str;
 326     int allowmmap;
 327     char *err;
 328     int i;
 329
 330     if(!alsa_handle)
 331         return ALC_FALSE;
 332
 333     strncpy(driver, GetConfigValue("alsa", "device", "default"), sizeof(driver)-1);
 334     driver[sizeof(driver)-1] = 0;
 335     if(deviceName)
 336     {
 337         size_t idx;
 338
 339         for(idx = 0;idx < MAX_ALL_DEVICES;idx++)
 340         {
 341             if(allDevNameMap[idx].name &&
 342                strcmp(deviceName, allDevNameMap[idx].name) == 0)
 343             {
 344                 device->szDeviceName = allDevNameMap[idx].name;
 345                 if(idx > 0)
 346                     sprintf(driver, "hw:%d,%d", allDevNameMap[idx].card, allDevNameMap[idx].dev);
 347                 goto open_alsa;
 348             }
 349         }
 350         if(strcmp(deviceName, alsaDevice) == 0)
 351         {
 352             device->szDeviceName = alsaDevice;
 353             goto open_alsa;
 354         }
 355         return ALC_FALSE;
 356     }
 357     else
 358         device->szDeviceName = alsaDevice;
 359
 360 open_alsa:
 361     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 362
 363     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 364     if(i < 0)
 365     {
 366         Sleep(200);
 367         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 368     }
 369     if(i >= 0)
 370     {
 371         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 372         if(i < 0)
 373             psnd_pcm_close(data->pcmHandle);
 374     }
 375     if(i < 0)
 376     {
 377         free(data);
 378         AL_PRINT("Could not open playback device '%s': %s\n", driver, psnd_strerror(i));
 379         return ALC_FALSE;
 380     }
 381
 382     switch(aluBytesFromFormat(device->Format))
 383     {
 384         case 1:
 385             data->format = SND_PCM_FORMAT_U8;
 386             break;
 387         case 2:
 388             data->format = SND_PCM_FORMAT_S16;
 389             break;
 390         default:
 391             data->format = SND_PCM_FORMAT_UNKNOWN;
 392             AL_PRINT("Unknown format?! %x\n", device->Format);
 393     }
 394
 395     periods = GetConfigValueInt("alsa", "periods", 0);
 396     bufferSizeInFrames = device->UpdateSize;
 397
 398     str = GetConfigValue("alsa", "mmap", "true");
 399     allowmmap = (strcasecmp(str, "true") == 0 ||
 400                  strcasecmp(str, "yes") == 0 ||
 401                  strcasecmp(str, "on") == 0 ||
 402                  atoi(str) != 0);
 403
 404     psnd_pcm_hw_params_malloc(&p);
 405 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
 406     /* start with the largest configuration space possible */
 407     if(!(ok(psnd_pcm_hw_params_any(data->pcmHandle, p), "any") &&
 408          /* set interleaved access */
 409          ((allowmmap && ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set access")) ||
 410           ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED), "set access")) &&
 411          /* set format (implicitly sets sample bits) */
 412          ok(psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format), "set format") &&
 413          /* set channels (implicitly sets frame bits) */
 414          ok(psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(device->Format)), "set channels") &&
 415          /* set periods (implicitly constrains period/buffer parameters) */
 416          (!periods || ok(psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL), "set periods near")) &&
 417          /* set rate (implicitly constrains period/buffer parameters) */
 418          ok(psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &device->Frequency, NULL), "set rate near") &&
 419          /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 420          ok(psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames), "set buffer size near") &&
 421          /* install and prepare hardware configuration */
 422          ok(psnd_pcm_hw_params(data->pcmHandle, p), "set params")))
 423     {
 424         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 425         psnd_pcm_hw_params_free(p);
 426         psnd_pcm_close(data->pcmHandle);
 427         free(data);
 428         return ALC_FALSE;
 429     }
 430 #undef ok
 431
 432     if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
 433     {
 434         AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
 435         psnd_pcm_hw_params_free(p);
 436         psnd_pcm_close(data->pcmHandle);
 437         free(data);
 438         return ALC_FALSE;
 439     }
 440
 441     if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
 442     {
 443         AL_PRINT("get_period_size failed: %s\n", psnd_strerror(i));
 444         psnd_pcm_hw_params_free(p);
 445         psnd_pcm_close(data->pcmHandle);
 446         free(data);
 447         return ALC_FALSE;
 448     }
 449
 450     psnd_pcm_hw_params_free(p);
 451
 452     device->UpdateSize = bufferSizeInFrames;
 453
 454     data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, device->UpdateSize);
 455     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 456     {
 457         data->buffer = malloc(data->size);
 458         if(!data->buffer)
 459         {
 460             AL_PRINT("buffer malloc failed\n");
 461             psnd_pcm_close(data->pcmHandle);
 462             free(data);
 463             return ALC_FALSE;
 464         }
 465     }
 466     else
 467     {
 468         i = psnd_pcm_prepare(data->pcmHandle);
 469         if(i < 0)
 470         {
 471             AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 472             psnd_pcm_close(data->pcmHandle);
 473             free(data->buffer);
 474             free(data);
 475             return ALC_FALSE;
 476         }
 477     }
 478
 479     device->ExtraData = data;
 480     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 481         data->thread = StartThread(ALSANoMMapProc, device);
 482     else
 483         data->thread = StartThread(ALSAProc, device);
 484     if(data->thread == NULL)
 485     {
 486         AL_PRINT("Could not create playback thread\n");
 487         psnd_pcm_close(data->pcmHandle);
 488         device->ExtraData = NULL;
 489         free(data->buffer);
 490         free(data);
 491         return ALC_FALSE;
 492     }
 493
 494     return ALC_TRUE;
 495 }
 496
 497 static void alsa_close_playback(ALCdevice *device)
 498 {
 499     alsa_data *data = (alsa_data*)device->ExtraData;
 500     data->killNow = 1;
 501     StopThread(data->thread);
 502     psnd_pcm_close(data->pcmHandle);
 503
 504     free(data->buffer);
 505     free(data);
 506     device->ExtraData = NULL;
 507 }
 508
 509
 510 static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
 511 {
 512     snd_pcm_format_t alsaFormat;
 513     snd_pcm_hw_params_t *p;
 514     snd_pcm_uframes_t bufferSizeInFrames;
 515     snd_pcm_access_t access;
 516     const char *str;
 517     alsa_data *data;
 518     char driver[64];
 519     int allowmmap;
 520     char *err;
 521     int i;
 522
 523     if(!alsa_handle)
 524         return ALC_FALSE;
 525
 526     strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
 527     driver[sizeof(driver)-1] = 0;
 528     if(deviceName)
 529     {
 530         size_t idx;
 531
 532         for(idx = 0;idx < MAX_ALL_DEVICES;idx++)
 533         {
 534             if(allCaptureDevNameMap[idx].name &&
 535                strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
 536             {
 537                 pDevice->szDeviceName = allCaptureDevNameMap[idx].name;
 538                 if(idx > 0)
 539                     sprintf(driver, "plughw:%d,%d", allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
 540                 goto open_alsa;
 541             }
 542         }
 543         return ALC_FALSE;
 544     }
 545     else
 546         pDevice->szDeviceName = allCaptureDevNameMap[0].name;
 547
 548 open_alsa:
 549     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 550
 551     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 552     if(i < 0)
 553     {
 554         Sleep(200);
 555         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 556     }
 557     if(i >= 0)
 558     {
 559         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 560         if(i < 0)
 561             psnd_pcm_close(data->pcmHandle);
 562     }
 563     if(i < 0)
 564     {
 565         free(data);
 566         AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
 567         return ALC_FALSE;
 568     }
 569
 570     switch(aluBytesFromFormat(format))
 571     {
 572         case 1:
 573             alsaFormat = SND_PCM_FORMAT_U8;
 574             break;
 575         case 2:
 576             alsaFormat = SND_PCM_FORMAT_S16;
 577             break;
 578         default:
 579             alsaFormat = SND_PCM_FORMAT_UNKNOWN;
 580             AL_PRINT("Unknown format?! %x\n", format);
 581     }
 582
 583     str = GetConfigValue("alsa", "mmap", "true");
 584     allowmmap = (strcasecmp(str, "true") == 0 ||
 585                  strcasecmp(str, "yes") == 0 ||
 586                  strcasecmp(str, "on") == 0 ||
 587                  atoi(str) != 0);
 588
 589     bufferSizeInFrames = SampleSize;
 590     psnd_pcm_hw_params_malloc(&p);
 591 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
 592     /* start with the largest configuration space possible */
 593     if(!(allowmmap &&
 594          ok(psnd_pcm_hw_params_any(data->pcmHandle, p), "any") &&
 595          /* set interleaved access */
 596          ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set access") &&
 597          /* set format (implicitly sets sample bits) */
 598          ok(psnd_pcm_hw_params_set_format(data->pcmHandle, p, alsaFormat), "set format") &&
 599          /* set channels (implicitly sets frame bits) */
 600          ok(psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format)), "set channels") &&
 601          /* set rate (implicitly constrains period/buffer parameters) */
 602          ok(psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0), "set rate") &&
 603          /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 604          ok(psnd_pcm_hw_params_set_buffer_size_min(data->pcmHandle, p, &bufferSizeInFrames), "set buffer size min") &&
 605          /* install and prepare hardware configuration */
 606          ok(psnd_pcm_hw_params(data->pcmHandle, p), "set params")))
 607     {
 608         if(i < 0)
 609             AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 610         bufferSizeInFrames = SampleSize;
 611         if(!(ok(psnd_pcm_hw_params_any(data->pcmHandle, p), "any") &&
 612              ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED), "set access") &&
 613              ok(psnd_pcm_hw_params_set_format(data->pcmHandle, p, alsaFormat), "set format") &&
 614              ok(psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format)), "set channels") &&
 615              ok(psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0), "set rate") &&
 616              ok(psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames), "set buffer size near") &&
 617              ok(psnd_pcm_hw_params(data->pcmHandle, p), "set params")))
 618         {
 619             AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 620             psnd_pcm_hw_params_free(p);
 621             psnd_pcm_close(data->pcmHandle);
 622             free(data);
 623             return ALC_FALSE;
 624         }
 625     }
 626 #undef ok
 627
 628     if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
 629     {
 630         AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
 631         psnd_pcm_hw_params_free(p);
 632         psnd_pcm_close(data->pcmHandle);
 633         free(data);
 634         return ALC_FALSE;
 635     }
 636     if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
 637     {
 638         AL_PRINT("get size failed: %s\n", psnd_strerror(i));
 639         psnd_pcm_hw_params_free(p);
 640         psnd_pcm_close(data->pcmHandle);
 641         free(data);
 642         return ALC_FALSE;
 643     }
 644
 645     psnd_pcm_hw_params_free(p);
 646
 647     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 648     {
 649         ALuint frameSize = aluChannelsFromFormat(pDevice->Format);
 650         frameSize *= aluBytesFromFormat(pDevice->Format);
 651
 652         data->ring = CreateRingBuffer(frameSize, SampleSize);
 653         if(!data->ring)
 654         {
 655             AL_PRINT("ring buffer create failed\n");
 656             psnd_pcm_close(data->pcmHandle);
 657             free(data);
 658             return ALC_FALSE;
 659         }
 660
 661         data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
 662         data->buffer = malloc(data->size);
 663         if(!data->buffer)
 664         {
 665             AL_PRINT("buffer malloc failed\n");
 666             psnd_pcm_close(data->pcmHandle);
 667             DestroyRingBuffer(data->ring);
 668             free(data);
 669             return ALC_FALSE;
 670         }
 671
 672         pDevice->ExtraData = data;
 673         data->thread = StartThread(ALSANoMMapCaptureProc, pDevice);
 674         if(data->thread == NULL)
 675         {
 676             AL_PRINT("Could not create capture thread\n");
 677             pDevice->ExtraData = NULL;
 678             psnd_pcm_close(data->pcmHandle);
 679             DestroyRingBuffer(data->ring);
 680             free(data->buffer);
 681             free(data);
 682             return ALC_FALSE;
 683         }
 684     }
 685     else
 686     {
 687         i = psnd_pcm_prepare(data->pcmHandle);
 688         if(i < 0)
 689         {
 690             AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 691             psnd_pcm_close(data->pcmHandle);
 692             free(data);
 693             return ALC_FALSE;
 694         }
 695         pDevice->ExtraData = data;
 696     }
 697
 698     return ALC_TRUE;
 699 }
 700
 701 static void alsa_close_capture(ALCdevice *pDevice)
 702 {
 703     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 704
 705     if(data->thread)
 706     {
 707         data->killNow = 1;
 708         StopThread(data->thread);
 709         DestroyRingBuffer(data->ring);
 710     }
 711     psnd_pcm_close(data->pcmHandle);
 712
 713     free(data);
 714     pDevice->ExtraData = NULL;
 715 }
 716
 717 static void alsa_start_capture(ALCdevice *pDevice)
 718 {
 719     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 720     data->doCapture = 1;
 721     if(!data->thread)
 722     {
 723         psnd_pcm_prepare(data->pcmHandle);
 724         psnd_pcm_start(data->pcmHandle);
 725     }
 726 }
 727
 728 static void alsa_stop_capture(ALCdevice *pDevice)
 729 {
 730     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 731     data->doCapture = 0;
 732     if(!data->thread)
 733         psnd_pcm_drain(data->pcmHandle);
 734 }
 735
 736 static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 737 {
 738     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 739     const snd_pcm_channel_area_t *areas = NULL;
 740     snd_pcm_sframes_t frames, commitres;
 741     snd_pcm_uframes_t size, offset;
 742     snd_pcm_state_t state;
 743     int err;
 744
 745     if(data->thread)
 746     {
 747         if(lSamples <= (ALCuint)RingBufferSize(data->ring))
 748             ReadRingBuffer(data->ring, pBuffer, lSamples);
 749         else
 750             SetALCError(ALC_INVALID_VALUE);
 751         return;
 752     }
 753
 754     state = psnd_pcm_state(data->pcmHandle);
 755     if(state == SND_PCM_STATE_XRUN)
 756     {
 757         err = xrun_recovery(data->pcmHandle, -EPIPE);
 758         if(err < 0)
 759         {
 760             AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
 761             return;
 762         }
 763     }
 764
 765     frames = psnd_pcm_avail_update(data->pcmHandle);
 766     if(frames < 0)
 767     {
 768         err = xrun_recovery(data->pcmHandle, frames);
 769         if (err < 0)
 770             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 771         else
 772             frames = psnd_pcm_avail_update(data->pcmHandle);
 773     }
 774     if (frames < (snd_pcm_sframes_t)lSamples)
 775     {
 776         SetALCError(ALC_INVALID_VALUE);
 777         return;
 778     }
 779
 780     // it is possible that contiguous areas are smaller, thus we use a loop
 781     while (lSamples > 0)
 782     {
 783         char *Pointer;
 784         int Count;
 785
 786         size = lSamples;
 787         err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &size);
 788         if (err < 0)
 789         {
 790             err = xrun_recovery(data->pcmHandle, err);
 791             if (err < 0)
 792             {
 793                 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 794                 break;
 795             }
 796             continue;
 797         }
 798
 799         Pointer = (char*)areas->addr + (offset * areas->step / 8);
 800         Count = psnd_pcm_frames_to_bytes(data->pcmHandle, size);
 801
 802         memcpy(pBuffer, Pointer, Count);
 803         pBuffer = (char*)pBuffer + Count;
 804
 805         commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, size);
 806         if (commitres < 0 || (commitres-size) != 0)
 807         {
 808            AL_PRINT("mmap commit error: %s\n",
 809                     psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 810            break;
 811         }
 812
 813         lSamples -= size;
 814     }
 815 }
 816
 817 static ALCuint alsa_available_samples(ALCdevice *pDevice)
 818 {
 819     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 820     snd_pcm_sframes_t frames;
 821     snd_pcm_state_t state;
 822     int err;
 823
 824     if(data->thread)
 825         return RingBufferSize(data->ring);
 826
 827     state = psnd_pcm_state(data->pcmHandle);
 828     if(state == SND_PCM_STATE_XRUN)
 829     {
 830         err = xrun_recovery(data->pcmHandle, -EPIPE);
 831         if(err >= 0)
 832         {
 833             if(data->doCapture)
 834                 err = psnd_pcm_start(data->pcmHandle);
 835         }
 836         if (err < 0)
 837         {
 838             AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
 839             return 0;
 840         }
 841     }
 842
 843     frames = psnd_pcm_avail_update(data->pcmHandle);
 844     if(frames < 0)
 845     {
 846         err = xrun_recovery(data->pcmHandle, frames);
 847         if (err < 0)
 848             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 849         else
 850             frames = psnd_pcm_avail_update(data->pcmHandle);
 851     }
 852     return max(frames, 0);
 853 }
 854
 855
 856 BackendFuncs alsa_funcs = {
 857     alsa_open_playback,
 858     alsa_close_playback,
 859     alsa_open_capture,
 860     alsa_close_capture,
 861     alsa_start_capture,
 862     alsa_stop_capture,
 863     alsa_capture_samples,
 864     alsa_available_samples
 865 };
 866
 867 void alc_alsa_init(BackendFuncs *func_list)
 868 {
 869     snd_ctl_t *handle;
 870     int card, err, dev, idx = 1;
 871     snd_ctl_card_info_t *info;
 872     snd_pcm_info_t *pcminfo;
 873     snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
 874     char name[128];
 875     char *str;
 876
 877     *func_list = alsa_funcs;
 878
 879 #ifdef HAVE_DLFCN_H
 880     alsa_handle = dlopen("libasound.so.2", RTLD_NOW);
 881     if(!alsa_handle)
 882         return;
 883     dlerror();
 884
 885 #define LOAD_FUNC(f) do { \
 886     p##f = (typeof(f)*)dlsym(alsa_handle, #f); \
 887     if((str=dlerror()) != NULL) \
 888     { \
 889         dlclose(alsa_handle); \
 890         alsa_handle = NULL; \
 891         AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
 892         return; \
 893     } \
 894 } while(0)
 895 #else
 896     str = NULL;
 897     alsa_handle = (void*)0xDEADBEEF;
 898 #define LOAD_FUNC(f) p##f = f
 899 #endif
 900
 901 LOAD_FUNC(snd_strerror);
 902 LOAD_FUNC(snd_pcm_open);
 903 LOAD_FUNC(snd_pcm_close);
 904 LOAD_FUNC(snd_pcm_nonblock);
 905 LOAD_FUNC(snd_pcm_frames_to_bytes);
 906 LOAD_FUNC(snd_pcm_hw_params_malloc);
 907 LOAD_FUNC(snd_pcm_hw_params_free);
 908 LOAD_FUNC(snd_pcm_hw_params_any);
 909 LOAD_FUNC(snd_pcm_hw_params_set_access);
 910 LOAD_FUNC(snd_pcm_hw_params_set_format);
 911 LOAD_FUNC(snd_pcm_hw_params_set_channels);
 912 LOAD_FUNC(snd_pcm_hw_params_set_periods_near);
 913 LOAD_FUNC(snd_pcm_hw_params_set_rate_near);
 914 LOAD_FUNC(snd_pcm_hw_params_set_rate);
 915 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near);
 916 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min);
 917 LOAD_FUNC(snd_pcm_hw_params_get_buffer_size);
 918 LOAD_FUNC(snd_pcm_hw_params_get_period_size);
 919 LOAD_FUNC(snd_pcm_hw_params_get_access);
 920 LOAD_FUNC(snd_pcm_hw_params);
 921 LOAD_FUNC(snd_pcm_prepare);
 922 LOAD_FUNC(snd_pcm_start);
 923 LOAD_FUNC(snd_pcm_resume);
 924 LOAD_FUNC(snd_pcm_wait);
 925 LOAD_FUNC(snd_pcm_state);
 926 LOAD_FUNC(snd_pcm_avail_update);
 927 LOAD_FUNC(snd_pcm_areas_silence);
 928 LOAD_FUNC(snd_pcm_mmap_begin);
 929 LOAD_FUNC(snd_pcm_mmap_commit);
 930 LOAD_FUNC(snd_pcm_readi);
 931 LOAD_FUNC(snd_pcm_writei);
 932 LOAD_FUNC(snd_pcm_drain);
 933
 934 LOAD_FUNC(snd_pcm_info_malloc);
 935 LOAD_FUNC(snd_pcm_info_free);
 936 LOAD_FUNC(snd_pcm_info_set_device);
 937 LOAD_FUNC(snd_pcm_info_set_subdevice);
 938 LOAD_FUNC(snd_pcm_info_set_stream);
 939 LOAD_FUNC(snd_pcm_info_get_name);
 940 LOAD_FUNC(snd_ctl_pcm_next_device);
 941 LOAD_FUNC(snd_ctl_pcm_info);
 942 LOAD_FUNC(snd_ctl_open);
 943 LOAD_FUNC(snd_ctl_close);
 944 LOAD_FUNC(snd_ctl_card_info_malloc);
 945 LOAD_FUNC(snd_ctl_card_info_free);
 946 LOAD_FUNC(snd_ctl_card_info);
 947 LOAD_FUNC(snd_ctl_card_info_get_name);
 948 LOAD_FUNC(snd_card_next);
 949
 950 #undef LOAD_FUNC
 951
 952     psnd_ctl_card_info_malloc(&info);
 953     psnd_pcm_info_malloc(&pcminfo);
 954
 955     card = -1;
 956     if(psnd_card_next(&card) < 0 || card < 0)
 957         AL_PRINT("no playback cards found...\n");
 958
 959     alsaDevice = AppendDeviceList("ALSA Software");
 960     allDevNameMap[0].name = AppendAllDeviceList("ALSA Software on default");
 961
 962     while (card >= 0) {
 963         sprintf(name, "hw:%d", card);
 964         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
 965             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
 966             goto next_card;
 967         }
 968         if ((err = psnd_ctl_card_info(handle, info)) < 0) {
 969             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
 970             psnd_ctl_close(handle);
 971             goto next_card;
 972         }
 973
 974         dev = -1;
 975         while (idx < MAX_ALL_DEVICES) {
 976             const char *cname, *dname;
 977
 978             if (psnd_ctl_pcm_next_device(handle, &dev)<0)
 979                 AL_PRINT("snd_ctl_pcm_next_device failed\n");
 980             if (dev < 0)
 981                 break;
 982
 983             psnd_pcm_info_set_device(pcminfo, dev);
 984             psnd_pcm_info_set_subdevice(pcminfo, 0);
 985             psnd_pcm_info_set_stream(pcminfo, stream);
 986             if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
 987                 if (err != -ENOENT)
 988                     AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
 989                 continue;
 990             }
 991
 992             cname = psnd_ctl_card_info_get_name(info);
 993             dname = psnd_pcm_info_get_name(pcminfo);
 994             snprintf(name, sizeof(name), "ALSA Software on %s [%s] (hw:%d,%d)",
 995                      cname, dname, card, dev);
 996             allDevNameMap[idx].name = AppendAllDeviceList(name);
 997             allDevNameMap[idx].card = card;
 998             allDevNameMap[idx].dev = dev;
 999             idx++;
1000         }
1001         psnd_ctl_close(handle);
1002 next_card:
1003         if(psnd_card_next(&card) < 0) {
1004             AL_PRINT("snd_card_next failed\n");
1005             break;
1006         }
1007     }
1008
1009
1010     stream = SND_PCM_STREAM_CAPTURE;
1011
1012     card = -1;
1013     if(psnd_card_next(&card) < 0 || card < 0) {
1014         AL_PRINT("no capture cards found...\n");
1015         psnd_pcm_info_free(pcminfo);
1016         psnd_ctl_card_info_free(info);
1017         return;
1018     }
1019
1020     allCaptureDevNameMap[0].name = AppendCaptureDeviceList("ALSA Capture on default");
1021     idx = 1;
1022
1023     while (card >= 0) {
1024         sprintf(name, "hw:%d", card);
1025         handle = NULL;
1026         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
1027             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
1028         }
1029         if (err >= 0 && (err = psnd_ctl_card_info(handle, info)) < 0) {
1030             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
1031         }
1032         else if (err >= 0)
1033         {
1034             dev = -1;
1035             while (idx < MAX_ALL_DEVICES) {
1036                 const char *cname, *dname;
1037
1038                 if (psnd_ctl_pcm_next_device(handle, &dev)<0)
1039                     AL_PRINT("snd_ctl_pcm_next_device failed\n");
1040                 if (dev < 0)
1041                     break;
1042                 psnd_pcm_info_set_device(pcminfo, dev);
1043                 psnd_pcm_info_set_subdevice(pcminfo, 0);
1044                 psnd_pcm_info_set_stream(pcminfo, stream);
1045                 if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
1046                     if (err != -ENOENT)
1047                         AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
1048                     continue;
1049                 }
1050
1051                 cname = psnd_ctl_card_info_get_name(info);
1052                 dname = psnd_pcm_info_get_name(pcminfo);
1053                 snprintf(name, sizeof(name), "ALSA Capture on %s [%s] (hw:%d,%d)",
1054                          cname, dname, card, dev);
1055                 allCaptureDevNameMap[idx].name = AppendCaptureDeviceList(name);
1056                 allCaptureDevNameMap[idx].card = card;
1057                 allCaptureDevNameMap[idx].dev = dev;
1058                 idx++;
1059             }
1060         }
1061         if(handle) psnd_ctl_close(handle);
1062         if(psnd_card_next(&card) < 0) {
1063             AL_PRINT("snd_card_next failed\n");
1064             break;
1065         }
1066     }
1067     psnd_pcm_info_free(pcminfo);
1068     psnd_ctl_card_info_free(info);
1069 }