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