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     if(err == -EINTR || err == -EPIPE || err == -ESTRPIPE)
 306     {
 307         err = psnd_pcm_recover(handle, err, 1);
 308         if(err >= 0)
 309             err = psnd_pcm_prepare(handle);
 310         if(err < 0)
 311             AL_PRINT("recover failed: %s\n", psnd_strerror(err));
 312     }
 313     return err;
 314 }
 315
 316 static int verify_state(snd_pcm_t *handle)
 317 {
 318     snd_pcm_state_t state = psnd_pcm_state(handle);
 319     if(state == SND_PCM_STATE_DISCONNECTED)
 320         return -ENODEV;
 321     if(state == SND_PCM_STATE_XRUN)
 322     {
 323         int err = xrun_recovery(handle, -EPIPE);
 324         if(err < 0) return err;
 325     }
 326     else if(state == SND_PCM_STATE_SUSPENDED)
 327     {
 328         int err = xrun_recovery(handle, -ESTRPIPE);
 329         if(err < 0) return err;
 330     }
 331
 332     return state;
 333 }
 334
 335
 336 static ALuint ALSAProc(ALvoid *ptr)
 337 {
 338     ALCdevice *pDevice = (ALCdevice*)ptr;
 339     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 340     const snd_pcm_channel_area_t *areas = NULL;
 341     snd_pcm_sframes_t avail, commitres;
 342     snd_pcm_uframes_t offset, frames;
 343     char *WritePtr;
 344     int err;
 345
 346     SetRTPriority();
 347
 348     while(!data->killNow)
 349     {
 350         int state = verify_state(data->pcmHandle);
 351         if(state < 0)
 352         {
 353             AL_PRINT("Invalid state detected: %s\n", psnd_strerror(state));
 354             aluHandleDisconnect(pDevice);
 355             break;
 356         }
 357
 358         avail = psnd_pcm_avail_update(data->pcmHandle);
 359         if(avail < 0)
 360         {
 361             AL_PRINT("available update failed: %s\n", psnd_strerror(avail));
 362             continue;
 363         }
 364
 365         // make sure there's frames to process
 366         if((snd_pcm_uframes_t)avail < pDevice->UpdateSize)
 367         {
 368             if(state != SND_PCM_STATE_RUNNING)
 369             {
 370                 err = psnd_pcm_start(data->pcmHandle);
 371                 if(err < 0)
 372                 {
 373                     AL_PRINT("start failed: %s\n", psnd_strerror(err));
 374                     continue;
 375                 }
 376             }
 377             if(psnd_pcm_wait(data->pcmHandle, 1000) == 0)
 378                 AL_PRINT("Wait timeout... buffer size too low?\n");
 379             continue;
 380         }
 381         avail -= avail%pDevice->UpdateSize;
 382
 383         // it is possible that contiguous areas are smaller, thus we use a loop
 384         while(avail > 0)
 385         {
 386             frames = avail;
 387
 388             err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &frames);
 389             if(err < 0)
 390             {
 391                 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 392                 break;
 393             }
 394
 395             WritePtr = (char*)areas->addr + (offset * areas->step / 8);
 396             aluMixData(pDevice, WritePtr, frames);
 397
 398             commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, frames);
 399             if(commitres < 0 || (commitres-frames) != 0)
 400             {
 401                 AL_PRINT("mmap commit error: %s\n",
 402                          psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 403                 break;
 404             }
 405
 406             avail -= frames;
 407         }
 408     }
 409
 410     return 0;
 411 }
 412
 413 static ALuint ALSANoMMapProc(ALvoid *ptr)
 414 {
 415     ALCdevice *pDevice = (ALCdevice*)ptr;
 416     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 417     snd_pcm_sframes_t avail;
 418     char *WritePtr;
 419
 420     SetRTPriority();
 421
 422     while(!data->killNow)
 423     {
 424         int state = verify_state(data->pcmHandle);
 425         if(state < 0)
 426         {
 427             AL_PRINT("Invalid state detected: %s\n", psnd_strerror(state));
 428             aluHandleDisconnect(pDevice);
 429             break;
 430         }
 431
 432         WritePtr = data->buffer;
 433         avail = data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
 434         aluMixData(pDevice, WritePtr, avail);
 435
 436         while(avail > 0)
 437         {
 438             int ret = psnd_pcm_writei(data->pcmHandle, WritePtr, avail);
 439             switch (ret)
 440             {
 441             case -EAGAIN:
 442                 continue;
 443             case -ESTRPIPE:
 444             case -EPIPE:
 445             case -EINTR:
 446                 ret = psnd_pcm_recover(data->pcmHandle, ret, 1);
 447                 if(ret >= 0)
 448                     psnd_pcm_prepare(data->pcmHandle);
 449                 break;
 450             default:
 451                 if (ret >= 0)
 452                 {
 453                     WritePtr += psnd_pcm_frames_to_bytes(data->pcmHandle, ret);
 454                     avail -= ret;
 455                 }
 456                 break;
 457             }
 458             if (ret < 0)
 459             {
 460                 ret = psnd_pcm_prepare(data->pcmHandle);
 461                 if(ret < 0)
 462                     break;
 463             }
 464         }
 465     }
 466
 467     return 0;
 468 }
 469
 470 static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
 471 {
 472     alsa_data *data;
 473     char driver[64];
 474     int i;
 475
 476     if(!alsa_load())
 477         return ALC_FALSE;
 478
 479     strncpy(driver, GetConfigValue("alsa", "device", "default"), sizeof(driver)-1);
 480     driver[sizeof(driver)-1] = 0;
 481
 482     if(!deviceName)
 483         deviceName = alsaDevice;
 484     else if(strcmp(deviceName, alsaDevice) != 0)
 485     {
 486         size_t idx;
 487
 488         if(!allDevNameMap)
 489             allDevNameMap = probe_devices(SND_PCM_STREAM_PLAYBACK, &numDevNames);
 490
 491         for(idx = 0;idx < numDevNames;idx++)
 492         {
 493             if(allDevNameMap[idx].name &&
 494                strcmp(deviceName, allDevNameMap[idx].name) == 0)
 495             {
 496                 if(idx > 0)
 497                     sprintf(driver, "hw:%d,%d", allDevNameMap[idx].card, allDevNameMap[idx].dev);
 498                 break;
 499             }
 500         }
 501         if(idx == numDevNames)
 502             return ALC_FALSE;
 503     }
 504
 505     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 506
 507     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 508     if(i < 0)
 509     {
 510         Sleep(200);
 511         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 512     }
 513     if(i >= 0)
 514     {
 515         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 516         if(i < 0)
 517             psnd_pcm_close(data->pcmHandle);
 518     }
 519     if(i < 0)
 520     {
 521         free(data);
 522         AL_PRINT("Could not open playback device '%s': %s\n", driver, psnd_strerror(i));
 523         return ALC_FALSE;
 524     }
 525
 526     device->szDeviceName = strdup(deviceName);
 527     device->ExtraData = data;
 528     return ALC_TRUE;
 529 }
 530
 531 static void alsa_close_playback(ALCdevice *device)
 532 {
 533     alsa_data *data = (alsa_data*)device->ExtraData;
 534
 535     psnd_pcm_close(data->pcmHandle);
 536     free(data);
 537     device->ExtraData = NULL;
 538 }
 539
 540 static ALCboolean alsa_reset_playback(ALCdevice *device)
 541 {
 542     alsa_data *data = (alsa_data*)device->ExtraData;
 543     snd_pcm_uframes_t periodSizeInFrames;
 544     unsigned int periodLen, bufferLen;
 545     snd_pcm_sw_params_t *sp = NULL;
 546     snd_pcm_hw_params_t *p = NULL;
 547     snd_pcm_access_t access;
 548     snd_pcm_format_t format;
 549     unsigned int periods;
 550     unsigned int rate;
 551     int allowmmap;
 552     char *err;
 553     int i;
 554
 555
 556     switch(aluBytesFromFormat(device->Format))
 557     {
 558         case 1:
 559             format = SND_PCM_FORMAT_U8;
 560             break;
 561         case 2:
 562             format = SND_PCM_FORMAT_S16;
 563             break;
 564         case 4:
 565             format = SND_PCM_FORMAT_FLOAT;
 566             break;
 567         default:
 568             AL_PRINT("Unknown format: 0x%x\n", device->Format);
 569             return ALC_FALSE;
 570     }
 571
 572     allowmmap = GetConfigValueBool("alsa", "mmap", 1);
 573     periods = device->NumUpdates;
 574     periodLen = (ALuint64)device->UpdateSize * 1000000 / device->Frequency;
 575     rate = device->Frequency;
 576
 577     err = NULL;
 578     psnd_pcm_hw_params_malloc(&p);
 579
 580     if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
 581         err = "any";
 582     /* set interleaved access */
 583     if(i >= 0 && (!allowmmap || (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0))
 584     {
 585         if(periods > 2) periods--;
 586         if((i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
 587             err = "set access";
 588     }
 589     /* set format (implicitly sets sample bits) */
 590     if(i >= 0 && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
 591     {
 592         switch(aluChannelsFromFormat(device->Format))
 593         {
 594             case 1: device->Format = AL_FORMAT_MONO_FLOAT32; break;
 595             case 2: device->Format = AL_FORMAT_STEREO_FLOAT32; break;
 596             case 4: device->Format = AL_FORMAT_QUAD32; break;
 597             case 6: device->Format = AL_FORMAT_51CHN32; break;
 598             case 7: device->Format = AL_FORMAT_61CHN32; break;
 599             case 8: device->Format = AL_FORMAT_71CHN32; break;
 600         }
 601         if((i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_FLOAT)) < 0)
 602         {
 603             switch(aluChannelsFromFormat(device->Format))
 604             {
 605                 case 1: device->Format = AL_FORMAT_MONO16; break;
 606                 case 2: device->Format = AL_FORMAT_STEREO16; break;
 607                 case 4: device->Format = AL_FORMAT_QUAD16; break;
 608                 case 6: device->Format = AL_FORMAT_51CHN16; break;
 609                 case 7: device->Format = AL_FORMAT_61CHN16; break;
 610                 case 8: device->Format = AL_FORMAT_71CHN16; break;
 611             }
 612             if((i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_S16)) < 0)
 613             {
 614                 switch(aluChannelsFromFormat(device->Format))
 615                 {
 616                     case 1: device->Format = AL_FORMAT_MONO8; break;
 617                     case 2: device->Format = AL_FORMAT_STEREO8; break;
 618                     case 4: device->Format = AL_FORMAT_QUAD8; break;
 619                     case 6: device->Format = AL_FORMAT_51CHN8; break;
 620                     case 7: device->Format = AL_FORMAT_61CHN8; break;
 621                     case 8: device->Format = AL_FORMAT_71CHN8; break;
 622                 }
 623                 if((i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_U8)) < 0)
 624                     err = "set format";
 625             }
 626         }
 627     }
 628     /* set channels (implicitly sets frame bits) */
 629     if(i >= 0 && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(device->Format))) < 0)
 630     {
 631         switch(aluBytesFromFormat(device->Format))
 632         {
 633             case 1: device->Format = AL_FORMAT_STEREO8; break;
 634             case 2: device->Format = AL_FORMAT_STEREO16; break;
 635             case 4: device->Format = AL_FORMAT_STEREO_FLOAT32; break;
 636         }
 637         if((i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, 2)) < 0)
 638         {
 639             switch(aluBytesFromFormat(device->Format))
 640             {
 641                 case 1: device->Format = AL_FORMAT_MONO8; break;
 642                 case 2: device->Format = AL_FORMAT_MONO16; break;
 643                 case 4: device->Format = AL_FORMAT_MONO_FLOAT32; break;
 644             }
 645             if((i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, 1)) < 0)
 646                 err = "set channels";
 647         }
 648     }
 649     if(i >= 0 && (i=psnd_pcm_hw_params_set_rate_resample(data->pcmHandle, p, 0)) < 0)
 650     {
 651         AL_PRINT("Failed to disable ALSA resampler\n");
 652         i = 0;
 653     }
 654     /* set rate (implicitly constrains period/buffer parameters) */
 655     if(i >= 0 && (i=psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &rate, NULL)) < 0)
 656         err = "set rate near";
 657     /* set buffer time (implicitly constrains period/buffer parameters) */
 658     bufferLen = periodLen * periods;
 659     if(i >= 0 && (i=psnd_pcm_hw_params_set_buffer_time_near(data->pcmHandle, p, &bufferLen, NULL)) < 0)
 660         err = "set buffer time near";
 661     /* set period time in frame units (implicitly sets buffer size/bytes/time and period size/bytes) */
 662     if(i >= 0 && (i=psnd_pcm_hw_params_set_period_time_near(data->pcmHandle, p, &periodLen, NULL)) < 0)
 663         err = "set period time near";
 664     /* install and prepare hardware configuration */
 665     if(i >= 0 && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 666         err = "set params";
 667     if(i >= 0 && (i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
 668         err = "get access";
 669     if(i >= 0 && (i=psnd_pcm_hw_params_get_period_size(p, &periodSizeInFrames, NULL)) < 0)
 670         err = "get period size";
 671     if(i >= 0 && (i=psnd_pcm_hw_params_get_periods(p, &periods, NULL)) < 0)
 672         err = "get periods";
 673     if(i < 0)
 674     {
 675         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 676         psnd_pcm_hw_params_free(p);
 677         return ALC_FALSE;
 678     }
 679
 680     psnd_pcm_hw_params_free(p);
 681
 682     err = NULL;
 683     psnd_pcm_sw_params_malloc(&sp);
 684
 685     if((i=psnd_pcm_sw_params_current(data->pcmHandle, sp)) != 0)
 686         err = "sw current";
 687     if(i == 0 && (i=psnd_pcm_sw_params_set_avail_min(data->pcmHandle, sp, periodSizeInFrames)) != 0)
 688         err = "sw set avail min";
 689     if(i == 0 && (i=psnd_pcm_sw_params(data->pcmHandle, sp)) != 0)
 690         err = "sw set params";
 691     if(i != 0)
 692     {
 693         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 694         psnd_pcm_sw_params_free(sp);
 695         return ALC_FALSE;
 696     }
 697
 698     psnd_pcm_sw_params_free(sp);
 699
 700     SetDefaultChannelOrder(device);
 701
 702     data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, periodSizeInFrames);
 703     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 704     {
 705         /* Increase periods by one, since the temp buffer counts as an extra
 706          * period */
 707         periods++;
 708         data->buffer = malloc(data->size);
 709         if(!data->buffer)
 710         {
 711             AL_PRINT("buffer malloc failed\n");
 712             return ALC_FALSE;
 713         }
 714         device->UpdateSize = periodSizeInFrames;
 715         device->NumUpdates = periods;
 716         device->Frequency = rate;
 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         device->Frequency = rate;
 730         data->thread = StartThread(ALSAProc, device);
 731     }
 732     if(data->thread == NULL)
 733     {
 734         AL_PRINT("Could not create playback thread\n");
 735         free(data->buffer);
 736         data->buffer = NULL;
 737         return ALC_FALSE;
 738     }
 739
 740     return ALC_TRUE;
 741 }
 742
 743 static void alsa_stop_playback(ALCdevice *device)
 744 {
 745     alsa_data *data = (alsa_data*)device->ExtraData;
 746
 747     if(data->thread)
 748     {
 749         data->killNow = 1;
 750         StopThread(data->thread);
 751         data->thread = NULL;
 752     }
 753     data->killNow = 0;
 754     free(data->buffer);
 755     data->buffer = NULL;
 756 }
 757
 758
 759 static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName)
 760 {
 761     snd_pcm_hw_params_t *p;
 762     snd_pcm_uframes_t bufferSizeInFrames;
 763     snd_pcm_format_t format;
 764     ALuint frameSize;
 765     alsa_data *data;
 766     char driver[64];
 767     char *err;
 768     int i;
 769
 770     if(!alsa_load())
 771         return ALC_FALSE;
 772
 773     strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
 774     driver[sizeof(driver)-1] = 0;
 775
 776     if(!allCaptureDevNameMap)
 777         allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
 778
 779     if(!deviceName)
 780         deviceName = allCaptureDevNameMap[0].name;
 781     else
 782     {
 783         size_t idx;
 784
 785         for(idx = 0;idx < numCaptureDevNames;idx++)
 786         {
 787             if(allCaptureDevNameMap[idx].name &&
 788                strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
 789             {
 790                 if(idx > 0)
 791                     sprintf(driver, "plughw:%d,%d", allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
 792                 break;
 793             }
 794         }
 795         if(idx == numCaptureDevNames)
 796             return ALC_FALSE;
 797     }
 798
 799     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 800
 801     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 802     if(i < 0)
 803     {
 804         Sleep(200);
 805         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 806     }
 807     if(i < 0)
 808     {
 809         AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
 810         free(data);
 811         return ALC_FALSE;
 812     }
 813
 814     switch(aluBytesFromFormat(pDevice->Format))
 815     {
 816         case 1:
 817             format = SND_PCM_FORMAT_U8;
 818             break;
 819         case 2:
 820             format = SND_PCM_FORMAT_S16;
 821             break;
 822         case 4:
 823             format = SND_PCM_FORMAT_FLOAT;
 824             break;
 825         default:
 826             AL_PRINT("Unknown format: 0x%x\n", pDevice->Format);
 827             goto error;
 828     }
 829
 830     err = NULL;
 831     bufferSizeInFrames = pDevice->UpdateSize * pDevice->NumUpdates;
 832     psnd_pcm_hw_params_malloc(&p);
 833
 834     if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
 835         err = "any";
 836     /* set interleaved access */
 837     if(i >= 0 && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
 838         err = "set access";
 839     /* set format (implicitly sets sample bits) */
 840     if(i >= 0 && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
 841         err = "set format";
 842     /* set channels (implicitly sets frame bits) */
 843     if(i >= 0 && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
 844         err = "set channels";
 845     /* set rate (implicitly constrains period/buffer parameters) */
 846     if(i >= 0 && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, pDevice->Frequency, 0)) < 0)
 847         err = "set rate near";
 848     /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 849     if(i >= 0 && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
 850         err = "set buffer size near";
 851     /* install and prepare hardware configuration */
 852     if(i >= 0 && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 853         err = "set params";
 854     if(i < 0)
 855     {
 856         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 857         psnd_pcm_hw_params_free(p);
 858         goto error;
 859     }
 860
 861     if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
 862     {
 863         AL_PRINT("get size failed: %s\n", psnd_strerror(i));
 864         psnd_pcm_hw_params_free(p);
 865         goto error;
 866     }
 867
 868     psnd_pcm_hw_params_free(p);
 869
 870     frameSize = aluFrameSizeFromFormat(pDevice->Format);
 871
 872     data->ring = CreateRingBuffer(frameSize, pDevice->UpdateSize*pDevice->NumUpdates);
 873     if(!data->ring)
 874     {
 875         AL_PRINT("ring buffer create failed\n");
 876         goto error;
 877     }
 878
 879     data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
 880     data->buffer = malloc(data->size);
 881     if(!data->buffer)
 882     {
 883         AL_PRINT("buffer malloc failed\n");
 884         goto error;
 885     }
 886
 887     pDevice->szDeviceName = strdup(deviceName);
 888
 889     pDevice->ExtraData = data;
 890     return ALC_TRUE;
 891
 892 error:
 893     free(data->buffer);
 894     DestroyRingBuffer(data->ring);
 895     psnd_pcm_close(data->pcmHandle);
 896     free(data);
 897
 898     pDevice->ExtraData = NULL;
 899     return ALC_FALSE;
 900 }
 901
 902 static void alsa_close_capture(ALCdevice *pDevice)
 903 {
 904     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 905
 906     psnd_pcm_close(data->pcmHandle);
 907     DestroyRingBuffer(data->ring);
 908
 909     free(data->buffer);
 910     free(data);
 911     pDevice->ExtraData = NULL;
 912 }
 913
 914 static void alsa_start_capture(ALCdevice *Device)
 915 {
 916     alsa_data *data = (alsa_data*)Device->ExtraData;
 917     int err;
 918
 919     err = psnd_pcm_start(data->pcmHandle);
 920     if(err < 0)
 921     {
 922         AL_PRINT("start failed: %s\n", psnd_strerror(err));
 923         aluHandleDisconnect(Device);
 924     }
 925     else
 926         data->doCapture = AL_TRUE;
 927 }
 928
 929 static void alsa_stop_capture(ALCdevice *Device)
 930 {
 931     alsa_data *data = (alsa_data*)Device->ExtraData;
 932     psnd_pcm_drain(data->pcmHandle);
 933     data->doCapture = AL_FALSE;
 934 }
 935
 936 static ALCuint alsa_available_samples(ALCdevice *Device)
 937 {
 938     alsa_data *data = (alsa_data*)Device->ExtraData;
 939     snd_pcm_sframes_t avail;
 940
 941     avail = (Device->Connected ? psnd_pcm_avail_update(data->pcmHandle) : 0);
 942     if(avail < 0)
 943     {
 944         AL_PRINT("avail update failed: %s\n", psnd_strerror(avail));
 945
 946         if((avail=psnd_pcm_recover(data->pcmHandle, avail, 1)) >= 0 &&
 947            (avail=psnd_pcm_prepare(data->pcmHandle)) >= 0)
 948         {
 949             if(data->doCapture)
 950                 avail = psnd_pcm_start(data->pcmHandle);
 951             if(avail >= 0)
 952                 avail = psnd_pcm_avail_update(data->pcmHandle);
 953         }
 954         if(avail < 0)
 955         {
 956             AL_PRINT("restore error: %s\n", psnd_strerror(avail));
 957             aluHandleDisconnect(Device);
 958         }
 959     }
 960     while(avail > 0)
 961     {
 962         snd_pcm_sframes_t amt;
 963
 964         amt = psnd_pcm_bytes_to_frames(data->pcmHandle, data->size);
 965         if(avail < amt) amt = avail;
 966
 967         amt = psnd_pcm_readi(data->pcmHandle, data->buffer, amt);
 968         if(amt < 0)
 969         {
 970             AL_PRINT("read error: %s\n", psnd_strerror(amt));
 971
 972             if(amt == -EAGAIN)
 973                 continue;
 974             if((amt=psnd_pcm_recover(data->pcmHandle, amt, 1)) >= 0 &&
 975                (amt=psnd_pcm_prepare(data->pcmHandle)) >= 0)
 976             {
 977                 if(data->doCapture)
 978                     amt = psnd_pcm_start(data->pcmHandle);
 979                 if(amt >= 0)
 980                     amt = psnd_pcm_avail_update(data->pcmHandle);
 981             }
 982             if(amt < 0)
 983             {
 984                 AL_PRINT("restore error: %s\n", psnd_strerror(amt));
 985                 aluHandleDisconnect(Device);
 986                 break;
 987             }
 988             avail = amt;
 989             continue;
 990         }
 991
 992         WriteRingBuffer(data->ring, data->buffer, amt);
 993         avail -= amt;
 994     }
 995
 996     return RingBufferSize(data->ring);
 997 }
 998
 999 static void alsa_capture_samples(ALCdevice *Device, ALCvoid *Buffer, ALCuint Samples)
1000 {
1001     alsa_data *data = (alsa_data*)Device->ExtraData;
1002
1003     if(Samples <= alsa_available_samples(Device))
1004         ReadRingBuffer(data->ring, Buffer, Samples);
1005     else
1006         alcSetError(Device, ALC_INVALID_VALUE);
1007 }
1008
1009
1010 BackendFuncs alsa_funcs = {
1011     alsa_open_playback,
1012     alsa_close_playback,
1013     alsa_reset_playback,
1014     alsa_stop_playback,
1015     alsa_open_capture,
1016     alsa_close_capture,
1017     alsa_start_capture,
1018     alsa_stop_capture,
1019     alsa_capture_samples,
1020     alsa_available_samples
1021 };
1022
1023 void alc_alsa_init(BackendFuncs *func_list)
1024 {
1025     *func_list = alsa_funcs;
1026 }
1027
1028 void alc_alsa_deinit(void)
1029 {
1030     ALuint i;
1031
1032     for(i = 0;i < numDevNames;++i)
1033         free(allDevNameMap[i].name);
1034     free(allDevNameMap);
1035     allDevNameMap = NULL;
1036     numDevNames = 0;
1037
1038     for(i = 0;i < numCaptureDevNames;++i)
1039         free(allCaptureDevNameMap[i].name);
1040     free(allCaptureDevNameMap);
1041     allCaptureDevNameMap = NULL;
1042     numCaptureDevNames = 0;
1043
1044     if(alsa_handle)
1045     {
1046 #ifdef HAVE_DLFCN_H
1047         dlclose(alsa_handle);
1048 #endif
1049         alsa_handle = NULL;
1050     }
1051 }
1052
1053 void alc_alsa_probe(int type)
1054 {
1055     ALuint i;
1056
1057     if(!alsa_load())
1058         return;
1059
1060     if(type == DEVICE_PROBE)
1061         AppendDeviceList(alsaDevice);
1062     else if(type == ALL_DEVICE_PROBE)
1063     {
1064         for(i = 0;i < numDevNames;++i)
1065             free(allDevNameMap[i].name);
1066
1067         free(allDevNameMap);
1068         allDevNameMap = probe_devices(SND_PCM_STREAM_PLAYBACK, &numDevNames);
1069
1070         for(i = 0;i < numDevNames;++i)
1071             AppendAllDeviceList(allDevNameMap[i].name);
1072     }
1073     else if(type == CAPTURE_DEVICE_PROBE)
1074     {
1075         for(i = 0;i < numCaptureDevNames;++i)
1076             free(allCaptureDevNameMap[i].name);
1077
1078         free(allCaptureDevNameMap);
1079         allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
1080
1081         for(i = 0;i < numCaptureDevNames;++i)
1082             AppendCaptureDeviceList(allCaptureDevNameMap[i].name);
1083     }
1084 }