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