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     snd_pcm_format_t format;
  39
  40     ALvoid *buffer;
  41     ALsizei size;
  42
  43     int killNow;
  44     ALvoid *thread;
  45 } alsa_data;
  46
  47 typedef struct {
  48     ALCchar *name;
  49     int card, dev;
  50 } DevMap;
  51
  52 static void *alsa_handle;
  53 #define MAKE_FUNC(f) static typeof(f) * p##f
  54 MAKE_FUNC(snd_strerror);
  55 MAKE_FUNC(snd_pcm_open);
  56 MAKE_FUNC(snd_pcm_close);
  57 MAKE_FUNC(snd_pcm_nonblock);
  58 MAKE_FUNC(snd_pcm_frames_to_bytes);
  59 MAKE_FUNC(snd_pcm_hw_params_malloc);
  60 MAKE_FUNC(snd_pcm_hw_params_free);
  61 MAKE_FUNC(snd_pcm_hw_params_any);
  62 MAKE_FUNC(snd_pcm_hw_params_set_access);
  63 MAKE_FUNC(snd_pcm_hw_params_set_format);
  64 MAKE_FUNC(snd_pcm_hw_params_set_channels);
  65 MAKE_FUNC(snd_pcm_hw_params_set_periods_near);
  66 MAKE_FUNC(snd_pcm_hw_params_set_rate_near);
  67 MAKE_FUNC(snd_pcm_hw_params_set_rate);
  68 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_near);
  69 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_min);
  70 MAKE_FUNC(snd_pcm_hw_params_get_access);
  71 MAKE_FUNC(snd_pcm_hw_params);
  72 MAKE_FUNC(snd_pcm_prepare);
  73 MAKE_FUNC(snd_pcm_start);
  74 MAKE_FUNC(snd_pcm_resume);
  75 MAKE_FUNC(snd_pcm_state);
  76 MAKE_FUNC(snd_pcm_avail_update);
  77 MAKE_FUNC(snd_pcm_areas_silence);
  78 MAKE_FUNC(snd_pcm_mmap_begin);
  79 MAKE_FUNC(snd_pcm_mmap_commit);
  80 MAKE_FUNC(snd_pcm_writei);
  81 MAKE_FUNC(snd_pcm_drain);
  82 MAKE_FUNC(snd_pcm_info_malloc);
  83 MAKE_FUNC(snd_pcm_info_free);
  84 MAKE_FUNC(snd_pcm_info_set_device);
  85 MAKE_FUNC(snd_pcm_info_set_subdevice);
  86 MAKE_FUNC(snd_pcm_info_set_stream);
  87 MAKE_FUNC(snd_pcm_info_get_name);
  88 MAKE_FUNC(snd_ctl_pcm_next_device);
  89 MAKE_FUNC(snd_ctl_pcm_info);
  90 MAKE_FUNC(snd_ctl_open);
  91 MAKE_FUNC(snd_ctl_close);
  92 MAKE_FUNC(snd_ctl_card_info_malloc);
  93 MAKE_FUNC(snd_ctl_card_info_free);
  94 MAKE_FUNC(snd_ctl_card_info);
  95 MAKE_FUNC(snd_ctl_card_info_get_name);
  96 MAKE_FUNC(snd_card_next);
  97 #undef MAKE_FUNC
  98
  99 #define MAX_DEVICES 16
 100 #define MAX_ALL_DEVICES 32
 101
 102 static DevMap allDevNameMap[MAX_ALL_DEVICES];
 103 static ALCchar *alsaDeviceList[MAX_DEVICES];
 104 static ALCchar *alsaCaptureDeviceList[MAX_DEVICES];
 105
 106 static int xrun_recovery(snd_pcm_t *handle, int err)
 107 {
 108     if (err == -EPIPE)
 109     {    /* under-run */
 110         err = psnd_pcm_prepare(handle);
 111         if (err < 0)
 112             AL_PRINT("prepare failed: %s\n", psnd_strerror(err));
 113     }
 114     else if (err == -ESTRPIPE)
 115     {
 116         while ((err = psnd_pcm_resume(handle)) == -EAGAIN)
 117             Sleep(1);       /* wait until the suspend flag is released */
 118         if (err < 0)
 119         {
 120             err = psnd_pcm_prepare(handle);
 121             if (err < 0)
 122                 AL_PRINT("prepare failed: %s\n", psnd_strerror(err));
 123         }
 124     }
 125     return err;
 126 }
 127
 128
 129 static ALuint ALSAProc(ALvoid *ptr)
 130 {
 131     ALCdevice *pDevice = (ALCdevice*)ptr;
 132     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 133     const snd_pcm_channel_area_t *areas = NULL;
 134     snd_pcm_sframes_t avail, commitres;
 135     snd_pcm_uframes_t offset, frames;
 136     char *WritePtr;
 137     int WriteCnt;
 138     int err;
 139
 140     while(!data->killNow)
 141     {
 142         snd_pcm_state_t state = psnd_pcm_state(data->pcmHandle);
 143         if(state == SND_PCM_STATE_XRUN)
 144         {
 145             err = xrun_recovery(data->pcmHandle, -EPIPE);
 146             if (err < 0)
 147             {
 148                 AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
 149                 break;
 150             }
 151         }
 152         else if (state == SND_PCM_STATE_SUSPENDED)
 153         {
 154             err = xrun_recovery(data->pcmHandle, -ESTRPIPE);
 155             if (err < 0)
 156             {
 157                 AL_PRINT("SUSPEND recovery failed: %s\n", psnd_strerror(err));
 158                 break;
 159             }
 160         }
 161
 162         avail = psnd_pcm_avail_update(data->pcmHandle);
 163         if(avail < 0)
 164         {
 165             err = xrun_recovery(data->pcmHandle, avail);
 166             if (err < 0)
 167             {
 168                 AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 169                 break;
 170             }
 171         }
 172
 173         // make sure there's frames to process
 174         if(avail == 0)
 175         {
 176             if(state != SND_PCM_STATE_RUNNING)
 177             {
 178                 err = psnd_pcm_start(data->pcmHandle);
 179                 if(err < 0)
 180                     err = xrun_recovery(data->pcmHandle, err);
 181                 if(err < 0)
 182                 {
 183                     AL_PRINT("start failed: %s\n", psnd_strerror(err));
 184                     break;
 185                 }
 186             }
 187             Sleep(1);
 188             continue;
 189         }
 190
 191         // it is possible that contiguous areas are smaller, thus we use a loop
 192         while (avail > 0)
 193         {
 194             frames = avail;
 195
 196             err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &frames);
 197             if (err < 0)
 198             {
 199                 err = xrun_recovery(data->pcmHandle, err);
 200                 if (err < 0)
 201                     AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 202                 break;
 203             }
 204
 205             SuspendContext(NULL);
 206             WritePtr = (char*)areas->addr + (offset * areas->step / 8);
 207             WriteCnt = psnd_pcm_frames_to_bytes(data->pcmHandle, frames);
 208             aluMixData(pDevice->Context, WritePtr, WriteCnt, pDevice->Format);
 209             ProcessContext(NULL);
 210
 211             commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, frames);
 212             if (commitres < 0 || (commitres-frames) != 0)
 213             {
 214                 AL_PRINT("mmap commit error: %s\n",
 215                          psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 216                 break;
 217             }
 218
 219             avail -= frames;
 220         }
 221     }
 222
 223     return 0;
 224 }
 225
 226 static ALuint ALSANoMMapProc(ALvoid *ptr)
 227 {
 228     ALCdevice *pDevice = (ALCdevice*)ptr;
 229     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 230     snd_pcm_sframes_t avail;
 231     char *WritePtr;
 232
 233     while(!data->killNow)
 234     {
 235         SuspendContext(NULL);
 236         aluMixData(pDevice->Context, data->buffer, data->size, pDevice->Format);
 237         ProcessContext(NULL);
 238
 239         WritePtr = data->buffer;
 240         avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
 241         while(avail > 0)
 242         {
 243             int ret = psnd_pcm_writei(data->pcmHandle, WritePtr, avail);
 244             switch (ret)
 245             {
 246             case -EAGAIN:
 247                 continue;
 248             case -ESTRPIPE:
 249                 while((ret=psnd_pcm_resume(data->pcmHandle)) == -EAGAIN)
 250                     Sleep(1);
 251                 break;
 252             case -EPIPE:
 253                 break;
 254             default:
 255                 if (ret >= 0)
 256                 {
 257                     WritePtr += psnd_pcm_frames_to_bytes(data->pcmHandle, ret);
 258                     avail -= ret;
 259                 }
 260                 break;
 261             }
 262             if (ret < 0)
 263             {
 264                 ret = psnd_pcm_prepare(data->pcmHandle);
 265                 if(ret < 0)
 266                     break;
 267             }
 268         }
 269     }
 270
 271     return 0;
 272 }
 273
 274 static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
 275 {
 276     snd_pcm_uframes_t bufferSizeInFrames;
 277     snd_pcm_hw_params_t *p = NULL;
 278     snd_pcm_access_t access;
 279     unsigned int periods;
 280     alsa_data *data;
 281     char driver[64];
 282     const char *str;
 283     int allowmmap;
 284     char *err;
 285     int i;
 286
 287     if(!alsa_handle)
 288         return ALC_FALSE;
 289
 290     strncpy(driver, GetConfigValue("alsa", "device", "default"), sizeof(driver)-1);
 291     driver[sizeof(driver)-1] = 0;
 292     if(deviceName)
 293     {
 294         size_t idx;
 295
 296         for(idx = 0;idx < MAX_ALL_DEVICES;idx++)
 297         {
 298             if(allDevNameMap[idx].name &&
 299                strcmp(deviceName, allDevNameMap[idx].name) == 0)
 300             {
 301                 device->szDeviceName = allDevNameMap[idx].name;
 302                 if(idx > 0)
 303                     sprintf(driver, "hw:%d,%d", allDevNameMap[idx].card, allDevNameMap[idx].dev);
 304                 goto open_alsa;
 305             }
 306         }
 307         for(idx = 0;idx < MAX_DEVICES;idx++)
 308         {
 309             if(alsaDeviceList[idx] &&
 310                strcmp(deviceName, alsaDeviceList[idx]) == 0)
 311             {
 312                 device->szDeviceName = alsaDeviceList[idx];
 313                 if(idx > 0)
 314                     sprintf(driver, "hw:%zd,0", idx-1);
 315                 goto open_alsa;
 316             }
 317         }
 318         return ALC_FALSE;
 319     }
 320     else
 321         device->szDeviceName = alsaDeviceList[0];
 322
 323 open_alsa:
 324     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 325
 326     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 327     if(i < 0)
 328     {
 329         Sleep(200);
 330         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 331     }
 332     if(i >= 0)
 333     {
 334         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 335         if(i < 0)
 336             psnd_pcm_close(data->pcmHandle);
 337     }
 338     if(i < 0)
 339     {
 340         free(data);
 341         AL_PRINT("Could not open playback device '%s': %s\n", driver, psnd_strerror(i));
 342         return ALC_FALSE;
 343     }
 344
 345     switch(aluBytesFromFormat(device->Format))
 346     {
 347         case 1:
 348             data->format = SND_PCM_FORMAT_U8;
 349             break;
 350         case 2:
 351             data->format = SND_PCM_FORMAT_S16;
 352             break;
 353         default:
 354             data->format = SND_PCM_FORMAT_UNKNOWN;
 355             AL_PRINT("Unknown format?! %x\n", device->Format);
 356     }
 357
 358     periods = GetConfigValueInt("alsa", "periods", 4);
 359     if((int)periods <= 0)
 360         periods = 4;
 361     bufferSizeInFrames = device->UpdateFreq / periods;
 362
 363     str = GetConfigValue("alsa", "mmap", "true");
 364     allowmmap = (strcasecmp(str, "true") == 0 ||
 365                  strcasecmp(str, "yes") == 0 ||
 366                  strcasecmp(str, "on") == 0 ||
 367                  atoi(str) != 0);
 368
 369     psnd_pcm_hw_params_malloc(&p);
 370 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
 371     /* start with the largest configuration space possible */
 372     if(!(ok(psnd_pcm_hw_params_any(data->pcmHandle, p), "any") &&
 373          /* set interleaved access */
 374          ((allowmmap && ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set access")) ||
 375           ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED), "set access")) &&
 376          /* set format (implicitly sets sample bits) */
 377          ok(psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format), "set format") &&
 378          /* set channels (implicitly sets frame bits) */
 379          ok(psnd_pcm_hw_params_set_channels(data->pcmHandle, p, device->Channels), "set channels") &&
 380          /* set periods (implicitly constrains period/buffer parameters) */
 381          ok(psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL), "set periods near") &&
 382          /* set rate (implicitly constrains period/buffer parameters) */
 383          ok(psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &device->Frequency, NULL), "set rate near") &&
 384          /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 385          ok(psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames), "set buffer size near") &&
 386          /* install and prepare hardware configuration */
 387          ok(psnd_pcm_hw_params(data->pcmHandle, p), "set params")))
 388     {
 389         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 390         psnd_pcm_hw_params_free(p);
 391         psnd_pcm_close(data->pcmHandle);
 392         free(data);
 393         return ALC_FALSE;
 394     }
 395 #undef ok
 396
 397     if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
 398     {
 399         AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
 400         psnd_pcm_hw_params_free(p);
 401         psnd_pcm_close(data->pcmHandle);
 402         free(data);
 403         return ALC_FALSE;
 404     }
 405
 406     psnd_pcm_hw_params_free(p);
 407
 408     device->MaxNoOfSources = 256;
 409     device->UpdateFreq = bufferSizeInFrames;
 410
 411     data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, device->UpdateFreq);
 412     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 413     {
 414         data->buffer = malloc(data->size);
 415         if(!data->buffer)
 416         {
 417             AL_PRINT("buffer malloc failed\n");
 418             psnd_pcm_close(data->pcmHandle);
 419             free(data);
 420             return ALC_FALSE;
 421         }
 422     }
 423     else
 424     {
 425         i = psnd_pcm_prepare(data->pcmHandle);
 426         if(i < 0)
 427         {
 428             AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 429             psnd_pcm_close(data->pcmHandle);
 430             free(data->buffer);
 431             free(data);
 432             return ALC_FALSE;
 433         }
 434     }
 435
 436     device->ExtraData = data;
 437     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 438         data->thread = StartThread(ALSANoMMapProc, device);
 439     else
 440         data->thread = StartThread(ALSAProc, device);
 441     if(data->thread == NULL)
 442     {
 443         psnd_pcm_close(data->pcmHandle);
 444         device->ExtraData = NULL;
 445         free(data->buffer);
 446         free(data);
 447         return ALC_FALSE;
 448     }
 449
 450     return ALC_TRUE;
 451 }
 452
 453 static void alsa_close_playback(ALCdevice *device)
 454 {
 455     alsa_data *data = (alsa_data*)device->ExtraData;
 456     data->killNow = 1;
 457     StopThread(data->thread);
 458     psnd_pcm_close(data->pcmHandle);
 459
 460     free(data->buffer);
 461     free(data);
 462     device->ExtraData = NULL;
 463 }
 464
 465
 466 static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
 467 {
 468     snd_pcm_format_t alsaFormat;
 469     snd_pcm_hw_params_t *p;
 470     unsigned int periods = 4;
 471     snd_pcm_uframes_t bufferSizeInFrames;
 472     alsa_data *data;
 473     char driver[64];
 474     char *err;
 475     int i;
 476
 477     if(!alsa_handle)
 478         return ALC_FALSE;
 479
 480     strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
 481     driver[sizeof(driver)-1] = 0;
 482     if(deviceName)
 483     {
 484         size_t idx;
 485
 486         for(idx = 0;idx < MAX_DEVICES;idx++)
 487         {
 488             if(alsaCaptureDeviceList[idx] &&
 489                strcmp(deviceName, alsaCaptureDeviceList[idx]) == 0)
 490             {
 491                 pDevice->szDeviceName = alsaCaptureDeviceList[idx];
 492                 if(idx > 0)
 493                     sprintf(driver, "hw:%zd,0", idx-1);
 494                 goto open_alsa;
 495             }
 496         }
 497         return ALC_FALSE;
 498     }
 499     else
 500         pDevice->szDeviceName = alsaCaptureDeviceList[0];
 501
 502 open_alsa:
 503     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 504
 505     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 506     if(i < 0)
 507     {
 508         Sleep(200);
 509         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 510     }
 511     if(i >= 0)
 512     {
 513         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 514         if(i < 0)
 515             psnd_pcm_close(data->pcmHandle);
 516     }
 517     if(i < 0)
 518     {
 519         free(data);
 520         AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
 521         return ALC_FALSE;
 522     }
 523
 524     switch(aluBytesFromFormat(format))
 525     {
 526         case 1:
 527             alsaFormat = SND_PCM_FORMAT_U8;
 528             break;
 529         case 2:
 530             alsaFormat = SND_PCM_FORMAT_S16;
 531             break;
 532         default:
 533             alsaFormat = SND_PCM_FORMAT_UNKNOWN;
 534             AL_PRINT("Unknown format?! %x\n", format);
 535     }
 536
 537     bufferSizeInFrames = SampleSize / periods;
 538
 539     psnd_pcm_hw_params_malloc(&p);
 540 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
 541     /* start with the largest configuration space possible */
 542     if(!(ok(psnd_pcm_hw_params_any(data->pcmHandle, p), "any") &&
 543          /* set interleaved access */
 544          ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set access") &&
 545          /* set format (implicitly sets sample bits) */
 546          ok(psnd_pcm_hw_params_set_format(data->pcmHandle, p, alsaFormat), "set format") &&
 547          /* set channels (implicitly sets frame bits) */
 548          ok(psnd_pcm_hw_params_set_channels(data->pcmHandle, p, pDevice->Channels), "set channels") &&
 549          /* set periods (implicitly constrains period/buffer parameters) */
 550          ok(psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL), "set periods near") &&
 551          /* set rate (implicitly constrains period/buffer parameters) */
 552          ok(psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0), "set rate") &&
 553          /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 554          ok(psnd_pcm_hw_params_set_buffer_size_min(data->pcmHandle, p, &bufferSizeInFrames), "set buffer size min") &&
 555          /* install and prepare hardware configuration */
 556          ok(psnd_pcm_hw_params(data->pcmHandle, p), "set params")))
 557     {
 558         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 559         psnd_pcm_hw_params_free(p);
 560         psnd_pcm_close(data->pcmHandle);
 561         free(data);
 562         return ALC_FALSE;
 563     }
 564 #undef ok
 565     psnd_pcm_hw_params_free(p);
 566
 567     i = psnd_pcm_prepare(data->pcmHandle);
 568     if(i < 0)
 569     {
 570         AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 571         psnd_pcm_close(data->pcmHandle);
 572         free(data);
 573         return ALC_FALSE;
 574     }
 575
 576     pDevice->ExtraData = data;
 577     return ALC_TRUE;
 578 }
 579
 580 static void alsa_close_capture(ALCdevice *pDevice)
 581 {
 582     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 583     psnd_pcm_close(data->pcmHandle);
 584
 585     free(data);
 586     pDevice->ExtraData = NULL;
 587 }
 588
 589 static void alsa_start_capture(ALCdevice *pDevice)
 590 {
 591     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 592     psnd_pcm_start(data->pcmHandle);
 593 }
 594
 595 static void alsa_stop_capture(ALCdevice *pDevice)
 596 {
 597     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 598     psnd_pcm_drain(data->pcmHandle);
 599 }
 600
 601 static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 602 {
 603     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 604     const snd_pcm_channel_area_t *areas = NULL;
 605     snd_pcm_sframes_t frames, commitres;
 606     snd_pcm_uframes_t size, offset;
 607     int err;
 608
 609     frames = psnd_pcm_avail_update(data->pcmHandle);
 610     if(frames < 0)
 611     {
 612         err = xrun_recovery(data->pcmHandle, frames);
 613         if (err < 0)
 614             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 615         else
 616             frames = psnd_pcm_avail_update(data->pcmHandle);
 617     }
 618     if (frames < (snd_pcm_sframes_t)lSamples)
 619     {
 620         SetALCError(ALC_INVALID_VALUE);
 621         return;
 622     }
 623
 624     // it is possible that contiguous areas are smaller, thus we use a loop
 625     while (lSamples > 0)
 626     {
 627         char *Pointer;
 628         int Count;
 629
 630         size = lSamples;
 631         err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &size);
 632         if (err < 0)
 633         {
 634             err = xrun_recovery(data->pcmHandle, err);
 635             if (err < 0)
 636             {
 637                 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 638                 break;
 639             }
 640             continue;
 641         }
 642
 643         Pointer = (char*)areas->addr + (offset * areas->step / 8);
 644         Count = size * pDevice->FrameSize;
 645
 646         memcpy(pBuffer, Pointer, Count);
 647         pBuffer = (char*)pBuffer + Count;
 648
 649         commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, size);
 650         if (commitres < 0 || (commitres-size) != 0)
 651         {
 652            AL_PRINT("mmap commit error: %s\n",
 653                     psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 654            break;
 655         }
 656
 657         lSamples -= size;
 658     }
 659 }
 660
 661 static ALCuint alsa_available_samples(ALCdevice *pDevice)
 662 {
 663     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 664     snd_pcm_sframes_t frames = psnd_pcm_avail_update(data->pcmHandle);
 665     if(frames < 0)
 666     {
 667         int err = xrun_recovery(data->pcmHandle, frames);
 668         if (err < 0)
 669             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 670         else
 671             frames = psnd_pcm_avail_update(data->pcmHandle);
 672         if(frames < 0) /* ew.. */
 673             SetALCError(ALC_INVALID_DEVICE);
 674     }
 675     return max(frames, 0);
 676 }
 677
 678
 679 BackendFuncs alsa_funcs = {
 680     alsa_open_playback,
 681     alsa_close_playback,
 682     alsa_open_capture,
 683     alsa_close_capture,
 684     alsa_start_capture,
 685     alsa_stop_capture,
 686     alsa_capture_samples,
 687     alsa_available_samples
 688 };
 689
 690 void alc_alsa_init(BackendFuncs *func_list)
 691 {
 692     snd_ctl_t *handle;
 693     int card, err, dev, idx = 1;
 694     snd_ctl_card_info_t *info;
 695     snd_pcm_info_t *pcminfo;
 696     snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
 697     char name[128];
 698     char *str;
 699
 700     *func_list = alsa_funcs;
 701
 702 #ifdef HAVE_DLFCN_H
 703     alsa_handle = dlopen("libasound.so.2", RTLD_NOW);
 704     if(!alsa_handle)
 705         return;
 706     dlerror();
 707
 708 #define LOAD_FUNC(f) do { \
 709     p##f = (typeof(f)*)dlsym(alsa_handle, #f); \
 710     if((str=dlerror()) != NULL) \
 711     { \
 712         dlclose(alsa_handle); \
 713         alsa_handle = NULL; \
 714         AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
 715         return; \
 716     } \
 717 } while(0)
 718 #else
 719     str = NULL;
 720     alsa_handle = 0xDEADBEEF;
 721 #define LOAD_FUNC(f) p##f = f
 722 #endif
 723
 724 LOAD_FUNC(snd_strerror);
 725 LOAD_FUNC(snd_pcm_open);
 726 LOAD_FUNC(snd_pcm_close);
 727 LOAD_FUNC(snd_pcm_nonblock);
 728 LOAD_FUNC(snd_pcm_frames_to_bytes);
 729 LOAD_FUNC(snd_pcm_hw_params_malloc);
 730 LOAD_FUNC(snd_pcm_hw_params_free);
 731 LOAD_FUNC(snd_pcm_hw_params_any);
 732 LOAD_FUNC(snd_pcm_hw_params_set_access);
 733 LOAD_FUNC(snd_pcm_hw_params_set_format);
 734 LOAD_FUNC(snd_pcm_hw_params_set_channels);
 735 LOAD_FUNC(snd_pcm_hw_params_set_periods_near);
 736 LOAD_FUNC(snd_pcm_hw_params_set_rate_near);
 737 LOAD_FUNC(snd_pcm_hw_params_set_rate);
 738 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near);
 739 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min);
 740 LOAD_FUNC(snd_pcm_hw_params_get_access);
 741 LOAD_FUNC(snd_pcm_hw_params);
 742 LOAD_FUNC(snd_pcm_prepare);
 743 LOAD_FUNC(snd_pcm_start);
 744 LOAD_FUNC(snd_pcm_resume);
 745 LOAD_FUNC(snd_pcm_state);
 746 LOAD_FUNC(snd_pcm_avail_update);
 747 LOAD_FUNC(snd_pcm_areas_silence);
 748 LOAD_FUNC(snd_pcm_mmap_begin);
 749 LOAD_FUNC(snd_pcm_mmap_commit);
 750 LOAD_FUNC(snd_pcm_writei);
 751 LOAD_FUNC(snd_pcm_drain);
 752
 753 LOAD_FUNC(snd_pcm_info_malloc);
 754 LOAD_FUNC(snd_pcm_info_free);
 755 LOAD_FUNC(snd_pcm_info_set_device);
 756 LOAD_FUNC(snd_pcm_info_set_subdevice);
 757 LOAD_FUNC(snd_pcm_info_set_stream);
 758 LOAD_FUNC(snd_pcm_info_get_name);
 759 LOAD_FUNC(snd_ctl_pcm_next_device);
 760 LOAD_FUNC(snd_ctl_pcm_info);
 761 LOAD_FUNC(snd_ctl_open);
 762 LOAD_FUNC(snd_ctl_close);
 763 LOAD_FUNC(snd_ctl_card_info_malloc);
 764 LOAD_FUNC(snd_ctl_card_info_free);
 765 LOAD_FUNC(snd_ctl_card_info);
 766 LOAD_FUNC(snd_ctl_card_info_get_name);
 767 LOAD_FUNC(snd_card_next);
 768
 769 #undef LOAD_FUNC
 770
 771     psnd_ctl_card_info_malloc(&info);
 772     psnd_pcm_info_malloc(&pcminfo);
 773
 774     card = -1;
 775     if(psnd_card_next(&card) < 0 || card < 0)
 776         AL_PRINT("no playback cards found...\n");
 777     else
 778     {
 779         alsaDeviceList[0] = AppendDeviceList("ALSA Software on default");
 780         allDevNameMap[0].name = AppendAllDeviceList("ALSA Software on default");
 781     }
 782
 783     while (card >= 0) {
 784         sprintf(name, "hw:%d", card);
 785         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
 786             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
 787             goto next_card;
 788         }
 789         if ((err = psnd_ctl_card_info(handle, info)) < 0) {
 790             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
 791             psnd_ctl_close(handle);
 792             goto next_card;
 793         }
 794         if(card < MAX_DEVICES-1) {
 795             snprintf(name, sizeof(name), "ALSA Software on %s",
 796                      psnd_ctl_card_info_get_name(info));
 797             alsaDeviceList[card+1] = AppendDeviceList(name);
 798         }
 799
 800         dev = -1;
 801         while (idx < MAX_ALL_DEVICES) {
 802             const char *cname, *dname;
 803
 804             if (psnd_ctl_pcm_next_device(handle, &dev)<0)
 805                 AL_PRINT("snd_ctl_pcm_next_device failed\n");
 806             if (dev < 0)
 807                 break;
 808             psnd_pcm_info_set_device(pcminfo, dev);
 809             psnd_pcm_info_set_subdevice(pcminfo, 0);
 810             psnd_pcm_info_set_stream(pcminfo, stream);
 811             if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
 812                 if (err != -ENOENT)
 813                     AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
 814                 continue;
 815             }
 816
 817             cname = psnd_ctl_card_info_get_name(info);
 818             dname = psnd_pcm_info_get_name(pcminfo);
 819             snprintf(name, sizeof(name), "ALSA Software on %s [%s]",
 820                      cname, dname);
 821             allDevNameMap[idx].name = AppendAllDeviceList(name);
 822             allDevNameMap[idx].card = card;
 823             allDevNameMap[idx].dev = dev;
 824             idx++;
 825         }
 826         psnd_ctl_close(handle);
 827 next_card:
 828         if(psnd_card_next(&card) < 0) {
 829             AL_PRINT("snd_card_next failed\n");
 830             break;
 831         }
 832     }
 833
 834
 835     stream = SND_PCM_STREAM_CAPTURE;
 836
 837     card = -1;
 838     if(psnd_card_next(&card) < 0 || card < 0) {
 839         AL_PRINT("no capture cards found...\n");
 840         psnd_pcm_info_free(pcminfo);
 841         psnd_ctl_card_info_free(info);
 842         return;
 843     }
 844
 845     alsaCaptureDeviceList[0] = AppendCaptureDeviceList("ALSA Capture on default");
 846
 847     while (card >= 0) {
 848         sprintf(name, "hw:%d", card);
 849         handle = NULL;
 850         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
 851             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
 852         }
 853         if (err >= 0 && (err = psnd_ctl_card_info(handle, info)) < 0) {
 854             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
 855         }
 856         else if (err >= 0 && card < MAX_DEVICES-1)
 857         {
 858             snprintf(name, sizeof(name), "ALSA Capture on %s",
 859                      psnd_ctl_card_info_get_name(info));
 860             alsaCaptureDeviceList[card+1] = AppendCaptureDeviceList(name);
 861         }
 862         if(handle) psnd_ctl_close(handle);
 863         if(psnd_card_next(&card) < 0) {
 864             AL_PRINT("snd_card_next failed\n");
 865             break;
 866         }
 867     }
 868     psnd_pcm_info_free(pcminfo);
 869     psnd_ctl_card_info_free(info);
 870 }