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                 {
 181                     err = xrun_recovery(data->pcmHandle, err);
 182                     if (err < 0)
 183                     {
 184                         AL_PRINT("start failed: %s\n", psnd_strerror(err));
 185                         break;
 186                     }
 187                 }
 188             }
 189             Sleep(1);
 190             continue;
 191         }
 192
 193         // it is possible that contiguous areas are smaller, thus we use a loop
 194         while (avail > 0)
 195         {
 196             frames = avail;
 197
 198             err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &frames);
 199             if (err < 0)
 200             {
 201                 err = xrun_recovery(data->pcmHandle, err);
 202                 if (err < 0)
 203                     AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 204                 break;
 205             }
 206
 207             SuspendContext(NULL);
 208             WritePtr = (char*)areas->addr + (offset * areas->step / 8);
 209             WriteCnt = psnd_pcm_frames_to_bytes(data->pcmHandle, frames);
 210             aluMixData(pDevice->Context, WritePtr, WriteCnt, pDevice->Format);
 211             ProcessContext(NULL);
 212
 213             commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, frames);
 214             if (commitres < 0 || (commitres-frames) != 0)
 215             {
 216                 AL_PRINT("mmap commit error: %s\n",
 217                          psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 218                 break;
 219             }
 220
 221             avail -= frames;
 222         }
 223     }
 224
 225     return 0;
 226 }
 227
 228 static ALuint ALSANoMMapProc(ALvoid *ptr)
 229 {
 230     ALCdevice *pDevice = (ALCdevice*)ptr;
 231     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 232     snd_pcm_sframes_t avail;
 233     char *WritePtr;
 234
 235     while(!data->killNow)
 236     {
 237         SuspendContext(NULL);
 238         aluMixData(pDevice->Context, data->buffer, data->size, pDevice->Format);
 239         ProcessContext(NULL);
 240
 241         WritePtr = data->buffer;
 242         avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
 243         while(avail > 0)
 244         {
 245             int ret = psnd_pcm_writei(data->pcmHandle, WritePtr, avail);
 246             switch (ret)
 247             {
 248             case -EAGAIN:
 249                 continue;
 250             case -ESTRPIPE:
 251                 while((ret=psnd_pcm_resume(data->pcmHandle)) == -EAGAIN)
 252                     Sleep(1);
 253                 break;
 254             case -EPIPE:
 255                 break;
 256             default:
 257                 if (ret >= 0)
 258                 {
 259                     WritePtr += psnd_pcm_frames_to_bytes(data->pcmHandle, ret);
 260                     avail -= ret;
 261                 }
 262                 break;
 263             }
 264             if (ret < 0)
 265             {
 266                 ret = psnd_pcm_prepare(data->pcmHandle);
 267                 if(ret < 0)
 268                     break;
 269             }
 270         }
 271     }
 272
 273     return 0;
 274 }
 275
 276 static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
 277 {
 278     snd_pcm_uframes_t bufferSizeInFrames;
 279     snd_pcm_hw_params_t *p = NULL;
 280     snd_pcm_access_t access;
 281     unsigned int periods;
 282     alsa_data *data;
 283     char driver[64];
 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     psnd_pcm_hw_params_malloc(&p);
 364 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
 365     /* start with the largest configuration space possible */
 366     if(!(ok(psnd_pcm_hw_params_any(data->pcmHandle, p), "any") &&
 367          /* set interleaved access */
 368          (ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set access") ||
 369           ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED), "set access")) &&
 370          /* set format (implicitly sets sample bits) */
 371          ok(psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format), "set format") &&
 372          /* set channels (implicitly sets frame bits) */
 373          ok(psnd_pcm_hw_params_set_channels(data->pcmHandle, p, device->Channels), "set channels") &&
 374          /* set periods (implicitly constrains period/buffer parameters) */
 375          ok(psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL), "set periods near") &&
 376          /* set rate (implicitly constrains period/buffer parameters) */
 377          ok(psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &device->Frequency, NULL), "set rate near") &&
 378          /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 379          ok(psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames), "set buffer size near") &&
 380          /* install and prepare hardware configuration */
 381          ok(psnd_pcm_hw_params(data->pcmHandle, p), "set params")))
 382     {
 383         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 384         psnd_pcm_hw_params_free(p);
 385         psnd_pcm_close(data->pcmHandle);
 386         free(data);
 387         return ALC_FALSE;
 388     }
 389 #undef ok
 390
 391     if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
 392     {
 393         AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
 394         psnd_pcm_hw_params_free(p);
 395         psnd_pcm_close(data->pcmHandle);
 396         free(data);
 397         return ALC_FALSE;
 398     }
 399
 400     psnd_pcm_hw_params_free(p);
 401
 402     device->MaxNoOfSources = 256;
 403     device->UpdateFreq = bufferSizeInFrames;
 404
 405     data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, device->UpdateFreq);
 406     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 407     {
 408         data->buffer = malloc(data->size);
 409         if(!data->buffer)
 410         {
 411             AL_PRINT("buffer malloc failed\n");
 412             psnd_pcm_close(data->pcmHandle);
 413             free(data);
 414             return ALC_FALSE;
 415         }
 416     }
 417     else
 418     {
 419         i = psnd_pcm_prepare(data->pcmHandle);
 420         if(i < 0)
 421         {
 422             AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 423             psnd_pcm_close(data->pcmHandle);
 424             free(data->buffer);
 425             free(data);
 426             return ALC_FALSE;
 427         }
 428     }
 429
 430     device->ExtraData = data;
 431     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 432         data->thread = StartThread(ALSANoMMapProc, device);
 433     else
 434         data->thread = StartThread(ALSAProc, device);
 435     if(data->thread == NULL)
 436     {
 437         psnd_pcm_close(data->pcmHandle);
 438         device->ExtraData = NULL;
 439         free(data->buffer);
 440         free(data);
 441         return ALC_FALSE;
 442     }
 443
 444     return ALC_TRUE;
 445 }
 446
 447 static void alsa_close_playback(ALCdevice *device)
 448 {
 449     alsa_data *data = (alsa_data*)device->ExtraData;
 450     data->killNow = 1;
 451     StopThread(data->thread);
 452     psnd_pcm_close(data->pcmHandle);
 453
 454     free(data->buffer);
 455     free(data);
 456     device->ExtraData = NULL;
 457 }
 458
 459
 460 static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
 461 {
 462     snd_pcm_format_t alsaFormat;
 463     snd_pcm_hw_params_t *p;
 464     unsigned int periods = 4;
 465     snd_pcm_uframes_t bufferSizeInFrames;
 466     alsa_data *data;
 467     char driver[64];
 468     char *err;
 469     int i;
 470
 471     if(!alsa_handle)
 472         return ALC_FALSE;
 473
 474     strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
 475     driver[sizeof(driver)-1] = 0;
 476     if(deviceName)
 477     {
 478         size_t idx;
 479
 480         for(idx = 0;idx < MAX_DEVICES;idx++)
 481         {
 482             if(alsaCaptureDeviceList[idx] &&
 483                strcmp(deviceName, alsaCaptureDeviceList[idx]) == 0)
 484             {
 485                 pDevice->szDeviceName = alsaCaptureDeviceList[idx];
 486                 if(idx > 0)
 487                     sprintf(driver, "hw:%zd,0", idx-1);
 488                 goto open_alsa;
 489             }
 490         }
 491         return ALC_FALSE;
 492     }
 493     else
 494         pDevice->szDeviceName = alsaCaptureDeviceList[0];
 495
 496 open_alsa:
 497     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 498
 499     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 500     if(i < 0)
 501     {
 502         Sleep(200);
 503         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 504     }
 505     if(i >= 0)
 506     {
 507         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 508         if(i < 0)
 509             psnd_pcm_close(data->pcmHandle);
 510     }
 511     if(i < 0)
 512     {
 513         free(data);
 514         AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
 515         return ALC_FALSE;
 516     }
 517
 518     switch(aluBytesFromFormat(format))
 519     {
 520         case 1:
 521             alsaFormat = SND_PCM_FORMAT_U8;
 522             break;
 523         case 2:
 524             alsaFormat = SND_PCM_FORMAT_S16;
 525             break;
 526         default:
 527             alsaFormat = SND_PCM_FORMAT_UNKNOWN;
 528             AL_PRINT("Unknown format?! %x\n", format);
 529     }
 530
 531     bufferSizeInFrames = SampleSize / periods;
 532
 533     psnd_pcm_hw_params_malloc(&p);
 534 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
 535     /* start with the largest configuration space possible */
 536     if(!(ok(psnd_pcm_hw_params_any(data->pcmHandle, p), "any") &&
 537          /* set interleaved access */
 538          ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set access") &&
 539          /* set format (implicitly sets sample bits) */
 540          ok(psnd_pcm_hw_params_set_format(data->pcmHandle, p, alsaFormat), "set format") &&
 541          /* set channels (implicitly sets frame bits) */
 542          ok(psnd_pcm_hw_params_set_channels(data->pcmHandle, p, pDevice->Channels), "set channels") &&
 543          /* set periods (implicitly constrains period/buffer parameters) */
 544          ok(psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL), "set periods near") &&
 545          /* set rate (implicitly constrains period/buffer parameters) */
 546          ok(psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0), "set rate") &&
 547          /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 548          ok(psnd_pcm_hw_params_set_buffer_size_min(data->pcmHandle, p, &bufferSizeInFrames), "set buffer size min") &&
 549          /* install and prepare hardware configuration */
 550          ok(psnd_pcm_hw_params(data->pcmHandle, p), "set params")))
 551     {
 552         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 553         psnd_pcm_hw_params_free(p);
 554         psnd_pcm_close(data->pcmHandle);
 555         free(data);
 556         return ALC_FALSE;
 557     }
 558 #undef ok
 559     psnd_pcm_hw_params_free(p);
 560
 561     i = psnd_pcm_prepare(data->pcmHandle);
 562     if(i < 0)
 563     {
 564         AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 565         psnd_pcm_close(data->pcmHandle);
 566         free(data);
 567         return ALC_FALSE;
 568     }
 569
 570     pDevice->ExtraData = data;
 571     return ALC_TRUE;
 572 }
 573
 574 static void alsa_close_capture(ALCdevice *pDevice)
 575 {
 576     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 577     psnd_pcm_close(data->pcmHandle);
 578
 579     free(data);
 580     pDevice->ExtraData = NULL;
 581 }
 582
 583 static void alsa_start_capture(ALCdevice *pDevice)
 584 {
 585     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 586     psnd_pcm_start(data->pcmHandle);
 587 }
 588
 589 static void alsa_stop_capture(ALCdevice *pDevice)
 590 {
 591     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 592     psnd_pcm_drain(data->pcmHandle);
 593 }
 594
 595 static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 596 {
 597     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 598     const snd_pcm_channel_area_t *areas = NULL;
 599     snd_pcm_sframes_t frames, commitres;
 600     snd_pcm_uframes_t size, offset;
 601     int err;
 602
 603     frames = psnd_pcm_avail_update(data->pcmHandle);
 604     if(frames < 0)
 605     {
 606         err = xrun_recovery(data->pcmHandle, frames);
 607         if (err < 0)
 608             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 609         else
 610             frames = psnd_pcm_avail_update(data->pcmHandle);
 611     }
 612     if (frames < (snd_pcm_sframes_t)lSamples)
 613     {
 614         SetALCError(ALC_INVALID_VALUE);
 615         return;
 616     }
 617
 618     // it is possible that contiguous areas are smaller, thus we use a loop
 619     while (lSamples > 0)
 620     {
 621         char *Pointer;
 622         int Count;
 623
 624         size = lSamples;
 625         err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &size);
 626         if (err < 0)
 627         {
 628             err = xrun_recovery(data->pcmHandle, err);
 629             if (err < 0)
 630             {
 631                 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 632                 break;
 633             }
 634             continue;
 635         }
 636
 637         Pointer = (char*)areas->addr + (offset * areas->step / 8);
 638         Count = size * pDevice->FrameSize;
 639
 640         memcpy(pBuffer, Pointer, Count);
 641         pBuffer = (char*)pBuffer + Count;
 642
 643         commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, size);
 644         if (commitres < 0 || (commitres-size) != 0)
 645         {
 646            AL_PRINT("mmap commit error: %s\n",
 647                     psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 648            break;
 649         }
 650
 651         lSamples -= size;
 652     }
 653 }
 654
 655 static ALCuint alsa_available_samples(ALCdevice *pDevice)
 656 {
 657     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 658     snd_pcm_sframes_t frames = psnd_pcm_avail_update(data->pcmHandle);
 659     if(frames < 0)
 660     {
 661         int err = xrun_recovery(data->pcmHandle, frames);
 662         if (err < 0)
 663             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 664         else
 665             frames = psnd_pcm_avail_update(data->pcmHandle);
 666         if(frames < 0) /* ew.. */
 667             SetALCError(ALC_INVALID_DEVICE);
 668     }
 669     return max(frames, 0);
 670 }
 671
 672
 673 BackendFuncs alsa_funcs = {
 674     alsa_open_playback,
 675     alsa_close_playback,
 676     alsa_open_capture,
 677     alsa_close_capture,
 678     alsa_start_capture,
 679     alsa_stop_capture,
 680     alsa_capture_samples,
 681     alsa_available_samples
 682 };
 683
 684 void alc_alsa_init(BackendFuncs *func_list)
 685 {
 686     snd_ctl_t *handle;
 687     int card, err, dev, idx = 1;
 688     snd_ctl_card_info_t *info;
 689     snd_pcm_info_t *pcminfo;
 690     snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
 691     char name[128];
 692     char *str;
 693
 694     *func_list = alsa_funcs;
 695
 696 #ifdef HAVE_DLFCN_H
 697     alsa_handle = dlopen("libasound.so.2", RTLD_NOW);
 698     if(!alsa_handle)
 699         return;
 700     dlerror();
 701
 702 #define LOAD_FUNC(f) do { \
 703     p##f = (typeof(f)*)dlsym(alsa_handle, #f); \
 704     if((str=dlerror()) != NULL) \
 705     { \
 706         dlclose(alsa_handle); \
 707         alsa_handle = NULL; \
 708         AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
 709         return; \
 710     } \
 711 } while(0)
 712 #else
 713     str = NULL;
 714     alsa_handle = 0xDEADBEEF;
 715 #define LOAD_FUNC(f) p##f = f
 716 #endif
 717
 718 LOAD_FUNC(snd_strerror);
 719 LOAD_FUNC(snd_pcm_open);
 720 LOAD_FUNC(snd_pcm_close);
 721 LOAD_FUNC(snd_pcm_nonblock);
 722 LOAD_FUNC(snd_pcm_frames_to_bytes);
 723 LOAD_FUNC(snd_pcm_hw_params_malloc);
 724 LOAD_FUNC(snd_pcm_hw_params_free);
 725 LOAD_FUNC(snd_pcm_hw_params_any);
 726 LOAD_FUNC(snd_pcm_hw_params_set_access);
 727 LOAD_FUNC(snd_pcm_hw_params_set_format);
 728 LOAD_FUNC(snd_pcm_hw_params_set_channels);
 729 LOAD_FUNC(snd_pcm_hw_params_set_periods_near);
 730 LOAD_FUNC(snd_pcm_hw_params_set_rate_near);
 731 LOAD_FUNC(snd_pcm_hw_params_set_rate);
 732 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near);
 733 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min);
 734 LOAD_FUNC(snd_pcm_hw_params_get_access);
 735 LOAD_FUNC(snd_pcm_hw_params);
 736 LOAD_FUNC(snd_pcm_prepare);
 737 LOAD_FUNC(snd_pcm_start);
 738 LOAD_FUNC(snd_pcm_resume);
 739 LOAD_FUNC(snd_pcm_state);
 740 LOAD_FUNC(snd_pcm_avail_update);
 741 LOAD_FUNC(snd_pcm_areas_silence);
 742 LOAD_FUNC(snd_pcm_mmap_begin);
 743 LOAD_FUNC(snd_pcm_mmap_commit);
 744 LOAD_FUNC(snd_pcm_writei);
 745 LOAD_FUNC(snd_pcm_drain);
 746
 747 LOAD_FUNC(snd_pcm_info_malloc);
 748 LOAD_FUNC(snd_pcm_info_free);
 749 LOAD_FUNC(snd_pcm_info_set_device);
 750 LOAD_FUNC(snd_pcm_info_set_subdevice);
 751 LOAD_FUNC(snd_pcm_info_set_stream);
 752 LOAD_FUNC(snd_pcm_info_get_name);
 753 LOAD_FUNC(snd_ctl_pcm_next_device);
 754 LOAD_FUNC(snd_ctl_pcm_info);
 755 LOAD_FUNC(snd_ctl_open);
 756 LOAD_FUNC(snd_ctl_close);
 757 LOAD_FUNC(snd_ctl_card_info_malloc);
 758 LOAD_FUNC(snd_ctl_card_info_free);
 759 LOAD_FUNC(snd_ctl_card_info);
 760 LOAD_FUNC(snd_ctl_card_info_get_name);
 761 LOAD_FUNC(snd_card_next);
 762
 763 #undef LOAD_FUNC
 764
 765     psnd_ctl_card_info_malloc(&info);
 766     psnd_pcm_info_malloc(&pcminfo);
 767
 768     card = -1;
 769     if(psnd_card_next(&card) < 0 || card < 0)
 770         AL_PRINT("no playback cards found...\n");
 771     else
 772     {
 773         alsaDeviceList[0] = AppendDeviceList("ALSA Software on default");
 774         allDevNameMap[0].name = AppendAllDeviceList("ALSA Software on default");
 775     }
 776
 777     while (card >= 0) {
 778         sprintf(name, "hw:%d", card);
 779         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
 780             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
 781             goto next_card;
 782         }
 783         if ((err = psnd_ctl_card_info(handle, info)) < 0) {
 784             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
 785             psnd_ctl_close(handle);
 786             goto next_card;
 787         }
 788         if(card < MAX_DEVICES-1) {
 789             snprintf(name, sizeof(name), "ALSA Software on %s",
 790                      psnd_ctl_card_info_get_name(info));
 791             alsaDeviceList[card+1] = AppendDeviceList(name);
 792         }
 793
 794         dev = -1;
 795         while (idx < MAX_ALL_DEVICES) {
 796             const char *cname, *dname;
 797
 798             if (psnd_ctl_pcm_next_device(handle, &dev)<0)
 799                 AL_PRINT("snd_ctl_pcm_next_device failed\n");
 800             if (dev < 0)
 801                 break;
 802             psnd_pcm_info_set_device(pcminfo, dev);
 803             psnd_pcm_info_set_subdevice(pcminfo, 0);
 804             psnd_pcm_info_set_stream(pcminfo, stream);
 805             if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
 806                 if (err != -ENOENT)
 807                     AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
 808                 continue;
 809             }
 810
 811             cname = psnd_ctl_card_info_get_name(info);
 812             dname = psnd_pcm_info_get_name(pcminfo);
 813             snprintf(name, sizeof(name), "ALSA Software on %s [%s]",
 814                      cname, dname);
 815             allDevNameMap[idx].name = AppendAllDeviceList(name);
 816             allDevNameMap[idx].card = card;
 817             allDevNameMap[idx].dev = dev;
 818             idx++;
 819         }
 820         psnd_ctl_close(handle);
 821 next_card:
 822         if(psnd_card_next(&card) < 0) {
 823             AL_PRINT("snd_card_next failed\n");
 824             break;
 825         }
 826     }
 827
 828
 829     stream = SND_PCM_STREAM_CAPTURE;
 830
 831     card = -1;
 832     if(psnd_card_next(&card) < 0 || card < 0) {
 833         AL_PRINT("no capture cards found...\n");
 834         psnd_pcm_info_free(pcminfo);
 835         psnd_ctl_card_info_free(info);
 836         return;
 837     }
 838
 839     alsaCaptureDeviceList[0] = AppendCaptureDeviceList("ALSA Capture on default");
 840
 841     while (card >= 0) {
 842         sprintf(name, "hw:%d", card);
 843         handle = NULL;
 844         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
 845             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
 846         }
 847         if (err >= 0 && (err = psnd_ctl_card_info(handle, info)) < 0) {
 848             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
 849         }
 850         else if (err >= 0 && card < MAX_DEVICES-1)
 851         {
 852             snprintf(name, sizeof(name), "ALSA Capture on %s",
 853                      psnd_ctl_card_info_get_name(info));
 854             alsaCaptureDeviceList[card+1] = AppendCaptureDeviceList(name);
 855         }
 856         if(handle) psnd_ctl_close(handle);
 857         if(psnd_card_next(&card) < 0) {
 858             AL_PRINT("snd_card_next failed\n");
 859             break;
 860         }
 861     }
 862     psnd_pcm_info_free(pcminfo);
 863     psnd_ctl_card_info_free(info);
 864 }