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         Sleep(200);
 506         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 507     }
 508     if(i >= 0)
 509     {
 510         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 511         if(i < 0)
 512             psnd_pcm_close(data->pcmHandle);
 513     }
 514     if(i < 0)
 515     {
 516         free(data);
 517         AL_PRINT("Could not open playback device '%s': %s\n", driver, psnd_strerror(i));
 518         return ALC_FALSE;
 519     }
 520
 521     device->szDeviceName = strdup(deviceName);
 522     device->ExtraData = data;
 523     return ALC_TRUE;
 524 }
 525
 526 static void alsa_close_playback(ALCdevice *device)
 527 {
 528     alsa_data *data = (alsa_data*)device->ExtraData;
 529
 530     psnd_pcm_close(data->pcmHandle);
 531     free(data);
 532     device->ExtraData = NULL;
 533 }
 534
 535 static ALCboolean alsa_reset_playback(ALCdevice *device)
 536 {
 537     alsa_data *data = (alsa_data*)device->ExtraData;
 538     snd_pcm_uframes_t periodSizeInFrames;
 539     unsigned int periodLen, bufferLen;
 540     snd_pcm_sw_params_t *sp = NULL;
 541     snd_pcm_hw_params_t *p = NULL;
 542     snd_pcm_access_t access;
 543     snd_pcm_format_t format;
 544     unsigned int periods;
 545     unsigned int rate;
 546     int allowmmap;
 547     char *err;
 548     int i;
 549
 550
 551     switch(aluBytesFromFormat(device->Format))
 552     {
 553         case 1:
 554             format = SND_PCM_FORMAT_U8;
 555             break;
 556         case 2:
 557             format = SND_PCM_FORMAT_S16;
 558             break;
 559         case 4:
 560             format = SND_PCM_FORMAT_FLOAT;
 561             break;
 562         default:
 563             AL_PRINT("Unknown format: 0x%x\n", device->Format);
 564             return ALC_FALSE;
 565     }
 566
 567     allowmmap = GetConfigValueBool("alsa", "mmap", 1);
 568     periods = device->NumUpdates;
 569     periodLen = (ALuint64)device->UpdateSize * 1000000 / device->Frequency;
 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) periods--;
 581         if((i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
 582             err = "set access";
 583     }
 584     /* set format (implicitly sets sample bits) */
 585     if(i >= 0 && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
 586     {
 587         switch(aluChannelsFromFormat(device->Format))
 588         {
 589             case 1: device->Format = AL_FORMAT_MONO_FLOAT32; break;
 590             case 2: device->Format = AL_FORMAT_STEREO_FLOAT32; break;
 591             case 4: device->Format = AL_FORMAT_QUAD32; break;
 592             case 6: device->Format = AL_FORMAT_51CHN32; break;
 593             case 7: device->Format = AL_FORMAT_61CHN32; break;
 594             case 8: device->Format = AL_FORMAT_71CHN32; break;
 595         }
 596         if(format == SND_PCM_FORMAT_FLOAT ||
 597            (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_FLOAT)) < 0)
 598         {
 599             switch(aluChannelsFromFormat(device->Format))
 600             {
 601                 case 1: device->Format = AL_FORMAT_MONO16; break;
 602                 case 2: device->Format = AL_FORMAT_STEREO16; break;
 603                 case 4: device->Format = AL_FORMAT_QUAD16; break;
 604                 case 6: device->Format = AL_FORMAT_51CHN16; break;
 605                 case 7: device->Format = AL_FORMAT_61CHN16; break;
 606                 case 8: device->Format = AL_FORMAT_71CHN16; break;
 607             }
 608             if(format == SND_PCM_FORMAT_S16 ||
 609                (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_S16)) < 0)
 610             {
 611                 switch(aluChannelsFromFormat(device->Format))
 612                 {
 613                     case 1: device->Format = AL_FORMAT_MONO8; break;
 614                     case 2: device->Format = AL_FORMAT_STEREO8; break;
 615                     case 4: device->Format = AL_FORMAT_QUAD8; break;
 616                     case 6: device->Format = AL_FORMAT_51CHN8; break;
 617                     case 7: device->Format = AL_FORMAT_61CHN8; break;
 618                     case 8: device->Format = AL_FORMAT_71CHN8; break;
 619                 }
 620                 if(format == SND_PCM_FORMAT_U8 ||
 621                    (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_U8)) < 0)
 622                     err = "set format";
 623             }
 624         }
 625     }
 626     /* set channels (implicitly sets frame bits) */
 627     if(i >= 0 && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(device->Format))) < 0)
 628     {
 629         switch(aluBytesFromFormat(device->Format))
 630         {
 631             case 1: device->Format = AL_FORMAT_STEREO8; break;
 632             case 2: device->Format = AL_FORMAT_STEREO16; break;
 633             case 4: device->Format = AL_FORMAT_STEREO_FLOAT32; break;
 634         }
 635         if((i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, 2)) < 0)
 636         {
 637             switch(aluBytesFromFormat(device->Format))
 638             {
 639                 case 1: device->Format = AL_FORMAT_MONO8; break;
 640                 case 2: device->Format = AL_FORMAT_MONO16; break;
 641                 case 4: device->Format = AL_FORMAT_MONO_FLOAT32; break;
 642             }
 643             if((i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, 1)) < 0)
 644                 err = "set channels";
 645         }
 646     }
 647     if(i >= 0 && (i=psnd_pcm_hw_params_set_rate_resample(data->pcmHandle, p, 0)) < 0)
 648     {
 649         AL_PRINT("Failed to disable ALSA resampler\n");
 650         i = 0;
 651     }
 652     /* set rate (implicitly constrains period/buffer parameters) */
 653     if(i >= 0 && (i=psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &rate, NULL)) < 0)
 654         err = "set rate near";
 655     /* set buffer time (implicitly constrains period/buffer parameters) */
 656     bufferLen = periodLen * periods;
 657     if(i >= 0 && (i=psnd_pcm_hw_params_set_buffer_time_near(data->pcmHandle, p, &bufferLen, NULL)) < 0)
 658         err = "set buffer time near";
 659     /* set period time in frame units (implicitly sets buffer size/bytes/time and period size/bytes) */
 660     if(i >= 0 && (i=psnd_pcm_hw_params_set_period_time_near(data->pcmHandle, p, &periodLen, NULL)) < 0)
 661         err = "set period time near";
 662     /* install and prepare hardware configuration */
 663     if(i >= 0 && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 664         err = "set params";
 665     if(i >= 0 && (i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
 666         err = "get access";
 667     if(i >= 0 && (i=psnd_pcm_hw_params_get_period_size(p, &periodSizeInFrames, NULL)) < 0)
 668         err = "get period size";
 669     if(i >= 0 && (i=psnd_pcm_hw_params_get_periods(p, &periods, NULL)) < 0)
 670         err = "get periods";
 671     if(i < 0)
 672     {
 673         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 674         psnd_pcm_hw_params_free(p);
 675         return ALC_FALSE;
 676     }
 677
 678     psnd_pcm_hw_params_free(p);
 679
 680     err = NULL;
 681     psnd_pcm_sw_params_malloc(&sp);
 682
 683     if((i=psnd_pcm_sw_params_current(data->pcmHandle, sp)) != 0)
 684         err = "sw current";
 685     if(i == 0 && (i=psnd_pcm_sw_params_set_avail_min(data->pcmHandle, sp, periodSizeInFrames)) != 0)
 686         err = "sw set avail min";
 687     if(i == 0 && (i=psnd_pcm_sw_params(data->pcmHandle, sp)) != 0)
 688         err = "sw set params";
 689     if(i != 0)
 690     {
 691         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 692         psnd_pcm_sw_params_free(sp);
 693         return ALC_FALSE;
 694     }
 695
 696     psnd_pcm_sw_params_free(sp);
 697
 698     device->TimeRes = (ALuint64)periodSizeInFrames * 1000000000 / rate;
 699     device->Frequency = rate;
 700
 701     SetDefaultChannelOrder(device);
 702
 703     data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, periodSizeInFrames);
 704     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 705     {
 706         /* Increase periods by one, since the temp buffer counts as an extra
 707          * period */
 708         periods++;
 709         data->buffer = malloc(data->size);
 710         if(!data->buffer)
 711         {
 712             AL_PRINT("buffer malloc failed\n");
 713             return ALC_FALSE;
 714         }
 715         device->UpdateSize = periodSizeInFrames;
 716         device->NumUpdates = periods;
 717         data->thread = StartThread(ALSANoMMapProc, device);
 718     }
 719     else
 720     {
 721         i = psnd_pcm_prepare(data->pcmHandle);
 722         if(i < 0)
 723         {
 724             AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 725             return ALC_FALSE;
 726         }
 727         device->UpdateSize = periodSizeInFrames;
 728         device->NumUpdates = periods;
 729         data->thread = StartThread(ALSAProc, device);
 730     }
 731     if(data->thread == NULL)
 732     {
 733         AL_PRINT("Could not create playback thread\n");
 734         free(data->buffer);
 735         data->buffer = NULL;
 736         return ALC_FALSE;
 737     }
 738
 739     return ALC_TRUE;
 740 }
 741
 742 static void alsa_stop_playback(ALCdevice *device)
 743 {
 744     alsa_data *data = (alsa_data*)device->ExtraData;
 745
 746     if(data->thread)
 747     {
 748         data->killNow = 1;
 749         StopThread(data->thread);
 750         data->thread = NULL;
 751     }
 752     data->killNow = 0;
 753     free(data->buffer);
 754     data->buffer = NULL;
 755 }
 756
 757
 758 static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName)
 759 {
 760     snd_pcm_hw_params_t *p;
 761     snd_pcm_uframes_t bufferSizeInFrames;
 762     snd_pcm_format_t format;
 763     ALuint frameSize;
 764     alsa_data *data;
 765     char driver[64];
 766     char *err;
 767     int i;
 768
 769     if(!alsa_load())
 770         return ALC_FALSE;
 771
 772     strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
 773     driver[sizeof(driver)-1] = 0;
 774
 775     if(!allCaptureDevNameMap)
 776         allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
 777
 778     if(!deviceName)
 779         deviceName = allCaptureDevNameMap[0].name;
 780     else
 781     {
 782         size_t idx;
 783
 784         for(idx = 0;idx < numCaptureDevNames;idx++)
 785         {
 786             if(allCaptureDevNameMap[idx].name &&
 787                strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
 788             {
 789                 if(idx > 0)
 790                     sprintf(driver, "plughw:%d,%d", allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
 791                 break;
 792             }
 793         }
 794         if(idx == numCaptureDevNames)
 795             return ALC_FALSE;
 796     }
 797
 798     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 799
 800     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 801     if(i < 0)
 802     {
 803         Sleep(200);
 804         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 805     }
 806     if(i < 0)
 807     {
 808         AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
 809         free(data);
 810         return ALC_FALSE;
 811     }
 812
 813     switch(aluBytesFromFormat(pDevice->Format))
 814     {
 815         case 1:
 816             format = SND_PCM_FORMAT_U8;
 817             break;
 818         case 2:
 819             format = SND_PCM_FORMAT_S16;
 820             break;
 821         case 4:
 822             format = SND_PCM_FORMAT_FLOAT;
 823             break;
 824         default:
 825             AL_PRINT("Unknown format: 0x%x\n", pDevice->Format);
 826             goto error;
 827     }
 828
 829     err = NULL;
 830     bufferSizeInFrames = pDevice->UpdateSize * pDevice->NumUpdates;
 831     psnd_pcm_hw_params_malloc(&p);
 832
 833     if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
 834         err = "any";
 835     /* set interleaved access */
 836     if(i >= 0 && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
 837         err = "set access";
 838     /* set format (implicitly sets sample bits) */
 839     if(i >= 0 && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
 840         err = "set format";
 841     /* set channels (implicitly sets frame bits) */
 842     if(i >= 0 && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
 843         err = "set channels";
 844     /* set rate (implicitly constrains period/buffer parameters) */
 845     if(i >= 0 && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, pDevice->Frequency, 0)) < 0)
 846         err = "set rate near";
 847     /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 848     if(i >= 0 && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
 849         err = "set buffer size near";
 850     /* install and prepare hardware configuration */
 851     if(i >= 0 && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 852         err = "set params";
 853     if(i < 0)
 854     {
 855         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 856         psnd_pcm_hw_params_free(p);
 857         goto error;
 858     }
 859
 860     if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
 861     {
 862         AL_PRINT("get size failed: %s\n", psnd_strerror(i));
 863         psnd_pcm_hw_params_free(p);
 864         goto error;
 865     }
 866
 867     psnd_pcm_hw_params_free(p);
 868
 869     frameSize = aluFrameSizeFromFormat(pDevice->Format);
 870
 871     data->ring = CreateRingBuffer(frameSize, pDevice->UpdateSize*pDevice->NumUpdates);
 872     if(!data->ring)
 873     {
 874         AL_PRINT("ring buffer create failed\n");
 875         goto error;
 876     }
 877
 878     data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
 879     data->buffer = malloc(data->size);
 880     if(!data->buffer)
 881     {
 882         AL_PRINT("buffer malloc failed\n");
 883         goto error;
 884     }
 885
 886     pDevice->szDeviceName = strdup(deviceName);
 887
 888     pDevice->ExtraData = data;
 889     return ALC_TRUE;
 890
 891 error:
 892     free(data->buffer);
 893     DestroyRingBuffer(data->ring);
 894     psnd_pcm_close(data->pcmHandle);
 895     free(data);
 896
 897     pDevice->ExtraData = NULL;
 898     return ALC_FALSE;
 899 }
 900
 901 static void alsa_close_capture(ALCdevice *pDevice)
 902 {
 903     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 904
 905     psnd_pcm_close(data->pcmHandle);
 906     DestroyRingBuffer(data->ring);
 907
 908     free(data->buffer);
 909     free(data);
 910     pDevice->ExtraData = NULL;
 911 }
 912
 913 static void alsa_start_capture(ALCdevice *Device)
 914 {
 915     alsa_data *data = (alsa_data*)Device->ExtraData;
 916     int err;
 917
 918     err = psnd_pcm_start(data->pcmHandle);
 919     if(err < 0)
 920     {
 921         AL_PRINT("start failed: %s\n", psnd_strerror(err));
 922         aluHandleDisconnect(Device);
 923     }
 924     else
 925         data->doCapture = AL_TRUE;
 926 }
 927
 928 static void alsa_stop_capture(ALCdevice *Device)
 929 {
 930     alsa_data *data = (alsa_data*)Device->ExtraData;
 931     psnd_pcm_drain(data->pcmHandle);
 932     data->doCapture = AL_FALSE;
 933 }
 934
 935 static ALCuint alsa_available_samples(ALCdevice *Device)
 936 {
 937     alsa_data *data = (alsa_data*)Device->ExtraData;
 938     snd_pcm_sframes_t avail;
 939
 940     avail = (Device->Connected ? psnd_pcm_avail_update(data->pcmHandle) : 0);
 941     if(avail < 0)
 942     {
 943         AL_PRINT("avail update failed: %s\n", psnd_strerror(avail));
 944
 945         if((avail=psnd_pcm_recover(data->pcmHandle, avail, 1)) >= 0)
 946         {
 947             if(data->doCapture)
 948                 avail = psnd_pcm_start(data->pcmHandle);
 949             if(avail >= 0)
 950                 avail = psnd_pcm_avail_update(data->pcmHandle);
 951         }
 952         if(avail < 0)
 953         {
 954             AL_PRINT("restore error: %s\n", psnd_strerror(avail));
 955             aluHandleDisconnect(Device);
 956         }
 957     }
 958     while(avail > 0)
 959     {
 960         snd_pcm_sframes_t amt;
 961
 962         amt = psnd_pcm_bytes_to_frames(data->pcmHandle, data->size);
 963         if(avail < amt) amt = avail;
 964
 965         amt = psnd_pcm_readi(data->pcmHandle, data->buffer, amt);
 966         if(amt < 0)
 967         {
 968             AL_PRINT("read error: %s\n", psnd_strerror(amt));
 969
 970             if(amt == -EAGAIN)
 971                 continue;
 972             if((amt=psnd_pcm_recover(data->pcmHandle, amt, 1)) >= 0)
 973             {
 974                 if(data->doCapture)
 975                     amt = psnd_pcm_start(data->pcmHandle);
 976                 if(amt >= 0)
 977                     amt = psnd_pcm_avail_update(data->pcmHandle);
 978             }
 979             if(amt < 0)
 980             {
 981                 AL_PRINT("restore error: %s\n", psnd_strerror(amt));
 982                 aluHandleDisconnect(Device);
 983                 break;
 984             }
 985             avail = amt;
 986             continue;
 987         }
 988
 989         WriteRingBuffer(data->ring, data->buffer, amt);
 990         avail -= amt;
 991     }
 992
 993     return RingBufferSize(data->ring);
 994 }
 995
 996 static void alsa_capture_samples(ALCdevice *Device, ALCvoid *Buffer, ALCuint Samples)
 997 {
 998     alsa_data *data = (alsa_data*)Device->ExtraData;
 999
1000     if(Samples <= alsa_available_samples(Device))
1001         ReadRingBuffer(data->ring, Buffer, Samples);
1002     else
1003         alcSetError(Device, ALC_INVALID_VALUE);
1004 }
1005
1006 static ALuint64 alsa_get_time(ALCdevice *Device)
1007 {
1008     return Device->SamplesPlayed * 1000000000 / Device->Frequency;
1009 }
1010
1011
1012 BackendFuncs alsa_funcs = {
1013     alsa_open_playback,
1014     alsa_close_playback,
1015     alsa_reset_playback,
1016     alsa_stop_playback,
1017     alsa_open_capture,
1018     alsa_close_capture,
1019     alsa_start_capture,
1020     alsa_stop_capture,
1021     alsa_capture_samples,
1022     alsa_available_samples,
1023     alsa_get_time
1024 };
1025
1026 void alc_alsa_init(BackendFuncs *func_list)
1027 {
1028     *func_list = alsa_funcs;
1029 }
1030
1031 void alc_alsa_deinit(void)
1032 {
1033     ALuint i;
1034
1035     for(i = 0;i < numDevNames;++i)
1036         free(allDevNameMap[i].name);
1037     free(allDevNameMap);
1038     allDevNameMap = NULL;
1039     numDevNames = 0;
1040
1041     for(i = 0;i < numCaptureDevNames;++i)
1042         free(allCaptureDevNameMap[i].name);
1043     free(allCaptureDevNameMap);
1044     allCaptureDevNameMap = NULL;
1045     numCaptureDevNames = 0;
1046
1047     if(alsa_handle)
1048     {
1049 #ifdef HAVE_DLFCN_H
1050         dlclose(alsa_handle);
1051 #endif
1052         alsa_handle = NULL;
1053     }
1054 }
1055
1056 void alc_alsa_probe(int type)
1057 {
1058     ALuint i;
1059
1060     if(!alsa_load())
1061         return;
1062
1063     if(type == DEVICE_PROBE)
1064         AppendDeviceList(alsaDevice);
1065     else if(type == ALL_DEVICE_PROBE)
1066     {
1067         for(i = 0;i < numDevNames;++i)
1068             free(allDevNameMap[i].name);
1069
1070         free(allDevNameMap);
1071         allDevNameMap = probe_devices(SND_PCM_STREAM_PLAYBACK, &numDevNames);
1072
1073         for(i = 0;i < numDevNames;++i)
1074             AppendAllDeviceList(allDevNameMap[i].name);
1075     }
1076     else if(type == CAPTURE_DEVICE_PROBE)
1077     {
1078         for(i = 0;i < numCaptureDevNames;++i)
1079             free(allCaptureDevNameMap[i].name);
1080
1081         free(allCaptureDevNameMap);
1082         allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
1083
1084         for(i = 0;i < numCaptureDevNames;++i)
1085             AppendCaptureDeviceList(allCaptureDevNameMap[i].name);
1086     }
1087 }