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(RTPrioLevel);
 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(RTPrioLevel);
 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(RTPrioLevel);
 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     SetDefaultChannelOrder(device);
 667
 668     data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, periodSizeInFrames);
 669     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 670     {
 671         /* Increase periods by one, since the temp buffer counts as an extra
 672          * period */
 673         periods++;
 674         data->buffer = malloc(data->size);
 675         if(!data->buffer)
 676         {
 677             AL_PRINT("buffer malloc failed\n");
 678             return ALC_FALSE;
 679         }
 680         device->UpdateSize = periodSizeInFrames;
 681         device->NumUpdates = periods;
 682         device->Frequency = rate;
 683         data->thread = StartThread(ALSANoMMapProc, device);
 684     }
 685     else
 686     {
 687         i = psnd_pcm_prepare(data->pcmHandle);
 688         if(i < 0)
 689         {
 690             AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 691             return ALC_FALSE;
 692         }
 693         device->UpdateSize = periodSizeInFrames;
 694         device->NumUpdates = periods;
 695         device->Frequency = rate;
 696         data->thread = StartThread(ALSAProc, device);
 697     }
 698     if(data->thread == NULL)
 699     {
 700         AL_PRINT("Could not create playback thread\n");
 701         free(data->buffer);
 702         data->buffer = NULL;
 703         return ALC_FALSE;
 704     }
 705
 706     return ALC_TRUE;
 707 }
 708
 709 static void alsa_stop_playback(ALCdevice *device)
 710 {
 711     alsa_data *data = (alsa_data*)device->ExtraData;
 712
 713     if(data->thread)
 714     {
 715         data->killNow = 1;
 716         StopThread(data->thread);
 717         data->thread = NULL;
 718     }
 719     data->killNow = 0;
 720     free(data->buffer);
 721     data->buffer = NULL;
 722 }
 723
 724
 725 static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName)
 726 {
 727     const char *devName;
 728     snd_pcm_hw_params_t *p;
 729     snd_pcm_uframes_t bufferSizeInFrames;
 730     snd_pcm_format_t format;
 731     ALuint frameSize;
 732     alsa_data *data;
 733     char driver[64];
 734     char *err;
 735     int i;
 736
 737     strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
 738     driver[sizeof(driver)-1] = 0;
 739     if(!deviceName)
 740         deviceName = allCaptureDevNameMap[0].name;
 741     else
 742     {
 743         size_t idx;
 744
 745         for(idx = 0;idx < numCaptureDevNames;idx++)
 746         {
 747             if(allCaptureDevNameMap[idx].name &&
 748                strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
 749             {
 750                 devName = allCaptureDevNameMap[idx].name;
 751                 if(idx > 0)
 752                     sprintf(driver, "plughw:%d,%d", allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
 753                 break;
 754             }
 755         }
 756         if(idx == numCaptureDevNames)
 757             return ALC_FALSE;
 758     }
 759
 760     alsa_load();
 761     if(!alsa_handle)
 762         return ALC_FALSE;
 763
 764     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 765
 766     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 767     if(i < 0)
 768     {
 769         Sleep(200);
 770         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 771     }
 772     if(i >= 0)
 773     {
 774         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 775         if(i < 0)
 776             psnd_pcm_close(data->pcmHandle);
 777     }
 778     if(i < 0)
 779     {
 780         AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
 781         free(data);
 782         alsa_unload();
 783         return ALC_FALSE;
 784     }
 785
 786     switch(aluBytesFromFormat(pDevice->Format))
 787     {
 788         case 1:
 789             format = SND_PCM_FORMAT_U8;
 790             break;
 791         case 2:
 792             format = SND_PCM_FORMAT_S16;
 793             break;
 794         case 4:
 795             format = SND_PCM_FORMAT_FLOAT;
 796             break;
 797         default:
 798             AL_PRINT("Unknown format: 0x%x\n", pDevice->Format);
 799             goto error;
 800     }
 801
 802     err = NULL;
 803     bufferSizeInFrames = pDevice->UpdateSize * pDevice->NumUpdates;
 804     psnd_pcm_hw_params_malloc(&p);
 805
 806     if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
 807         err = "any";
 808     /* set interleaved access */
 809     if(err == NULL && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
 810         err = "set access";
 811     /* set format (implicitly sets sample bits) */
 812     if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
 813         err = "set format";
 814     /* set channels (implicitly sets frame bits) */
 815     if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
 816         err = "set channels";
 817     /* set rate (implicitly constrains period/buffer parameters) */
 818     if(err == NULL && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, pDevice->Frequency, 0)) < 0)
 819         err = "set rate near";
 820     /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 821     if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
 822         err = "set buffer size near";
 823     /* install and prepare hardware configuration */
 824     if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 825         err = "set params";
 826     if(err != NULL)
 827     {
 828         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 829         psnd_pcm_hw_params_free(p);
 830         goto error;
 831     }
 832
 833     if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
 834     {
 835         AL_PRINT("get size failed: %s\n", psnd_strerror(i));
 836         psnd_pcm_hw_params_free(p);
 837         goto error;
 838     }
 839
 840     psnd_pcm_hw_params_free(p);
 841
 842     frameSize  = aluChannelsFromFormat(pDevice->Format);
 843     frameSize *= aluBytesFromFormat(pDevice->Format);
 844
 845     data->ring = CreateRingBuffer(frameSize, pDevice->UpdateSize*pDevice->NumUpdates);
 846     if(!data->ring)
 847     {
 848         AL_PRINT("ring buffer create failed\n");
 849         goto error;
 850     }
 851
 852     data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
 853     data->buffer = malloc(data->size);
 854     if(!data->buffer)
 855     {
 856         AL_PRINT("buffer malloc failed\n");
 857         goto error;
 858     }
 859
 860     pDevice->ExtraData = data;
 861     data->thread = StartThread(ALSANoMMapCaptureProc, pDevice);
 862     if(data->thread == NULL)
 863     {
 864         AL_PRINT("Could not create capture thread\n");
 865         goto error;
 866     }
 867
 868     pDevice->szDeviceName = strdup(deviceName);
 869     return ALC_TRUE;
 870
 871 error:
 872     free(data->buffer);
 873     DestroyRingBuffer(data->ring);
 874     psnd_pcm_close(data->pcmHandle);
 875     free(data);
 876     alsa_unload();
 877
 878     pDevice->ExtraData = NULL;
 879     return ALC_FALSE;
 880 }
 881
 882 static void alsa_close_capture(ALCdevice *pDevice)
 883 {
 884     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 885
 886     data->killNow = 1;
 887     StopThread(data->thread);
 888
 889     psnd_pcm_close(data->pcmHandle);
 890     DestroyRingBuffer(data->ring);
 891
 892     free(data->buffer);
 893     free(data);
 894     pDevice->ExtraData = NULL;
 895
 896     alsa_unload();
 897 }
 898
 899 static void alsa_start_capture(ALCdevice *pDevice)
 900 {
 901     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 902     data->doCapture = 1;
 903 }
 904
 905 static void alsa_stop_capture(ALCdevice *pDevice)
 906 {
 907     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 908     data->doCapture = 0;
 909 }
 910
 911 static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 912 {
 913     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 914
 915     if(lSamples <= (ALCuint)RingBufferSize(data->ring))
 916         ReadRingBuffer(data->ring, pBuffer, lSamples);
 917     else
 918         alcSetError(ALC_INVALID_VALUE);
 919 }
 920
 921 static ALCuint alsa_available_samples(ALCdevice *pDevice)
 922 {
 923     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 924     return RingBufferSize(data->ring);
 925 }
 926
 927
 928 BackendFuncs alsa_funcs = {
 929     alsa_open_playback,
 930     alsa_close_playback,
 931     alsa_reset_playback,
 932     alsa_stop_playback,
 933     alsa_open_capture,
 934     alsa_close_capture,
 935     alsa_start_capture,
 936     alsa_stop_capture,
 937     alsa_capture_samples,
 938     alsa_available_samples
 939 };
 940
 941 void alc_alsa_init(BackendFuncs *func_list)
 942 {
 943     *func_list = alsa_funcs;
 944 }
 945
 946 void alc_alsa_deinit(void)
 947 {
 948     ALuint i;
 949
 950     for(i = 0;i < numDevNames;++i)
 951         free(allDevNameMap[i].name);
 952     free(allDevNameMap);
 953     allDevNameMap = NULL;
 954     numDevNames = 0;
 955
 956     for(i = 0;i < numCaptureDevNames;++i)
 957         free(allCaptureDevNameMap[i].name);
 958     free(allCaptureDevNameMap);
 959     allCaptureDevNameMap = NULL;
 960     numCaptureDevNames = 0;
 961 }
 962
 963 void alc_alsa_probe(int type)
 964 {
 965     snd_ctl_t *handle;
 966     int card, err, dev, idx;
 967     snd_ctl_card_info_t *info;
 968     snd_pcm_info_t *pcminfo;
 969     snd_pcm_stream_t stream;
 970     char name[128];
 971     ALuint i;
 972
 973     alsa_load();
 974     if(!alsa_handle) return;
 975
 976     psnd_ctl_card_info_malloc(&info);
 977     psnd_pcm_info_malloc(&pcminfo);
 978
 979     card = -1;
 980     if((err=psnd_card_next(&card)) < 0)
 981         AL_PRINT("Failed to find a card: %s\n", psnd_strerror(err));
 982
 983     if(type == DEVICE_PROBE)
 984         AppendDeviceList(alsaDevice);
 985     else if(type == ALL_DEVICE_PROBE)
 986     {
 987         stream = SND_PCM_STREAM_PLAYBACK;
 988
 989         for(i = 0;i < numDevNames;++i)
 990             free(allDevNameMap[i].name);
 991
 992         allDevNameMap = realloc(allDevNameMap, sizeof(DevMap) * 1);
 993         allDevNameMap[0].name = strdup("ALSA Software on default");
 994         AppendAllDeviceList(allDevNameMap[0].name);
 995
 996         idx = 1;
 997         while(card >= 0) {
 998             sprintf(name, "hw:%d", card);
 999             if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
1000                 AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
1001                 goto next_card;
1002             }
1003             if ((err = psnd_ctl_card_info(handle, info)) < 0) {
1004                 AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
1005                 psnd_ctl_close(handle);
1006                 goto next_card;
1007             }
1008
1009             dev = -1;
1010             while(1) {
1011                 const char *cname, *dname;
1012                 void *temp;
1013
1014                 if (psnd_ctl_pcm_next_device(handle, &dev)<0)
1015                     AL_PRINT("snd_ctl_pcm_next_device failed\n");
1016                 if (dev < 0)
1017                     break;
1018
1019                 psnd_pcm_info_set_device(pcminfo, dev);
1020                 psnd_pcm_info_set_subdevice(pcminfo, 0);
1021                 psnd_pcm_info_set_stream(pcminfo, stream);
1022                 if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
1023                     if (err != -ENOENT)
1024                         AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
1025                     continue;
1026                 }
1027
1028                 temp = realloc(allDevNameMap, sizeof(DevMap) * (idx+1));
1029                 if(temp)
1030                 {
1031                     allDevNameMap = temp;
1032                     cname = psnd_ctl_card_info_get_name(info);
1033                     dname = psnd_pcm_info_get_name(pcminfo);
1034                     snprintf(name, sizeof(name), "ALSA Software on %s [%s] (hw:%d,%d)",
1035                              cname, dname, card, dev);
1036                     AppendAllDeviceList(name);
1037                     allDevNameMap[idx].name = strdup(name);
1038                     allDevNameMap[idx].card = card;
1039                     allDevNameMap[idx].dev = dev;
1040                     idx++;
1041                 }
1042             }
1043             psnd_ctl_close(handle);
1044         next_card:
1045             if(psnd_card_next(&card) < 0) {
1046                 AL_PRINT("snd_card_next failed\n");
1047                 break;
1048             }
1049         }
1050         numDevNames = idx;
1051     }
1052     else if(type == CAPTURE_DEVICE_PROBE)
1053     {
1054         stream = SND_PCM_STREAM_CAPTURE;
1055
1056         for(i = 0;i < numCaptureDevNames;++i)
1057             free(allCaptureDevNameMap[i].name);
1058
1059         allCaptureDevNameMap = realloc(allCaptureDevNameMap, sizeof(DevMap) * 1);
1060         allCaptureDevNameMap[0].name = strdup("ALSA Capture on default");
1061         AppendCaptureDeviceList(allCaptureDevNameMap[0].name);
1062
1063         idx = 1;
1064         while (card >= 0) {
1065             sprintf(name, "hw:%d", card);
1066             handle = NULL;
1067             if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
1068                 AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
1069             }
1070             if (err >= 0 && (err = psnd_ctl_card_info(handle, info)) < 0) {
1071                 AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
1072             }
1073             else if (err >= 0)
1074             {
1075                 dev = -1;
1076                 while(1) {
1077                     const char *cname, *dname;
1078                     void *temp;
1079
1080                     if (psnd_ctl_pcm_next_device(handle, &dev)<0)
1081                         AL_PRINT("snd_ctl_pcm_next_device failed\n");
1082                     if (dev < 0)
1083                         break;
1084                     psnd_pcm_info_set_device(pcminfo, dev);
1085                     psnd_pcm_info_set_subdevice(pcminfo, 0);
1086                     psnd_pcm_info_set_stream(pcminfo, stream);
1087                     if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
1088                         if (err != -ENOENT)
1089                             AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
1090                         continue;
1091                     }
1092
1093                     temp = realloc(allCaptureDevNameMap, sizeof(DevMap) * (idx+1));
1094                     if(temp)
1095                     {
1096                         allCaptureDevNameMap = temp;
1097                         cname = psnd_ctl_card_info_get_name(info);
1098                         dname = psnd_pcm_info_get_name(pcminfo);
1099                         snprintf(name, sizeof(name), "ALSA Capture on %s [%s] (hw:%d,%d)",
1100                                  cname, dname, card, dev);
1101                         AppendCaptureDeviceList(name);
1102                         allCaptureDevNameMap[idx].name = strdup(name);
1103                         allCaptureDevNameMap[idx].card = card;
1104                         allCaptureDevNameMap[idx].dev = dev;
1105                         idx++;
1106                     }
1107                 }
1108             }
1109             if(handle) psnd_ctl_close(handle);
1110             if(psnd_card_next(&card) < 0) {
1111                 AL_PRINT("snd_card_next failed\n");
1112                 break;
1113             }
1114         }
1115         numCaptureDevNames = idx;
1116     }
1117
1118     psnd_pcm_info_free(pcminfo);
1119     psnd_ctl_card_info_free(info);
1120
1121     alsa_unload();
1122 }