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((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
 610         err = "any";
 611     /* set interleaved access */
 612     if(err == NULL && (!allowmmap || (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0))
 613     {
 614         if((i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
 615             err = "set access";
 616     }
 617     /* set format (implicitly sets sample bits) */
 618     if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
 619         err = "set format";
 620     /* set channels (implicitly sets frame bits) */
 621     if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
 622         err = "set channels";
 623     /* set rate (implicitly constrains period/buffer parameters) */
 624     if(err == NULL && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0)) < 0)
 625         err = "set rate near";
 626     /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 627     if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
 628         err = "set buffer size near";
 629     /* install and prepare hardware configuration */
 630     if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 631         err = "set params";
 632     if(err != NULL)
 633     {
 634         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 635         psnd_pcm_hw_params_free(p);
 636         psnd_pcm_close(data->pcmHandle);
 637         free(data);
 638         return ALC_FALSE;
 639     }
 640
 641     if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
 642     {
 643         AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
 644         psnd_pcm_hw_params_free(p);
 645         psnd_pcm_close(data->pcmHandle);
 646         free(data);
 647         return ALC_FALSE;
 648     }
 649     if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
 650     {
 651         AL_PRINT("get size failed: %s\n", psnd_strerror(i));
 652         psnd_pcm_hw_params_free(p);
 653         psnd_pcm_close(data->pcmHandle);
 654         free(data);
 655         return ALC_FALSE;
 656     }
 657
 658     psnd_pcm_hw_params_free(p);
 659
 660     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 661     {
 662         ALuint frameSize = aluChannelsFromFormat(pDevice->Format);
 663         frameSize *= aluBytesFromFormat(pDevice->Format);
 664
 665         data->ring = CreateRingBuffer(frameSize, SampleSize);
 666         if(!data->ring)
 667         {
 668             AL_PRINT("ring buffer create failed\n");
 669             psnd_pcm_close(data->pcmHandle);
 670             free(data);
 671             return ALC_FALSE;
 672         }
 673
 674         data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
 675         data->buffer = malloc(data->size);
 676         if(!data->buffer)
 677         {
 678             AL_PRINT("buffer malloc failed\n");
 679             psnd_pcm_close(data->pcmHandle);
 680             DestroyRingBuffer(data->ring);
 681             free(data);
 682             return ALC_FALSE;
 683         }
 684
 685         pDevice->ExtraData = data;
 686         data->thread = StartThread(ALSANoMMapCaptureProc, pDevice);
 687         if(data->thread == NULL)
 688         {
 689             AL_PRINT("Could not create capture thread\n");
 690             pDevice->ExtraData = NULL;
 691             psnd_pcm_close(data->pcmHandle);
 692             DestroyRingBuffer(data->ring);
 693             free(data->buffer);
 694             free(data);
 695             return ALC_FALSE;
 696         }
 697     }
 698     else
 699     {
 700         i = psnd_pcm_prepare(data->pcmHandle);
 701         if(i < 0)
 702         {
 703             AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 704             psnd_pcm_close(data->pcmHandle);
 705             free(data);
 706             return ALC_FALSE;
 707         }
 708         pDevice->ExtraData = data;
 709     }
 710
 711     return ALC_TRUE;
 712 }
 713
 714 static void alsa_close_capture(ALCdevice *pDevice)
 715 {
 716     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 717
 718     if(data->thread)
 719     {
 720         data->killNow = 1;
 721         StopThread(data->thread);
 722         DestroyRingBuffer(data->ring);
 723     }
 724     psnd_pcm_close(data->pcmHandle);
 725
 726     free(data);
 727     pDevice->ExtraData = NULL;
 728 }
 729
 730 static void alsa_start_capture(ALCdevice *pDevice)
 731 {
 732     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 733     data->doCapture = 1;
 734     if(!data->thread)
 735     {
 736         psnd_pcm_prepare(data->pcmHandle);
 737         psnd_pcm_start(data->pcmHandle);
 738     }
 739 }
 740
 741 static void alsa_stop_capture(ALCdevice *pDevice)
 742 {
 743     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 744     data->doCapture = 0;
 745     if(!data->thread)
 746         psnd_pcm_drain(data->pcmHandle);
 747 }
 748
 749 static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 750 {
 751     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 752     const snd_pcm_channel_area_t *areas = NULL;
 753     snd_pcm_sframes_t frames, commitres;
 754     snd_pcm_uframes_t size, offset;
 755     snd_pcm_state_t state;
 756     int err;
 757
 758     if(data->thread)
 759     {
 760         if(lSamples <= (ALCuint)RingBufferSize(data->ring))
 761             ReadRingBuffer(data->ring, pBuffer, lSamples);
 762         else
 763             SetALCError(ALC_INVALID_VALUE);
 764         return;
 765     }
 766
 767     state = psnd_pcm_state(data->pcmHandle);
 768     if(state == SND_PCM_STATE_XRUN)
 769     {
 770         err = xrun_recovery(data->pcmHandle, -EPIPE);
 771         if(err < 0)
 772         {
 773             AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
 774             return;
 775         }
 776     }
 777
 778     frames = psnd_pcm_avail_update(data->pcmHandle);
 779     if(frames < 0)
 780     {
 781         err = xrun_recovery(data->pcmHandle, frames);
 782         if (err < 0)
 783             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 784         else
 785             frames = psnd_pcm_avail_update(data->pcmHandle);
 786     }
 787     if (frames < (snd_pcm_sframes_t)lSamples)
 788     {
 789         SetALCError(ALC_INVALID_VALUE);
 790         return;
 791     }
 792
 793     // it is possible that contiguous areas are smaller, thus we use a loop
 794     while (lSamples > 0)
 795     {
 796         char *Pointer;
 797         int Count;
 798
 799         size = lSamples;
 800         err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &size);
 801         if (err < 0)
 802         {
 803             err = xrun_recovery(data->pcmHandle, err);
 804             if (err < 0)
 805             {
 806                 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 807                 break;
 808             }
 809             continue;
 810         }
 811
 812         Pointer = (char*)areas->addr + (offset * areas->step / 8);
 813         Count = psnd_pcm_frames_to_bytes(data->pcmHandle, size);
 814
 815         memcpy(pBuffer, Pointer, Count);
 816         pBuffer = (char*)pBuffer + Count;
 817
 818         commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, size);
 819         if (commitres < 0 || (commitres-size) != 0)
 820         {
 821            AL_PRINT("mmap commit error: %s\n",
 822                     psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 823            break;
 824         }
 825
 826         lSamples -= size;
 827     }
 828 }
 829
 830 static ALCuint alsa_available_samples(ALCdevice *pDevice)
 831 {
 832     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 833     snd_pcm_sframes_t frames;
 834     snd_pcm_state_t state;
 835     int err;
 836
 837     if(data->thread)
 838         return RingBufferSize(data->ring);
 839
 840     state = psnd_pcm_state(data->pcmHandle);
 841     if(state == SND_PCM_STATE_XRUN)
 842     {
 843         err = xrun_recovery(data->pcmHandle, -EPIPE);
 844         if(err >= 0)
 845         {
 846             if(data->doCapture)
 847                 err = psnd_pcm_start(data->pcmHandle);
 848         }
 849         if (err < 0)
 850         {
 851             AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
 852             return 0;
 853         }
 854     }
 855
 856     frames = psnd_pcm_avail_update(data->pcmHandle);
 857     if(frames < 0)
 858     {
 859         err = xrun_recovery(data->pcmHandle, frames);
 860         if (err < 0)
 861             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 862         else
 863             frames = psnd_pcm_avail_update(data->pcmHandle);
 864     }
 865     return max(frames, 0);
 866 }
 867
 868
 869 BackendFuncs alsa_funcs = {
 870     alsa_open_playback,
 871     alsa_close_playback,
 872     alsa_open_capture,
 873     alsa_close_capture,
 874     alsa_start_capture,
 875     alsa_stop_capture,
 876     alsa_capture_samples,
 877     alsa_available_samples
 878 };
 879
 880 void alc_alsa_init(BackendFuncs *func_list)
 881 {
 882     snd_ctl_t *handle;
 883     int card, err, dev, idx = 1;
 884     snd_ctl_card_info_t *info;
 885     snd_pcm_info_t *pcminfo;
 886     snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
 887     char name[128];
 888     char *str;
 889
 890     *func_list = alsa_funcs;
 891
 892 #ifdef HAVE_DLFCN_H
 893     alsa_handle = dlopen("libasound.so.2", RTLD_NOW);
 894     if(!alsa_handle)
 895         return;
 896     dlerror();
 897
 898 #define LOAD_FUNC(f) do { \
 899     p##f = (typeof(f)*)dlsym(alsa_handle, #f); \
 900     if((str=dlerror()) != NULL) \
 901     { \
 902         dlclose(alsa_handle); \
 903         alsa_handle = NULL; \
 904         AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
 905         return; \
 906     } \
 907 } while(0)
 908 #else
 909     str = NULL;
 910     alsa_handle = (void*)0xDEADBEEF;
 911 #define LOAD_FUNC(f) p##f = f
 912 #endif
 913
 914 LOAD_FUNC(snd_strerror);
 915 LOAD_FUNC(snd_pcm_open);
 916 LOAD_FUNC(snd_pcm_close);
 917 LOAD_FUNC(snd_pcm_nonblock);
 918 LOAD_FUNC(snd_pcm_frames_to_bytes);
 919 LOAD_FUNC(snd_pcm_hw_params_malloc);
 920 LOAD_FUNC(snd_pcm_hw_params_free);
 921 LOAD_FUNC(snd_pcm_hw_params_any);
 922 LOAD_FUNC(snd_pcm_hw_params_set_access);
 923 LOAD_FUNC(snd_pcm_hw_params_set_format);
 924 LOAD_FUNC(snd_pcm_hw_params_set_channels);
 925 LOAD_FUNC(snd_pcm_hw_params_set_periods_near);
 926 LOAD_FUNC(snd_pcm_hw_params_set_rate_near);
 927 LOAD_FUNC(snd_pcm_hw_params_set_rate);
 928 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near);
 929 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min);
 930 LOAD_FUNC(snd_pcm_hw_params_get_buffer_size);
 931 LOAD_FUNC(snd_pcm_hw_params_get_period_size);
 932 LOAD_FUNC(snd_pcm_hw_params_get_access);
 933 LOAD_FUNC(snd_pcm_hw_params);
 934 LOAD_FUNC(snd_pcm_prepare);
 935 LOAD_FUNC(snd_pcm_start);
 936 LOAD_FUNC(snd_pcm_resume);
 937 LOAD_FUNC(snd_pcm_wait);
 938 LOAD_FUNC(snd_pcm_state);
 939 LOAD_FUNC(snd_pcm_avail_update);
 940 LOAD_FUNC(snd_pcm_areas_silence);
 941 LOAD_FUNC(snd_pcm_mmap_begin);
 942 LOAD_FUNC(snd_pcm_mmap_commit);
 943 LOAD_FUNC(snd_pcm_readi);
 944 LOAD_FUNC(snd_pcm_writei);
 945 LOAD_FUNC(snd_pcm_drain);
 946
 947 LOAD_FUNC(snd_pcm_info_malloc);
 948 LOAD_FUNC(snd_pcm_info_free);
 949 LOAD_FUNC(snd_pcm_info_set_device);
 950 LOAD_FUNC(snd_pcm_info_set_subdevice);
 951 LOAD_FUNC(snd_pcm_info_set_stream);
 952 LOAD_FUNC(snd_pcm_info_get_name);
 953 LOAD_FUNC(snd_ctl_pcm_next_device);
 954 LOAD_FUNC(snd_ctl_pcm_info);
 955 LOAD_FUNC(snd_ctl_open);
 956 LOAD_FUNC(snd_ctl_close);
 957 LOAD_FUNC(snd_ctl_card_info_malloc);
 958 LOAD_FUNC(snd_ctl_card_info_free);
 959 LOAD_FUNC(snd_ctl_card_info);
 960 LOAD_FUNC(snd_ctl_card_info_get_name);
 961 LOAD_FUNC(snd_card_next);
 962
 963 #undef LOAD_FUNC
 964
 965     psnd_ctl_card_info_malloc(&info);
 966     psnd_pcm_info_malloc(&pcminfo);
 967
 968     card = -1;
 969     if(psnd_card_next(&card) < 0 || card < 0)
 970         AL_PRINT("no playback cards found...\n");
 971
 972     alsaDevice = AppendDeviceList("ALSA Software");
 973     allDevNameMap[0].name = AppendAllDeviceList("ALSA Software on default");
 974
 975     while (card >= 0) {
 976         sprintf(name, "hw:%d", card);
 977         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
 978             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
 979             goto next_card;
 980         }
 981         if ((err = psnd_ctl_card_info(handle, info)) < 0) {
 982             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
 983             psnd_ctl_close(handle);
 984             goto next_card;
 985         }
 986
 987         dev = -1;
 988         while (idx < MAX_ALL_DEVICES) {
 989             const char *cname, *dname;
 990
 991             if (psnd_ctl_pcm_next_device(handle, &dev)<0)
 992                 AL_PRINT("snd_ctl_pcm_next_device failed\n");
 993             if (dev < 0)
 994                 break;
 995
 996             psnd_pcm_info_set_device(pcminfo, dev);
 997             psnd_pcm_info_set_subdevice(pcminfo, 0);
 998             psnd_pcm_info_set_stream(pcminfo, stream);
 999             if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
1000                 if (err != -ENOENT)
1001                     AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
1002                 continue;
1003             }
1004
1005             cname = psnd_ctl_card_info_get_name(info);
1006             dname = psnd_pcm_info_get_name(pcminfo);
1007             snprintf(name, sizeof(name), "ALSA Software on %s [%s] (hw:%d,%d)",
1008                      cname, dname, card, dev);
1009             allDevNameMap[idx].name = AppendAllDeviceList(name);
1010             allDevNameMap[idx].card = card;
1011             allDevNameMap[idx].dev = dev;
1012             idx++;
1013         }
1014         psnd_ctl_close(handle);
1015 next_card:
1016         if(psnd_card_next(&card) < 0) {
1017             AL_PRINT("snd_card_next failed\n");
1018             break;
1019         }
1020     }
1021
1022
1023     stream = SND_PCM_STREAM_CAPTURE;
1024
1025     card = -1;
1026     if(psnd_card_next(&card) < 0 || card < 0) {
1027         AL_PRINT("no capture cards found...\n");
1028         psnd_pcm_info_free(pcminfo);
1029         psnd_ctl_card_info_free(info);
1030         return;
1031     }
1032
1033     allCaptureDevNameMap[0].name = AppendCaptureDeviceList("ALSA Capture on default");
1034     idx = 1;
1035
1036     while (card >= 0) {
1037         sprintf(name, "hw:%d", card);
1038         handle = NULL;
1039         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
1040             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
1041         }
1042         if (err >= 0 && (err = psnd_ctl_card_info(handle, info)) < 0) {
1043             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
1044         }
1045         else if (err >= 0)
1046         {
1047             dev = -1;
1048             while (idx < MAX_ALL_DEVICES) {
1049                 const char *cname, *dname;
1050
1051                 if (psnd_ctl_pcm_next_device(handle, &dev)<0)
1052                     AL_PRINT("snd_ctl_pcm_next_device failed\n");
1053                 if (dev < 0)
1054                     break;
1055                 psnd_pcm_info_set_device(pcminfo, dev);
1056                 psnd_pcm_info_set_subdevice(pcminfo, 0);
1057                 psnd_pcm_info_set_stream(pcminfo, stream);
1058                 if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
1059                     if (err != -ENOENT)
1060                         AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
1061                     continue;
1062                 }
1063
1064                 cname = psnd_ctl_card_info_get_name(info);
1065                 dname = psnd_pcm_info_get_name(pcminfo);
1066                 snprintf(name, sizeof(name), "ALSA Capture on %s [%s] (hw:%d,%d)",
1067                          cname, dname, card, dev);
1068                 allCaptureDevNameMap[idx].name = AppendCaptureDeviceList(name);
1069                 allCaptureDevNameMap[idx].card = card;
1070                 allCaptureDevNameMap[idx].dev = dev;
1071                 idx++;
1072             }
1073         }
1074         if(handle) psnd_ctl_close(handle);
1075         if(psnd_card_next(&card) < 0) {
1076             AL_PRINT("snd_card_next failed\n");
1077             break;
1078         }
1079     }
1080     psnd_pcm_info_free(pcminfo);
1081     psnd_ctl_card_info_free(info);
1082 }