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