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