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