Alc/alsa.c

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