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