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