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