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