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 < (snd_pcm_sframes_t)pDevice->UpdateSize)
 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(avail == 0 && psnd_pcm_wait(data->pcmHandle, 1000) == 0)
 194                 AL_PRINT("Wait timeout... buffer size too low?\n");
 195             else if(avail != 0)
 196                 Sleep(1);
 197             continue;
 198         }
 199         avail = pDevice->UpdateSize;
 200
 201         // it is possible that contiguous areas are smaller, thus we use a loop
 202         while (avail > 0)
 203         {
 204             frames = avail;
 205
 206             err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &frames);
 207             if (err < 0)
 208             {
 209                 err = xrun_recovery(data->pcmHandle, err);
 210                 if (err < 0)
 211                     AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 212                 break;
 213             }
 214
 215             WritePtr = (char*)areas->addr + (offset * areas->step / 8);
 216             WriteCnt = psnd_pcm_frames_to_bytes(data->pcmHandle, frames);
 217             SuspendContext(NULL);
 218             aluMixData(pDevice->Context, WritePtr, WriteCnt, pDevice->Format);
 219             ProcessContext(NULL);
 220
 221             commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, frames);
 222             if (commitres < 0 || (commitres-frames) != 0)
 223             {
 224                 AL_PRINT("mmap commit error: %s\n",
 225                          psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 226                 break;
 227             }
 228
 229             avail -= frames;
 230         }
 231     }
 232
 233     return 0;
 234 }
 235
 236 static ALuint ALSANoMMapProc(ALvoid *ptr)
 237 {
 238     ALCdevice *pDevice = (ALCdevice*)ptr;
 239     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 240     snd_pcm_sframes_t avail;
 241     char *WritePtr;
 242
 243     while(!data->killNow)
 244     {
 245         SuspendContext(NULL);
 246         aluMixData(pDevice->Context, data->buffer, data->size, pDevice->Format);
 247         ProcessContext(NULL);
 248
 249         WritePtr = data->buffer;
 250         avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
 251         while(avail > 0)
 252         {
 253             int ret = psnd_pcm_writei(data->pcmHandle, WritePtr, avail);
 254             switch (ret)
 255             {
 256             case -EAGAIN:
 257                 continue;
 258             case -ESTRPIPE:
 259                 while((ret=psnd_pcm_resume(data->pcmHandle)) == -EAGAIN)
 260                     Sleep(1);
 261                 break;
 262             case -EPIPE:
 263                 break;
 264             default:
 265                 if (ret >= 0)
 266                 {
 267                     WritePtr += psnd_pcm_frames_to_bytes(data->pcmHandle, ret);
 268                     avail -= ret;
 269                 }
 270                 break;
 271             }
 272             if (ret < 0)
 273             {
 274                 ret = psnd_pcm_prepare(data->pcmHandle);
 275                 if(ret < 0)
 276                     break;
 277             }
 278         }
 279     }
 280
 281     return 0;
 282 }
 283
 284 static ALuint ALSANoMMapCaptureProc(ALvoid *ptr)
 285 {
 286     ALCdevice *pDevice = (ALCdevice*)ptr;
 287     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 288     snd_pcm_sframes_t avail;
 289
 290     while(!data->killNow)
 291     {
 292         avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
 293         avail = psnd_pcm_readi(data->pcmHandle, data->buffer, avail);
 294         switch(avail)
 295         {
 296             case -EAGAIN:
 297                 continue;
 298             case -ESTRPIPE:
 299                 while((avail=psnd_pcm_resume(data->pcmHandle)) == -EAGAIN)
 300                     Sleep(1);
 301                 break;
 302             case -EPIPE:
 303                 break;
 304             default:
 305                 if (avail >= 0 && data->doCapture)
 306                     WriteRingBuffer(data->ring, data->buffer, avail);
 307                 break;
 308         }
 309         if(avail < 0)
 310         {
 311             avail = psnd_pcm_prepare(data->pcmHandle);
 312             if(avail < 0)
 313                 AL_PRINT("prepare error: %s\n", psnd_strerror(avail));
 314         }
 315     }
 316
 317     return 0;
 318 }
 319
 320 static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
 321 {
 322     snd_pcm_uframes_t bufferSizeInFrames;
 323     snd_pcm_hw_params_t *p = NULL;
 324     snd_pcm_access_t access;
 325     unsigned int periods;
 326     unsigned int rate;
 327     alsa_data *data;
 328     char driver[64];
 329     const char *str;
 330     int allowmmap;
 331     char *err;
 332     int i;
 333
 334     if(!alsa_handle)
 335         return ALC_FALSE;
 336
 337     strncpy(driver, GetConfigValue("alsa", "device", "default"), sizeof(driver)-1);
 338     driver[sizeof(driver)-1] = 0;
 339     if(deviceName)
 340     {
 341         size_t idx;
 342
 343         for(idx = 0;idx < MAX_ALL_DEVICES;idx++)
 344         {
 345             if(allDevNameMap[idx].name &&
 346                strcmp(deviceName, allDevNameMap[idx].name) == 0)
 347             {
 348                 device->szDeviceName = allDevNameMap[idx].name;
 349                 if(idx > 0)
 350                     sprintf(driver, "hw:%d,%d", allDevNameMap[idx].card, allDevNameMap[idx].dev);
 351                 goto open_alsa;
 352             }
 353         }
 354         if(strcmp(deviceName, alsaDevice) == 0)
 355         {
 356             device->szDeviceName = alsaDevice;
 357             goto open_alsa;
 358         }
 359         return ALC_FALSE;
 360     }
 361     else
 362         device->szDeviceName = alsaDevice;
 363
 364 open_alsa:
 365     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 366
 367     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 368     if(i < 0)
 369     {
 370         Sleep(200);
 371         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 372     }
 373     if(i >= 0)
 374     {
 375         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 376         if(i < 0)
 377             psnd_pcm_close(data->pcmHandle);
 378     }
 379     if(i < 0)
 380     {
 381         free(data);
 382         AL_PRINT("Could not open playback device '%s': %s\n", driver, psnd_strerror(i));
 383         return ALC_FALSE;
 384     }
 385
 386     switch(aluBytesFromFormat(device->Format))
 387     {
 388         case 1:
 389             data->format = SND_PCM_FORMAT_U8;
 390             break;
 391         case 2:
 392             data->format = SND_PCM_FORMAT_S16;
 393             break;
 394         default:
 395             data->format = SND_PCM_FORMAT_UNKNOWN;
 396             AL_PRINT("Unknown format?! %x\n", device->Format);
 397     }
 398
 399     periods = GetConfigValueInt("alsa", "periods", 0);
 400     bufferSizeInFrames = device->UpdateSize;
 401     rate = device->Frequency;
 402
 403     str = GetConfigValue("alsa", "mmap", "true");
 404     allowmmap = (strcasecmp(str, "true") == 0 ||
 405                  strcasecmp(str, "yes") == 0 ||
 406                  strcasecmp(str, "on") == 0 ||
 407                  atoi(str) != 0);
 408
 409     err = NULL;
 410     psnd_pcm_hw_params_malloc(&p);
 411
 412     if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
 413         err = "any";
 414     /* set interleaved access */
 415     if(err == NULL && (!allowmmap || (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0))
 416     {
 417         if((i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
 418             err = "set access";
 419     }
 420     /* set format (implicitly sets sample bits) */
 421     if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
 422         err = "set format";
 423     /* set channels (implicitly sets frame bits) */
 424     if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(device->Format))) < 0)
 425         err = "set channels";
 426     /* set periods (implicitly constrains period/buffer parameters) */
 427     if(err == NULL && periods && (i=psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL)) < 0)
 428         err = "set periods near";
 429     /* set rate (implicitly constrains period/buffer parameters) */
 430     if(err == NULL && (i=psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &rate, NULL)) < 0)
 431         err = "set rate near";
 432     /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 433     if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
 434         err = "set buffer size near";
 435     /* install and prepare hardware configuration */
 436     if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 437         err = "set params";
 438     if(err != NULL)
 439     {
 440         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 441         psnd_pcm_hw_params_free(p);
 442         psnd_pcm_close(data->pcmHandle);
 443         free(data);
 444         return ALC_FALSE;
 445     }
 446
 447     if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
 448     {
 449         AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
 450         psnd_pcm_hw_params_free(p);
 451         psnd_pcm_close(data->pcmHandle);
 452         free(data);
 453         return ALC_FALSE;
 454     }
 455
 456     if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
 457     {
 458         AL_PRINT("get_period_size failed: %s\n", psnd_strerror(i));
 459         psnd_pcm_hw_params_free(p);
 460         psnd_pcm_close(data->pcmHandle);
 461         free(data);
 462         return ALC_FALSE;
 463     }
 464
 465     psnd_pcm_hw_params_free(p);
 466
 467     data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, device->UpdateSize);
 468     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 469     {
 470         data->buffer = malloc(data->size);
 471         if(!data->buffer)
 472         {
 473             AL_PRINT("buffer malloc failed\n");
 474             psnd_pcm_close(data->pcmHandle);
 475             free(data);
 476             return ALC_FALSE;
 477         }
 478     }
 479     else
 480     {
 481         i = psnd_pcm_prepare(data->pcmHandle);
 482         if(i < 0)
 483         {
 484             AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 485             psnd_pcm_close(data->pcmHandle);
 486             free(data->buffer);
 487             free(data);
 488             return ALC_FALSE;
 489         }
 490     }
 491
 492     device->ExtraData = data;
 493     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 494         data->thread = StartThread(ALSANoMMapProc, device);
 495     else
 496         data->thread = StartThread(ALSAProc, device);
 497     if(data->thread == NULL)
 498     {
 499         AL_PRINT("Could not create playback thread\n");
 500         psnd_pcm_close(data->pcmHandle);
 501         device->ExtraData = NULL;
 502         free(data->buffer);
 503         free(data);
 504         return ALC_FALSE;
 505     }
 506
 507     device->UpdateSize = bufferSizeInFrames;
 508     device->Frequency = rate;
 509
 510     return ALC_TRUE;
 511 }
 512
 513 static void alsa_close_playback(ALCdevice *device)
 514 {
 515     alsa_data *data = (alsa_data*)device->ExtraData;
 516     data->killNow = 1;
 517     StopThread(data->thread);
 518     psnd_pcm_close(data->pcmHandle);
 519
 520     free(data->buffer);
 521     free(data);
 522     device->ExtraData = NULL;
 523 }
 524
 525
 526 static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
 527 {
 528     snd_pcm_format_t alsaFormat;
 529     snd_pcm_hw_params_t *p;
 530     snd_pcm_uframes_t bufferSizeInFrames;
 531     snd_pcm_access_t access;
 532     const char *str;
 533     alsa_data *data;
 534     char driver[64];
 535     int allowmmap;
 536     char *err;
 537     int i;
 538
 539     if(!alsa_handle)
 540         return ALC_FALSE;
 541
 542     strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
 543     driver[sizeof(driver)-1] = 0;
 544     if(deviceName)
 545     {
 546         size_t idx;
 547
 548         for(idx = 0;idx < MAX_ALL_DEVICES;idx++)
 549         {
 550             if(allCaptureDevNameMap[idx].name &&
 551                strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
 552             {
 553                 pDevice->szDeviceName = allCaptureDevNameMap[idx].name;
 554                 if(idx > 0)
 555                     sprintf(driver, "plughw:%d,%d", allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
 556                 goto open_alsa;
 557             }
 558         }
 559         return ALC_FALSE;
 560     }
 561     else
 562         pDevice->szDeviceName = allCaptureDevNameMap[0].name;
 563
 564 open_alsa:
 565     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 566
 567     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 568     if(i < 0)
 569     {
 570         Sleep(200);
 571         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 572     }
 573     if(i >= 0)
 574     {
 575         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 576         if(i < 0)
 577             psnd_pcm_close(data->pcmHandle);
 578     }
 579     if(i < 0)
 580     {
 581         free(data);
 582         AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
 583         return ALC_FALSE;
 584     }
 585
 586     switch(aluBytesFromFormat(format))
 587     {
 588         case 1:
 589             alsaFormat = SND_PCM_FORMAT_U8;
 590             break;
 591         case 2:
 592             alsaFormat = SND_PCM_FORMAT_S16;
 593             break;
 594         default:
 595             alsaFormat = SND_PCM_FORMAT_UNKNOWN;
 596             AL_PRINT("Unknown format?! %x\n", format);
 597     }
 598
 599     str = GetConfigValue("alsa", "mmap", "true");
 600     allowmmap = (strcasecmp(str, "true") == 0 ||
 601                  strcasecmp(str, "yes") == 0 ||
 602                  strcasecmp(str, "on") == 0 ||
 603                  atoi(str) != 0);
 604
 605     err = NULL;
 606     bufferSizeInFrames = SampleSize;
 607     psnd_pcm_hw_params_malloc(&p);
 608
 609     if(!allowmmap)
 610         err = "no mmap";
 611     if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
 612         err = "any";
 613     /* set interleaved access */
 614     if(err == NULL && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0)
 615     {
 616         err = "set access";
 617         allowmmap = 0;
 618     }
 619     /* set format (implicitly sets sample bits) */
 620     if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
 621         err = "set format";
 622     /* set channels (implicitly sets frame bits) */
 623     if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
 624         err = "set channels";
 625     /* set rate (implicitly constrains period/buffer parameters) */
 626     if(err == NULL && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0)) < 0)
 627         err = "set rate near";
 628     /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 629     if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_min(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
 630     {
 631         err = "set buffer size min";
 632         allowmmap = 0;
 633     }
 634     /* install and prepare hardware configuration */
 635     if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 636         err = "set params";
 637     if(!allowmmap)
 638     {
 639         err = NULL;
 640         if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
 641             err = "any";
 642         /* set interleaved access */
 643         if(err == NULL && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0)
 644             err = "set access";
 645         /* set format (implicitly sets sample bits) */
 646         if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
 647             err = "set format";
 648         /* set channels (implicitly sets frame bits) */
 649         if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
 650             err = "set channels";
 651         /* set rate (implicitly constrains period/buffer parameters) */
 652         if(err == NULL && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0)) < 0)
 653             err = "set rate near";
 654         /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 655         if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
 656             err = "set buffer size near";
 657         /* install and prepare hardware configuration */
 658         if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 659             err = "set params";
 660     }
 661     if(err != NULL)
 662     {
 663         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 664         psnd_pcm_hw_params_free(p);
 665         psnd_pcm_close(data->pcmHandle);
 666         free(data);
 667         return ALC_FALSE;
 668     }
 669
 670     if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
 671     {
 672         AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
 673         psnd_pcm_hw_params_free(p);
 674         psnd_pcm_close(data->pcmHandle);
 675         free(data);
 676         return ALC_FALSE;
 677     }
 678     if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
 679     {
 680         AL_PRINT("get size failed: %s\n", psnd_strerror(i));
 681         psnd_pcm_hw_params_free(p);
 682         psnd_pcm_close(data->pcmHandle);
 683         free(data);
 684         return ALC_FALSE;
 685     }
 686
 687     psnd_pcm_hw_params_free(p);
 688
 689     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 690     {
 691         ALuint frameSize = aluChannelsFromFormat(pDevice->Format);
 692         frameSize *= aluBytesFromFormat(pDevice->Format);
 693
 694         data->ring = CreateRingBuffer(frameSize, SampleSize);
 695         if(!data->ring)
 696         {
 697             AL_PRINT("ring buffer create failed\n");
 698             psnd_pcm_close(data->pcmHandle);
 699             free(data);
 700             return ALC_FALSE;
 701         }
 702
 703         data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
 704         data->buffer = malloc(data->size);
 705         if(!data->buffer)
 706         {
 707             AL_PRINT("buffer malloc failed\n");
 708             psnd_pcm_close(data->pcmHandle);
 709             DestroyRingBuffer(data->ring);
 710             free(data);
 711             return ALC_FALSE;
 712         }
 713
 714         pDevice->ExtraData = data;
 715         data->thread = StartThread(ALSANoMMapCaptureProc, pDevice);
 716         if(data->thread == NULL)
 717         {
 718             AL_PRINT("Could not create capture thread\n");
 719             pDevice->ExtraData = NULL;
 720             psnd_pcm_close(data->pcmHandle);
 721             DestroyRingBuffer(data->ring);
 722             free(data->buffer);
 723             free(data);
 724             return ALC_FALSE;
 725         }
 726     }
 727     else
 728     {
 729         i = psnd_pcm_prepare(data->pcmHandle);
 730         if(i < 0)
 731         {
 732             AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 733             psnd_pcm_close(data->pcmHandle);
 734             free(data);
 735             return ALC_FALSE;
 736         }
 737         pDevice->ExtraData = data;
 738     }
 739
 740     return ALC_TRUE;
 741 }
 742
 743 static void alsa_close_capture(ALCdevice *pDevice)
 744 {
 745     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 746
 747     if(data->thread)
 748     {
 749         data->killNow = 1;
 750         StopThread(data->thread);
 751         DestroyRingBuffer(data->ring);
 752     }
 753     psnd_pcm_close(data->pcmHandle);
 754
 755     free(data);
 756     pDevice->ExtraData = NULL;
 757 }
 758
 759 static void alsa_start_capture(ALCdevice *pDevice)
 760 {
 761     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 762     data->doCapture = 1;
 763     if(!data->thread)
 764     {
 765         psnd_pcm_prepare(data->pcmHandle);
 766         psnd_pcm_start(data->pcmHandle);
 767     }
 768 }
 769
 770 static void alsa_stop_capture(ALCdevice *pDevice)
 771 {
 772     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 773     data->doCapture = 0;
 774     if(!data->thread)
 775         psnd_pcm_drain(data->pcmHandle);
 776 }
 777
 778 static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 779 {
 780     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 781     const snd_pcm_channel_area_t *areas = NULL;
 782     snd_pcm_sframes_t frames, commitres;
 783     snd_pcm_uframes_t size, offset;
 784     snd_pcm_state_t state;
 785     int err;
 786
 787     if(data->thread)
 788     {
 789         if(lSamples <= (ALCuint)RingBufferSize(data->ring))
 790             ReadRingBuffer(data->ring, pBuffer, lSamples);
 791         else
 792             SetALCError(ALC_INVALID_VALUE);
 793         return;
 794     }
 795
 796     state = psnd_pcm_state(data->pcmHandle);
 797     if(state == SND_PCM_STATE_XRUN)
 798     {
 799         err = xrun_recovery(data->pcmHandle, -EPIPE);
 800         if(err < 0)
 801         {
 802             AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
 803             return;
 804         }
 805     }
 806
 807     frames = psnd_pcm_avail_update(data->pcmHandle);
 808     if(frames < 0)
 809     {
 810         err = xrun_recovery(data->pcmHandle, frames);
 811         if (err < 0)
 812             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 813         else
 814             frames = psnd_pcm_avail_update(data->pcmHandle);
 815     }
 816     if (frames < (snd_pcm_sframes_t)lSamples)
 817     {
 818         SetALCError(ALC_INVALID_VALUE);
 819         return;
 820     }
 821
 822     // it is possible that contiguous areas are smaller, thus we use a loop
 823     while (lSamples > 0)
 824     {
 825         char *Pointer;
 826         int Count;
 827
 828         size = lSamples;
 829         err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &size);
 830         if (err < 0)
 831         {
 832             err = xrun_recovery(data->pcmHandle, err);
 833             if (err < 0)
 834             {
 835                 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 836                 break;
 837             }
 838             continue;
 839         }
 840
 841         Pointer = (char*)areas->addr + (offset * areas->step / 8);
 842         Count = psnd_pcm_frames_to_bytes(data->pcmHandle, size);
 843
 844         memcpy(pBuffer, Pointer, Count);
 845         pBuffer = (char*)pBuffer + Count;
 846
 847         commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, size);
 848         if (commitres < 0 || (commitres-size) != 0)
 849         {
 850            AL_PRINT("mmap commit error: %s\n",
 851                     psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 852            break;
 853         }
 854
 855         lSamples -= size;
 856     }
 857 }
 858
 859 static ALCuint alsa_available_samples(ALCdevice *pDevice)
 860 {
 861     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 862     snd_pcm_sframes_t frames;
 863     snd_pcm_state_t state;
 864     int err;
 865
 866     if(data->thread)
 867         return RingBufferSize(data->ring);
 868
 869     state = psnd_pcm_state(data->pcmHandle);
 870     if(state == SND_PCM_STATE_XRUN)
 871     {
 872         err = xrun_recovery(data->pcmHandle, -EPIPE);
 873         if(err >= 0)
 874         {
 875             if(data->doCapture)
 876                 err = psnd_pcm_start(data->pcmHandle);
 877         }
 878         if (err < 0)
 879         {
 880             AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
 881             return 0;
 882         }
 883     }
 884
 885     frames = psnd_pcm_avail_update(data->pcmHandle);
 886     if(frames < 0)
 887     {
 888         err = xrun_recovery(data->pcmHandle, frames);
 889         if (err < 0)
 890             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 891         else
 892             frames = psnd_pcm_avail_update(data->pcmHandle);
 893     }
 894     return max(frames, 0);
 895 }
 896
 897
 898 BackendFuncs alsa_funcs = {
 899     alsa_open_playback,
 900     alsa_close_playback,
 901     alsa_open_capture,
 902     alsa_close_capture,
 903     alsa_start_capture,
 904     alsa_stop_capture,
 905     alsa_capture_samples,
 906     alsa_available_samples
 907 };
 908
 909 void alc_alsa_init(BackendFuncs *func_list)
 910 {
 911     snd_ctl_t *handle;
 912     int card, err, dev, idx = 1;
 913     snd_ctl_card_info_t *info;
 914     snd_pcm_info_t *pcminfo;
 915     snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
 916     char name[128];
 917     char *str;
 918
 919     *func_list = alsa_funcs;
 920
 921 #ifdef HAVE_DLFCN_H
 922     alsa_handle = dlopen("libasound.so.2", RTLD_NOW);
 923     if(!alsa_handle)
 924         return;
 925     dlerror();
 926
 927 #define LOAD_FUNC(f) do { \
 928     p##f = (typeof(f)*)dlsym(alsa_handle, #f); \
 929     if((str=dlerror()) != NULL) \
 930     { \
 931         dlclose(alsa_handle); \
 932         alsa_handle = NULL; \
 933         AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
 934         return; \
 935     } \
 936 } while(0)
 937 #else
 938     str = NULL;
 939     alsa_handle = (void*)0xDEADBEEF;
 940 #define LOAD_FUNC(f) p##f = f
 941 #endif
 942
 943 LOAD_FUNC(snd_strerror);
 944 LOAD_FUNC(snd_pcm_open);
 945 LOAD_FUNC(snd_pcm_close);
 946 LOAD_FUNC(snd_pcm_nonblock);
 947 LOAD_FUNC(snd_pcm_frames_to_bytes);
 948 LOAD_FUNC(snd_pcm_hw_params_malloc);
 949 LOAD_FUNC(snd_pcm_hw_params_free);
 950 LOAD_FUNC(snd_pcm_hw_params_any);
 951 LOAD_FUNC(snd_pcm_hw_params_set_access);
 952 LOAD_FUNC(snd_pcm_hw_params_set_format);
 953 LOAD_FUNC(snd_pcm_hw_params_set_channels);
 954 LOAD_FUNC(snd_pcm_hw_params_set_periods_near);
 955 LOAD_FUNC(snd_pcm_hw_params_set_rate_near);
 956 LOAD_FUNC(snd_pcm_hw_params_set_rate);
 957 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near);
 958 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min);
 959 LOAD_FUNC(snd_pcm_hw_params_get_buffer_size);
 960 LOAD_FUNC(snd_pcm_hw_params_get_period_size);
 961 LOAD_FUNC(snd_pcm_hw_params_get_access);
 962 LOAD_FUNC(snd_pcm_hw_params);
 963 LOAD_FUNC(snd_pcm_prepare);
 964 LOAD_FUNC(snd_pcm_start);
 965 LOAD_FUNC(snd_pcm_resume);
 966 LOAD_FUNC(snd_pcm_wait);
 967 LOAD_FUNC(snd_pcm_state);
 968 LOAD_FUNC(snd_pcm_avail_update);
 969 LOAD_FUNC(snd_pcm_areas_silence);
 970 LOAD_FUNC(snd_pcm_mmap_begin);
 971 LOAD_FUNC(snd_pcm_mmap_commit);
 972 LOAD_FUNC(snd_pcm_readi);
 973 LOAD_FUNC(snd_pcm_writei);
 974 LOAD_FUNC(snd_pcm_drain);
 975
 976 LOAD_FUNC(snd_pcm_info_malloc);
 977 LOAD_FUNC(snd_pcm_info_free);
 978 LOAD_FUNC(snd_pcm_info_set_device);
 979 LOAD_FUNC(snd_pcm_info_set_subdevice);
 980 LOAD_FUNC(snd_pcm_info_set_stream);
 981 LOAD_FUNC(snd_pcm_info_get_name);
 982 LOAD_FUNC(snd_ctl_pcm_next_device);
 983 LOAD_FUNC(snd_ctl_pcm_info);
 984 LOAD_FUNC(snd_ctl_open);
 985 LOAD_FUNC(snd_ctl_close);
 986 LOAD_FUNC(snd_ctl_card_info_malloc);
 987 LOAD_FUNC(snd_ctl_card_info_free);
 988 LOAD_FUNC(snd_ctl_card_info);
 989 LOAD_FUNC(snd_ctl_card_info_get_name);
 990 LOAD_FUNC(snd_card_next);
 991
 992 #undef LOAD_FUNC
 993
 994     psnd_ctl_card_info_malloc(&info);
 995     psnd_pcm_info_malloc(&pcminfo);
 996
 997     card = -1;
 998     if(psnd_card_next(&card) < 0 || card < 0)
 999         AL_PRINT("no playback cards found...\n");
1000
1001     alsaDevice = AppendDeviceList("ALSA Software");
1002     allDevNameMap[0].name = AppendAllDeviceList("ALSA Software on default");
1003
1004     while (card >= 0) {
1005         sprintf(name, "hw:%d", card);
1006         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
1007             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
1008             goto next_card;
1009         }
1010         if ((err = psnd_ctl_card_info(handle, info)) < 0) {
1011             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
1012             psnd_ctl_close(handle);
1013             goto next_card;
1014         }
1015
1016         dev = -1;
1017         while (idx < MAX_ALL_DEVICES) {
1018             const char *cname, *dname;
1019
1020             if (psnd_ctl_pcm_next_device(handle, &dev)<0)
1021                 AL_PRINT("snd_ctl_pcm_next_device failed\n");
1022             if (dev < 0)
1023                 break;
1024
1025             psnd_pcm_info_set_device(pcminfo, dev);
1026             psnd_pcm_info_set_subdevice(pcminfo, 0);
1027             psnd_pcm_info_set_stream(pcminfo, stream);
1028             if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
1029                 if (err != -ENOENT)
1030                     AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
1031                 continue;
1032             }
1033
1034             cname = psnd_ctl_card_info_get_name(info);
1035             dname = psnd_pcm_info_get_name(pcminfo);
1036             snprintf(name, sizeof(name), "ALSA Software on %s [%s] (hw:%d,%d)",
1037                      cname, dname, card, dev);
1038             allDevNameMap[idx].name = AppendAllDeviceList(name);
1039             allDevNameMap[idx].card = card;
1040             allDevNameMap[idx].dev = dev;
1041             idx++;
1042         }
1043         psnd_ctl_close(handle);
1044 next_card:
1045         if(psnd_card_next(&card) < 0) {
1046             AL_PRINT("snd_card_next failed\n");
1047             break;
1048         }
1049     }
1050
1051
1052     stream = SND_PCM_STREAM_CAPTURE;
1053
1054     card = -1;
1055     if(psnd_card_next(&card) < 0 || card < 0) {
1056         AL_PRINT("no capture cards found...\n");
1057         psnd_pcm_info_free(pcminfo);
1058         psnd_ctl_card_info_free(info);
1059         return;
1060     }
1061
1062     allCaptureDevNameMap[0].name = AppendCaptureDeviceList("ALSA Capture on default");
1063     idx = 1;
1064
1065     while (card >= 0) {
1066         sprintf(name, "hw:%d", card);
1067         handle = NULL;
1068         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
1069             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
1070         }
1071         if (err >= 0 && (err = psnd_ctl_card_info(handle, info)) < 0) {
1072             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
1073         }
1074         else if (err >= 0)
1075         {
1076             dev = -1;
1077             while (idx < MAX_ALL_DEVICES) {
1078                 const char *cname, *dname;
1079
1080                 if (psnd_ctl_pcm_next_device(handle, &dev)<0)
1081                     AL_PRINT("snd_ctl_pcm_next_device failed\n");
1082                 if (dev < 0)
1083                     break;
1084                 psnd_pcm_info_set_device(pcminfo, dev);
1085                 psnd_pcm_info_set_subdevice(pcminfo, 0);
1086                 psnd_pcm_info_set_stream(pcminfo, stream);
1087                 if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
1088                     if (err != -ENOENT)
1089                         AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
1090                     continue;
1091                 }
1092
1093                 cname = psnd_ctl_card_info_get_name(info);
1094                 dname = psnd_pcm_info_get_name(pcminfo);
1095                 snprintf(name, sizeof(name), "ALSA Capture on %s [%s] (hw:%d,%d)",
1096                          cname, dname, card, dev);
1097                 allCaptureDevNameMap[idx].name = AppendCaptureDeviceList(name);
1098                 allCaptureDevNameMap[idx].card = card;
1099                 allCaptureDevNameMap[idx].dev = dev;
1100                 idx++;
1101             }
1102         }
1103         if(handle) psnd_ctl_close(handle);
1104         if(psnd_card_next(&card) < 0) {
1105             AL_PRINT("snd_card_next failed\n");
1106             break;
1107         }
1108     }
1109     psnd_pcm_info_free(pcminfo);
1110     psnd_ctl_card_info_free(info);
1111 }