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