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     RingBuffer *ring;
  44     int doCapture;
  45
  46     volatile int killNow;
  47     ALvoid *thread;
  48 } alsa_data;
  49
  50 typedef struct {
  51     ALCchar *name;
  52     int card, dev;
  53 } DevMap;
  54
  55 static void *alsa_handle;
  56 #define MAKE_FUNC(f) static typeof(f) * p##f
  57 MAKE_FUNC(snd_strerror);
  58 MAKE_FUNC(snd_pcm_open);
  59 MAKE_FUNC(snd_pcm_close);
  60 MAKE_FUNC(snd_pcm_nonblock);
  61 MAKE_FUNC(snd_pcm_frames_to_bytes);
  62 MAKE_FUNC(snd_pcm_hw_params_malloc);
  63 MAKE_FUNC(snd_pcm_hw_params_free);
  64 MAKE_FUNC(snd_pcm_hw_params_any);
  65 MAKE_FUNC(snd_pcm_hw_params_set_access);
  66 MAKE_FUNC(snd_pcm_hw_params_set_format);
  67 MAKE_FUNC(snd_pcm_hw_params_set_channels);
  68 MAKE_FUNC(snd_pcm_hw_params_set_periods_near);
  69 MAKE_FUNC(snd_pcm_hw_params_set_rate_near);
  70 MAKE_FUNC(snd_pcm_hw_params_set_rate);
  71 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_near);
  72 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_min);
  73 MAKE_FUNC(snd_pcm_hw_params_get_buffer_size);
  74 MAKE_FUNC(snd_pcm_hw_params_get_period_size);
  75 MAKE_FUNC(snd_pcm_hw_params_get_access);
  76 MAKE_FUNC(snd_pcm_hw_params);
  77 MAKE_FUNC(snd_pcm_sw_params_malloc);
  78 MAKE_FUNC(snd_pcm_sw_params_current);
  79 MAKE_FUNC(snd_pcm_sw_params_set_avail_min);
  80 MAKE_FUNC(snd_pcm_sw_params);
  81 MAKE_FUNC(snd_pcm_sw_params_free);
  82 MAKE_FUNC(snd_pcm_prepare);
  83 MAKE_FUNC(snd_pcm_start);
  84 MAKE_FUNC(snd_pcm_resume);
  85 MAKE_FUNC(snd_pcm_wait);
  86 MAKE_FUNC(snd_pcm_state);
  87 MAKE_FUNC(snd_pcm_avail_update);
  88 MAKE_FUNC(snd_pcm_areas_silence);
  89 MAKE_FUNC(snd_pcm_mmap_begin);
  90 MAKE_FUNC(snd_pcm_mmap_commit);
  91 MAKE_FUNC(snd_pcm_readi);
  92 MAKE_FUNC(snd_pcm_writei);
  93 MAKE_FUNC(snd_pcm_drain);
  94 MAKE_FUNC(snd_pcm_info_malloc);
  95 MAKE_FUNC(snd_pcm_info_free);
  96 MAKE_FUNC(snd_pcm_info_set_device);
  97 MAKE_FUNC(snd_pcm_info_set_subdevice);
  98 MAKE_FUNC(snd_pcm_info_set_stream);
  99 MAKE_FUNC(snd_pcm_info_get_name);
 100 MAKE_FUNC(snd_ctl_pcm_next_device);
 101 MAKE_FUNC(snd_ctl_pcm_info);
 102 MAKE_FUNC(snd_ctl_open);
 103 MAKE_FUNC(snd_ctl_close);
 104 MAKE_FUNC(snd_ctl_card_info_malloc);
 105 MAKE_FUNC(snd_ctl_card_info_free);
 106 MAKE_FUNC(snd_ctl_card_info);
 107 MAKE_FUNC(snd_ctl_card_info_get_name);
 108 MAKE_FUNC(snd_card_next);
 109 #undef MAKE_FUNC
 110
 111 #define MAX_ALL_DEVICES 32
 112
 113 static ALCchar *alsaDevice;
 114 static DevMap allDevNameMap[MAX_ALL_DEVICES];
 115 static DevMap allCaptureDevNameMap[MAX_ALL_DEVICES];
 116
 117 static int xrun_recovery(snd_pcm_t *handle, int err)
 118 {
 119     if (err == -EPIPE)
 120     {    /* under-run */
 121         err = psnd_pcm_prepare(handle);
 122         if (err < 0)
 123             AL_PRINT("prepare failed: %s\n", psnd_strerror(err));
 124     }
 125     else if (err == -ESTRPIPE)
 126     {
 127         while ((err = psnd_pcm_resume(handle)) == -EAGAIN)
 128             Sleep(1);       /* wait until the suspend flag is released */
 129         if (err < 0)
 130         {
 131             err = psnd_pcm_prepare(handle);
 132             if (err < 0)
 133                 AL_PRINT("prepare failed: %s\n", psnd_strerror(err));
 134         }
 135     }
 136     return err;
 137 }
 138
 139
 140 static ALuint ALSAProc(ALvoid *ptr)
 141 {
 142     ALCdevice *pDevice = (ALCdevice*)ptr;
 143     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 144     const snd_pcm_channel_area_t *areas = NULL;
 145     snd_pcm_sframes_t avail, commitres;
 146     snd_pcm_uframes_t offset, frames;
 147     char *WritePtr;
 148     int WriteCnt;
 149     int err;
 150
 151     while(!data->killNow)
 152     {
 153         snd_pcm_state_t state = psnd_pcm_state(data->pcmHandle);
 154         if(state == SND_PCM_STATE_XRUN)
 155         {
 156             err = xrun_recovery(data->pcmHandle, -EPIPE);
 157             if (err < 0)
 158             {
 159                 AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
 160                 break;
 161             }
 162         }
 163         else if (state == SND_PCM_STATE_SUSPENDED)
 164         {
 165             err = xrun_recovery(data->pcmHandle, -ESTRPIPE);
 166             if (err < 0)
 167             {
 168                 AL_PRINT("SUSPEND recovery failed: %s\n", psnd_strerror(err));
 169                 break;
 170             }
 171         }
 172
 173         avail = psnd_pcm_avail_update(data->pcmHandle);
 174         if(avail < 0)
 175         {
 176             err = xrun_recovery(data->pcmHandle, avail);
 177             if (err < 0)
 178             {
 179                 AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 180                 break;
 181             }
 182         }
 183
 184         // make sure there's frames to process
 185         if(avail >= 0 && avail < (snd_pcm_sframes_t)pDevice->UpdateSize)
 186         {
 187             if(state != SND_PCM_STATE_RUNNING)
 188             {
 189                 err = psnd_pcm_start(data->pcmHandle);
 190                 if(err < 0)
 191                     err = xrun_recovery(data->pcmHandle, err);
 192                 if(err < 0)
 193                 {
 194                     AL_PRINT("start failed: %s\n", psnd_strerror(err));
 195                     break;
 196                 }
 197             }
 198             else if(psnd_pcm_wait(data->pcmHandle, 1000) == 0)
 199                 AL_PRINT("Wait timeout... buffer size too low?\n");
 200             continue;
 201         }
 202         avail = pDevice->UpdateSize;
 203
 204         // it is possible that contiguous areas are smaller, thus we use a loop
 205         while (avail > 0)
 206         {
 207             frames = avail;
 208
 209             SuspendContext(NULL);
 210             err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &frames);
 211             if (err < 0)
 212             {
 213                 err = xrun_recovery(data->pcmHandle, err);
 214                 if (err < 0)
 215                     AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 216                 ProcessContext(NULL);
 217                 break;
 218             }
 219
 220             WritePtr = (char*)areas->addr + (offset * areas->step / 8);
 221             WriteCnt = psnd_pcm_frames_to_bytes(data->pcmHandle, frames);
 222             aluMixData(pDevice->Context, WritePtr, WriteCnt, pDevice->Format);
 223
 224             commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, frames);
 225             if (commitres < 0 || (commitres-frames) != 0)
 226             {
 227                 AL_PRINT("mmap commit error: %s\n",
 228                          psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 229                 ProcessContext(NULL);
 230                 break;
 231             }
 232             ProcessContext(NULL);
 233
 234             avail -= frames;
 235         }
 236     }
 237
 238     return 0;
 239 }
 240
 241 static ALuint ALSANoMMapProc(ALvoid *ptr)
 242 {
 243     ALCdevice *pDevice = (ALCdevice*)ptr;
 244     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 245     snd_pcm_sframes_t avail;
 246     char *WritePtr;
 247
 248     while(!data->killNow)
 249     {
 250         SuspendContext(NULL);
 251         aluMixData(pDevice->Context, data->buffer, data->size, pDevice->Format);
 252         ProcessContext(NULL);
 253
 254         WritePtr = data->buffer;
 255         avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
 256         while(avail > 0)
 257         {
 258             int ret = psnd_pcm_writei(data->pcmHandle, WritePtr, avail);
 259             switch (ret)
 260             {
 261             case -EAGAIN:
 262                 continue;
 263             case -ESTRPIPE:
 264                 while((ret=psnd_pcm_resume(data->pcmHandle)) == -EAGAIN)
 265                     Sleep(1);
 266                 break;
 267             case -EPIPE:
 268                 break;
 269             default:
 270                 if (ret >= 0)
 271                 {
 272                     WritePtr += psnd_pcm_frames_to_bytes(data->pcmHandle, ret);
 273                     avail -= ret;
 274                 }
 275                 break;
 276             }
 277             if (ret < 0)
 278             {
 279                 ret = psnd_pcm_prepare(data->pcmHandle);
 280                 if(ret < 0)
 281                     break;
 282             }
 283         }
 284     }
 285
 286     return 0;
 287 }
 288
 289 static ALuint ALSANoMMapCaptureProc(ALvoid *ptr)
 290 {
 291     ALCdevice *pDevice = (ALCdevice*)ptr;
 292     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 293     snd_pcm_sframes_t avail;
 294
 295     while(!data->killNow)
 296     {
 297         avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
 298         avail = psnd_pcm_readi(data->pcmHandle, data->buffer, avail);
 299         switch(avail)
 300         {
 301             case -EAGAIN:
 302                 continue;
 303             case -ESTRPIPE:
 304                 while((avail=psnd_pcm_resume(data->pcmHandle)) == -EAGAIN)
 305                     Sleep(1);
 306                 break;
 307             case -EPIPE:
 308                 break;
 309             default:
 310                 if (avail >= 0 && data->doCapture)
 311                     WriteRingBuffer(data->ring, data->buffer, avail);
 312                 break;
 313         }
 314         if(avail < 0)
 315         {
 316             avail = psnd_pcm_prepare(data->pcmHandle);
 317             if(avail < 0)
 318                 AL_PRINT("prepare error: %s\n", psnd_strerror(avail));
 319         }
 320     }
 321
 322     return 0;
 323 }
 324
 325 static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
 326 {
 327     alsa_data *data;
 328     char driver[64];
 329     int i;
 330
 331     if(!alsa_handle)
 332         return ALC_FALSE;
 333
 334     strncpy(driver, GetConfigValue("alsa", "device", "default"), sizeof(driver)-1);
 335     driver[sizeof(driver)-1] = 0;
 336     if(deviceName)
 337     {
 338         size_t idx;
 339
 340         for(idx = 0;idx < MAX_ALL_DEVICES;idx++)
 341         {
 342             if(allDevNameMap[idx].name &&
 343                strcmp(deviceName, allDevNameMap[idx].name) == 0)
 344             {
 345                 device->szDeviceName = allDevNameMap[idx].name;
 346                 if(idx > 0)
 347                     sprintf(driver, "hw:%d,%d", allDevNameMap[idx].card, allDevNameMap[idx].dev);
 348                 goto open_alsa;
 349             }
 350         }
 351         if(strcmp(deviceName, alsaDevice) == 0)
 352         {
 353             device->szDeviceName = alsaDevice;
 354             goto open_alsa;
 355         }
 356         return ALC_FALSE;
 357     }
 358     else
 359         device->szDeviceName = alsaDevice;
 360
 361 open_alsa:
 362     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 363
 364     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 365     if(i < 0)
 366     {
 367         Sleep(200);
 368         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 369     }
 370     if(i >= 0)
 371     {
 372         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 373         if(i < 0)
 374             psnd_pcm_close(data->pcmHandle);
 375     }
 376     if(i < 0)
 377     {
 378         free(data);
 379         AL_PRINT("Could not open playback device '%s': %s\n", driver, psnd_strerror(i));
 380         return ALC_FALSE;
 381     }
 382
 383     device->ExtraData = data;
 384     return ALC_TRUE;
 385 }
 386
 387 static void alsa_close_playback(ALCdevice *device)
 388 {
 389     alsa_data *data = (alsa_data*)device->ExtraData;
 390
 391     psnd_pcm_close(data->pcmHandle);
 392     free(data);
 393     device->ExtraData = NULL;
 394 }
 395
 396 static ALCboolean alsa_start_context(ALCdevice *device, ALCcontext *context)
 397 {
 398     alsa_data *data = (alsa_data*)device->ExtraData;
 399     snd_pcm_uframes_t bufferSizeInFrames;
 400     snd_pcm_sw_params_t *sp = NULL;
 401     snd_pcm_hw_params_t *p = NULL;
 402     snd_pcm_access_t access;
 403     unsigned int periods;
 404     unsigned int rate;
 405     const char *str;
 406     int allowmmap;
 407     char *err;
 408     int i;
 409     (void)context;
 410
 411
 412     switch(aluBytesFromFormat(device->Format))
 413     {
 414         case 1:
 415             data->format = SND_PCM_FORMAT_U8;
 416             break;
 417         case 2:
 418             data->format = SND_PCM_FORMAT_S16;
 419             break;
 420         default:
 421             data->format = SND_PCM_FORMAT_UNKNOWN;
 422             AL_PRINT("Unknown format?! %x\n", device->Format);
 423     }
 424
 425     periods = GetConfigValueInt("alsa", "periods", 0);
 426     bufferSizeInFrames = device->BufferSize;
 427     rate = device->Frequency;
 428
 429     str = GetConfigValue("alsa", "mmap", "true");
 430     allowmmap = (strcasecmp(str, "true") == 0 ||
 431                  strcasecmp(str, "yes") == 0 ||
 432                  strcasecmp(str, "on") == 0 ||
 433                  atoi(str) != 0);
 434
 435     err = NULL;
 436     psnd_pcm_hw_params_malloc(&p);
 437
 438     if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
 439         err = "any";
 440     /* set interleaved access */
 441     if(err == NULL && (!allowmmap || (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0))
 442     {
 443         if((i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
 444             err = "set access";
 445     }
 446     /* set format (implicitly sets sample bits) */
 447     if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
 448         err = "set format";
 449     /* set channels (implicitly sets frame bits) */
 450     if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(device->Format))) < 0)
 451         err = "set channels";
 452     /* set periods (implicitly constrains period/buffer parameters) */
 453     if(err == NULL && periods && (i=psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL)) < 0)
 454         err = "set periods near";
 455     /* set rate (implicitly constrains period/buffer parameters) */
 456     if(err == NULL && (i=psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &rate, NULL)) < 0)
 457         err = "set rate near";
 458     /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 459     if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
 460         err = "set buffer size near";
 461     /* install and prepare hardware configuration */
 462     if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 463         err = "set params";
 464     if(err == NULL && (i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
 465         err = "get access";
 466     if(err == NULL && (i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
 467         err = "get period size";
 468     if(err != NULL)
 469     {
 470         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 471         psnd_pcm_hw_params_free(p);
 472         return ALC_FALSE;
 473     }
 474
 475     psnd_pcm_hw_params_free(p);
 476
 477     err = NULL;
 478     psnd_pcm_sw_params_malloc(&sp);
 479
 480     if((i=psnd_pcm_sw_params_current(data->pcmHandle, sp)) != 0)
 481         err = "sw current";
 482     if(err == NULL && (i=psnd_pcm_sw_params_set_avail_min(data->pcmHandle, sp, bufferSizeInFrames)) != 0)
 483         err = "sw set avail min";
 484     if(err == NULL && (i=psnd_pcm_sw_params(data->pcmHandle, sp)) != 0)
 485         err = "sw set params";
 486     if(err != NULL)
 487     {
 488         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 489         psnd_pcm_sw_params_free(sp);
 490         return ALC_FALSE;
 491     }
 492
 493     psnd_pcm_sw_params_free(sp);
 494
 495     data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
 496     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 497     {
 498         data->buffer = malloc(data->size);
 499         if(!data->buffer)
 500         {
 501             AL_PRINT("buffer malloc failed\n");
 502             return ALC_FALSE;
 503         }
 504     }
 505     else
 506     {
 507         i = psnd_pcm_prepare(data->pcmHandle);
 508         if(i < 0)
 509         {
 510             AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 511             free(data->buffer);
 512             data->buffer = NULL;
 513             return ALC_FALSE;
 514         }
 515     }
 516
 517     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 518         data->thread = StartThread(ALSANoMMapProc, device);
 519     else
 520         data->thread = StartThread(ALSAProc, device);
 521     if(data->thread == NULL)
 522     {
 523         AL_PRINT("Could not create playback thread\n");
 524         free(data->buffer);
 525         data->buffer = NULL;
 526         return ALC_FALSE;
 527     }
 528
 529     device->UpdateSize = bufferSizeInFrames;
 530     device->Frequency = rate;
 531
 532     return ALC_TRUE;
 533 }
 534
 535 static void alsa_stop_context(ALCdevice *device, ALCcontext *context)
 536 {
 537     alsa_data *data = (alsa_data*)device->ExtraData;
 538     (void)context;
 539
 540     if(!data->thread)
 541         return;
 542
 543     data->killNow = 1;
 544     StopThread(data->thread);
 545     data->thread = NULL;
 546
 547     free(data->buffer);
 548     data->buffer = NULL;
 549 }
 550
 551
 552 static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
 553 {
 554     snd_pcm_hw_params_t *p;
 555     snd_pcm_uframes_t bufferSizeInFrames;
 556     snd_pcm_access_t access;
 557     const char *str;
 558     alsa_data *data;
 559     char driver[64];
 560     int allowmmap;
 561     char *err;
 562     int i;
 563
 564     if(!alsa_handle)
 565         return ALC_FALSE;
 566
 567     strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
 568     driver[sizeof(driver)-1] = 0;
 569     if(deviceName)
 570     {
 571         size_t idx;
 572
 573         for(idx = 0;idx < MAX_ALL_DEVICES;idx++)
 574         {
 575             if(allCaptureDevNameMap[idx].name &&
 576                strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
 577             {
 578                 pDevice->szDeviceName = allCaptureDevNameMap[idx].name;
 579                 if(idx > 0)
 580                     sprintf(driver, "plughw:%d,%d", allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
 581                 goto open_alsa;
 582             }
 583         }
 584         return ALC_FALSE;
 585     }
 586     else
 587         pDevice->szDeviceName = allCaptureDevNameMap[0].name;
 588
 589 open_alsa:
 590     data = (alsa_data*)calloc(1, sizeof(alsa_data));
 591
 592     i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 593     if(i < 0)
 594     {
 595         Sleep(200);
 596         i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 597     }
 598     if(i >= 0)
 599     {
 600         i = psnd_pcm_nonblock(data->pcmHandle, 0);
 601         if(i < 0)
 602             psnd_pcm_close(data->pcmHandle);
 603     }
 604     if(i < 0)
 605     {
 606         free(data);
 607         AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
 608         return ALC_FALSE;
 609     }
 610
 611     switch(aluBytesFromFormat(format))
 612     {
 613         case 1:
 614             data->format = SND_PCM_FORMAT_U8;
 615             break;
 616         case 2:
 617             data->format = SND_PCM_FORMAT_S16;
 618             break;
 619         default:
 620             data->format = SND_PCM_FORMAT_UNKNOWN;
 621             AL_PRINT("Unknown format?! %x\n", format);
 622     }
 623
 624     str = GetConfigValue("alsa", "mmap", "true");
 625     allowmmap = (strcasecmp(str, "true") == 0 ||
 626                  strcasecmp(str, "yes") == 0 ||
 627                  strcasecmp(str, "on") == 0 ||
 628                  atoi(str) != 0);
 629
 630     err = NULL;
 631     bufferSizeInFrames = SampleSize;
 632     psnd_pcm_hw_params_malloc(&p);
 633
 634     if(!allowmmap)
 635         err = "no mmap";
 636     if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
 637         err = "any";
 638     /* set interleaved access */
 639     if(err == NULL && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0)
 640     {
 641         err = "set access";
 642         allowmmap = 0;
 643     }
 644     /* set format (implicitly sets sample bits) */
 645     if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
 646         err = "set format";
 647     /* set channels (implicitly sets frame bits) */
 648     if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
 649         err = "set channels";
 650     /* set rate (implicitly constrains period/buffer parameters) */
 651     if(err == NULL && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0)) < 0)
 652         err = "set rate near";
 653     /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 654     if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_min(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
 655     {
 656         err = "set buffer size min";
 657         allowmmap = 0;
 658     }
 659     /* install and prepare hardware configuration */
 660     if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 661         err = "set params";
 662     if(!allowmmap)
 663     {
 664         err = NULL;
 665         if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
 666             err = "any";
 667         /* set interleaved access */
 668         if(err == NULL && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
 669             err = "set access";
 670         /* set format (implicitly sets sample bits) */
 671         if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
 672             err = "set format";
 673         /* set channels (implicitly sets frame bits) */
 674         if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
 675             err = "set channels";
 676         /* set rate (implicitly constrains period/buffer parameters) */
 677         if(err == NULL && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0)) < 0)
 678             err = "set rate near";
 679         /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
 680         if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
 681             err = "set buffer size near";
 682         /* install and prepare hardware configuration */
 683         if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
 684             err = "set params";
 685     }
 686     if(err != NULL)
 687     {
 688         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
 689         psnd_pcm_hw_params_free(p);
 690         psnd_pcm_close(data->pcmHandle);
 691         free(data);
 692         return ALC_FALSE;
 693     }
 694
 695     if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
 696     {
 697         AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
 698         psnd_pcm_hw_params_free(p);
 699         psnd_pcm_close(data->pcmHandle);
 700         free(data);
 701         return ALC_FALSE;
 702     }
 703     if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
 704     {
 705         AL_PRINT("get size failed: %s\n", psnd_strerror(i));
 706         psnd_pcm_hw_params_free(p);
 707         psnd_pcm_close(data->pcmHandle);
 708         free(data);
 709         return ALC_FALSE;
 710     }
 711
 712     psnd_pcm_hw_params_free(p);
 713
 714     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 715     {
 716         ALuint frameSize = aluChannelsFromFormat(pDevice->Format);
 717         frameSize *= aluBytesFromFormat(pDevice->Format);
 718
 719         data->ring = CreateRingBuffer(frameSize, SampleSize);
 720         if(!data->ring)
 721         {
 722             AL_PRINT("ring buffer create failed\n");
 723             psnd_pcm_close(data->pcmHandle);
 724             free(data);
 725             return ALC_FALSE;
 726         }
 727
 728         data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
 729         data->buffer = malloc(data->size);
 730         if(!data->buffer)
 731         {
 732             AL_PRINT("buffer malloc failed\n");
 733             psnd_pcm_close(data->pcmHandle);
 734             DestroyRingBuffer(data->ring);
 735             free(data);
 736             return ALC_FALSE;
 737         }
 738
 739         pDevice->ExtraData = data;
 740         data->thread = StartThread(ALSANoMMapCaptureProc, pDevice);
 741         if(data->thread == NULL)
 742         {
 743             AL_PRINT("Could not create capture thread\n");
 744             pDevice->ExtraData = NULL;
 745             psnd_pcm_close(data->pcmHandle);
 746             DestroyRingBuffer(data->ring);
 747             free(data->buffer);
 748             free(data);
 749             return ALC_FALSE;
 750         }
 751     }
 752     else
 753     {
 754         i = psnd_pcm_prepare(data->pcmHandle);
 755         if(i < 0)
 756         {
 757             AL_PRINT("prepare error: %s\n", psnd_strerror(i));
 758             psnd_pcm_close(data->pcmHandle);
 759             free(data);
 760             return ALC_FALSE;
 761         }
 762         pDevice->ExtraData = data;
 763     }
 764
 765     return ALC_TRUE;
 766 }
 767
 768 static void alsa_close_capture(ALCdevice *pDevice)
 769 {
 770     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 771
 772     if(data->thread)
 773     {
 774         data->killNow = 1;
 775         StopThread(data->thread);
 776         DestroyRingBuffer(data->ring);
 777     }
 778     psnd_pcm_close(data->pcmHandle);
 779
 780     free(data);
 781     pDevice->ExtraData = NULL;
 782 }
 783
 784 static void alsa_start_capture(ALCdevice *pDevice)
 785 {
 786     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 787     data->doCapture = 1;
 788     if(!data->thread)
 789     {
 790         psnd_pcm_prepare(data->pcmHandle);
 791         psnd_pcm_start(data->pcmHandle);
 792     }
 793 }
 794
 795 static void alsa_stop_capture(ALCdevice *pDevice)
 796 {
 797     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 798     data->doCapture = 0;
 799     if(!data->thread)
 800         psnd_pcm_drain(data->pcmHandle);
 801 }
 802
 803 static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 804 {
 805     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 806     const snd_pcm_channel_area_t *areas = NULL;
 807     snd_pcm_sframes_t frames, commitres;
 808     snd_pcm_uframes_t size, offset;
 809     snd_pcm_state_t state;
 810     int err;
 811
 812     if(data->thread)
 813     {
 814         if(lSamples <= (ALCuint)RingBufferSize(data->ring))
 815             ReadRingBuffer(data->ring, pBuffer, lSamples);
 816         else
 817             SetALCError(ALC_INVALID_VALUE);
 818         return;
 819     }
 820
 821     state = psnd_pcm_state(data->pcmHandle);
 822     if(state == SND_PCM_STATE_XRUN)
 823     {
 824         err = xrun_recovery(data->pcmHandle, -EPIPE);
 825         if(err < 0)
 826         {
 827             AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
 828             return;
 829         }
 830     }
 831
 832     frames = psnd_pcm_avail_update(data->pcmHandle);
 833     if(frames < 0)
 834     {
 835         err = xrun_recovery(data->pcmHandle, frames);
 836         if (err < 0)
 837             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 838         else
 839             frames = psnd_pcm_avail_update(data->pcmHandle);
 840     }
 841     if (frames < (snd_pcm_sframes_t)lSamples)
 842     {
 843         SetALCError(ALC_INVALID_VALUE);
 844         return;
 845     }
 846
 847     // it is possible that contiguous areas are smaller, thus we use a loop
 848     while (lSamples > 0)
 849     {
 850         char *Pointer;
 851         int Count;
 852
 853         size = lSamples;
 854         err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &size);
 855         if (err < 0)
 856         {
 857             err = xrun_recovery(data->pcmHandle, err);
 858             if (err < 0)
 859             {
 860                 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
 861                 break;
 862             }
 863             continue;
 864         }
 865
 866         Pointer = (char*)areas->addr + (offset * areas->step / 8);
 867         Count = psnd_pcm_frames_to_bytes(data->pcmHandle, size);
 868
 869         memcpy(pBuffer, Pointer, Count);
 870         pBuffer = (char*)pBuffer + Count;
 871
 872         commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, size);
 873         if (commitres < 0 || (commitres-size) != 0)
 874         {
 875            AL_PRINT("mmap commit error: %s\n",
 876                     psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
 877            break;
 878         }
 879
 880         lSamples -= size;
 881     }
 882 }
 883
 884 static ALCuint alsa_available_samples(ALCdevice *pDevice)
 885 {
 886     alsa_data *data = (alsa_data*)pDevice->ExtraData;
 887     snd_pcm_sframes_t frames;
 888     snd_pcm_state_t state;
 889     int err;
 890
 891     if(data->thread)
 892         return RingBufferSize(data->ring);
 893
 894     state = psnd_pcm_state(data->pcmHandle);
 895     if(state == SND_PCM_STATE_XRUN)
 896     {
 897         err = xrun_recovery(data->pcmHandle, -EPIPE);
 898         if(err >= 0)
 899         {
 900             if(data->doCapture)
 901                 err = psnd_pcm_start(data->pcmHandle);
 902         }
 903         if (err < 0)
 904         {
 905             AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
 906             return 0;
 907         }
 908     }
 909
 910     frames = psnd_pcm_avail_update(data->pcmHandle);
 911     if(frames < 0)
 912     {
 913         err = xrun_recovery(data->pcmHandle, frames);
 914         if (err < 0)
 915             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
 916         else
 917             frames = psnd_pcm_avail_update(data->pcmHandle);
 918     }
 919     return max(frames, 0);
 920 }
 921
 922
 923 BackendFuncs alsa_funcs = {
 924     alsa_open_playback,
 925     alsa_close_playback,
 926     alsa_start_context,
 927     alsa_stop_context,
 928     alsa_open_capture,
 929     alsa_close_capture,
 930     alsa_start_capture,
 931     alsa_stop_capture,
 932     alsa_capture_samples,
 933     alsa_available_samples
 934 };
 935
 936 void alc_alsa_init(BackendFuncs *func_list)
 937 {
 938     snd_ctl_t *handle;
 939     int card, err, dev, idx = 1;
 940     snd_ctl_card_info_t *info;
 941     snd_pcm_info_t *pcminfo;
 942     snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
 943     char name[128];
 944     char *str;
 945
 946     *func_list = alsa_funcs;
 947
 948 #ifdef HAVE_DLFCN_H
 949     alsa_handle = dlopen("libasound.so.2", RTLD_NOW);
 950     if(!alsa_handle)
 951         return;
 952     dlerror();
 953
 954 #define LOAD_FUNC(f) do { \
 955     p##f = (typeof(f)*)dlsym(alsa_handle, #f); \
 956     if((str=dlerror()) != NULL) \
 957     { \
 958         dlclose(alsa_handle); \
 959         alsa_handle = NULL; \
 960         AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
 961         return; \
 962     } \
 963 } while(0)
 964 #else
 965     str = NULL;
 966     alsa_handle = (void*)0xDEADBEEF;
 967 #define LOAD_FUNC(f) p##f = f
 968 #endif
 969
 970 LOAD_FUNC(snd_strerror);
 971 LOAD_FUNC(snd_pcm_open);
 972 LOAD_FUNC(snd_pcm_close);
 973 LOAD_FUNC(snd_pcm_nonblock);
 974 LOAD_FUNC(snd_pcm_frames_to_bytes);
 975 LOAD_FUNC(snd_pcm_hw_params_malloc);
 976 LOAD_FUNC(snd_pcm_hw_params_free);
 977 LOAD_FUNC(snd_pcm_hw_params_any);
 978 LOAD_FUNC(snd_pcm_hw_params_set_access);
 979 LOAD_FUNC(snd_pcm_hw_params_set_format);
 980 LOAD_FUNC(snd_pcm_hw_params_set_channels);
 981 LOAD_FUNC(snd_pcm_hw_params_set_periods_near);
 982 LOAD_FUNC(snd_pcm_hw_params_set_rate_near);
 983 LOAD_FUNC(snd_pcm_hw_params_set_rate);
 984 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near);
 985 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min);
 986 LOAD_FUNC(snd_pcm_hw_params_get_buffer_size);
 987 LOAD_FUNC(snd_pcm_hw_params_get_period_size);
 988 LOAD_FUNC(snd_pcm_hw_params_get_access);
 989 LOAD_FUNC(snd_pcm_hw_params);
 990 LOAD_FUNC(snd_pcm_sw_params_malloc);
 991 LOAD_FUNC(snd_pcm_sw_params_current);
 992 LOAD_FUNC(snd_pcm_sw_params_set_avail_min);
 993 LOAD_FUNC(snd_pcm_sw_params);
 994 LOAD_FUNC(snd_pcm_sw_params_free);
 995 LOAD_FUNC(snd_pcm_prepare);
 996 LOAD_FUNC(snd_pcm_start);
 997 LOAD_FUNC(snd_pcm_resume);
 998 LOAD_FUNC(snd_pcm_wait);
 999 LOAD_FUNC(snd_pcm_state);
1000 LOAD_FUNC(snd_pcm_avail_update);
1001 LOAD_FUNC(snd_pcm_areas_silence);
1002 LOAD_FUNC(snd_pcm_mmap_begin);
1003 LOAD_FUNC(snd_pcm_mmap_commit);
1004 LOAD_FUNC(snd_pcm_readi);
1005 LOAD_FUNC(snd_pcm_writei);
1006 LOAD_FUNC(snd_pcm_drain);
1007
1008 LOAD_FUNC(snd_pcm_info_malloc);
1009 LOAD_FUNC(snd_pcm_info_free);
1010 LOAD_FUNC(snd_pcm_info_set_device);
1011 LOAD_FUNC(snd_pcm_info_set_subdevice);
1012 LOAD_FUNC(snd_pcm_info_set_stream);
1013 LOAD_FUNC(snd_pcm_info_get_name);
1014 LOAD_FUNC(snd_ctl_pcm_next_device);
1015 LOAD_FUNC(snd_ctl_pcm_info);
1016 LOAD_FUNC(snd_ctl_open);
1017 LOAD_FUNC(snd_ctl_close);
1018 LOAD_FUNC(snd_ctl_card_info_malloc);
1019 LOAD_FUNC(snd_ctl_card_info_free);
1020 LOAD_FUNC(snd_ctl_card_info);
1021 LOAD_FUNC(snd_ctl_card_info_get_name);
1022 LOAD_FUNC(snd_card_next);
1023
1024 #undef LOAD_FUNC
1025
1026     psnd_ctl_card_info_malloc(&info);
1027     psnd_pcm_info_malloc(&pcminfo);
1028
1029     card = -1;
1030     if(psnd_card_next(&card) < 0 || card < 0)
1031         AL_PRINT("no playback cards found...\n");
1032
1033     alsaDevice = AppendDeviceList("ALSA Software");
1034     allDevNameMap[0].name = AppendAllDeviceList("ALSA Software on default");
1035
1036     while (card >= 0) {
1037         sprintf(name, "hw:%d", card);
1038         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
1039             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
1040             goto next_card;
1041         }
1042         if ((err = psnd_ctl_card_info(handle, info)) < 0) {
1043             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
1044             psnd_ctl_close(handle);
1045             goto next_card;
1046         }
1047
1048         dev = -1;
1049         while (idx < MAX_ALL_DEVICES) {
1050             const char *cname, *dname;
1051
1052             if (psnd_ctl_pcm_next_device(handle, &dev)<0)
1053                 AL_PRINT("snd_ctl_pcm_next_device failed\n");
1054             if (dev < 0)
1055                 break;
1056
1057             psnd_pcm_info_set_device(pcminfo, dev);
1058             psnd_pcm_info_set_subdevice(pcminfo, 0);
1059             psnd_pcm_info_set_stream(pcminfo, stream);
1060             if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
1061                 if (err != -ENOENT)
1062                     AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
1063                 continue;
1064             }
1065
1066             cname = psnd_ctl_card_info_get_name(info);
1067             dname = psnd_pcm_info_get_name(pcminfo);
1068             snprintf(name, sizeof(name), "ALSA Software on %s [%s] (hw:%d,%d)",
1069                      cname, dname, card, dev);
1070             allDevNameMap[idx].name = AppendAllDeviceList(name);
1071             allDevNameMap[idx].card = card;
1072             allDevNameMap[idx].dev = dev;
1073             idx++;
1074         }
1075         psnd_ctl_close(handle);
1076 next_card:
1077         if(psnd_card_next(&card) < 0) {
1078             AL_PRINT("snd_card_next failed\n");
1079             break;
1080         }
1081     }
1082
1083
1084     stream = SND_PCM_STREAM_CAPTURE;
1085
1086     card = -1;
1087     if(psnd_card_next(&card) < 0 || card < 0) {
1088         AL_PRINT("no capture cards found...\n");
1089         psnd_pcm_info_free(pcminfo);
1090         psnd_ctl_card_info_free(info);
1091         return;
1092     }
1093
1094     allCaptureDevNameMap[0].name = AppendCaptureDeviceList("ALSA Capture on default");
1095     idx = 1;
1096
1097     while (card >= 0) {
1098         sprintf(name, "hw:%d", card);
1099         handle = NULL;
1100         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
1101             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
1102         }
1103         if (err >= 0 && (err = psnd_ctl_card_info(handle, info)) < 0) {
1104             AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
1105         }
1106         else if (err >= 0)
1107         {
1108             dev = -1;
1109             while (idx < MAX_ALL_DEVICES) {
1110                 const char *cname, *dname;
1111
1112                 if (psnd_ctl_pcm_next_device(handle, &dev)<0)
1113                     AL_PRINT("snd_ctl_pcm_next_device failed\n");
1114                 if (dev < 0)
1115                     break;
1116                 psnd_pcm_info_set_device(pcminfo, dev);
1117                 psnd_pcm_info_set_subdevice(pcminfo, 0);
1118                 psnd_pcm_info_set_stream(pcminfo, stream);
1119                 if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
1120                     if (err != -ENOENT)
1121                         AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
1122                     continue;
1123                 }
1124
1125                 cname = psnd_ctl_card_info_get_name(info);
1126                 dname = psnd_pcm_info_get_name(pcminfo);
1127                 snprintf(name, sizeof(name), "ALSA Capture on %s [%s] (hw:%d,%d)",
1128                          cname, dname, card, dev);
1129                 allCaptureDevNameMap[idx].name = AppendCaptureDeviceList(name);
1130                 allCaptureDevNameMap[idx].card = card;
1131                 allCaptureDevNameMap[idx].dev = dev;
1132                 idx++;
1133             }
1134         }
1135         if(handle) psnd_ctl_close(handle);
1136         if(psnd_card_next(&card) < 0) {
1137             AL_PRINT("snd_card_next failed\n");
1138             break;
1139         }
1140     }
1141     psnd_pcm_info_free(pcminfo);
1142     psnd_ctl_card_info_free(info);
1143 }