Alc/backends/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.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
  27 #include "alMain.h"
  28 #include "alu.h"
  29 #include "threads.h"
  30 #include "compat.h"
  31
  32 #include "backends/base.h"
  33
  34 #include <alsa/asoundlib.h>
  35
  36
  37 static const ALCchar alsaDevice[] = "ALSA Default";
  38
  39
  40 #ifdef HAVE_DYNLOAD
  41 #define ALSA_FUNCS(MAGIC)                                                     \
  42     MAGIC(snd_strerror);                                                      \
  43     MAGIC(snd_pcm_open);                                                      \
  44     MAGIC(snd_pcm_close);                                                     \
  45     MAGIC(snd_pcm_nonblock);                                                  \
  46     MAGIC(snd_pcm_frames_to_bytes);                                           \
  47     MAGIC(snd_pcm_bytes_to_frames);                                           \
  48     MAGIC(snd_pcm_hw_params_malloc);                                          \
  49     MAGIC(snd_pcm_hw_params_free);                                            \
  50     MAGIC(snd_pcm_hw_params_any);                                             \
  51     MAGIC(snd_pcm_hw_params_current);                                         \
  52     MAGIC(snd_pcm_hw_params_set_access);                                      \
  53     MAGIC(snd_pcm_hw_params_set_format);                                      \
  54     MAGIC(snd_pcm_hw_params_set_channels);                                    \
  55     MAGIC(snd_pcm_hw_params_set_periods_near);                                \
  56     MAGIC(snd_pcm_hw_params_set_rate_near);                                   \
  57     MAGIC(snd_pcm_hw_params_set_rate);                                        \
  58     MAGIC(snd_pcm_hw_params_set_rate_resample);                               \
  59     MAGIC(snd_pcm_hw_params_set_buffer_time_near);                            \
  60     MAGIC(snd_pcm_hw_params_set_period_time_near);                            \
  61     MAGIC(snd_pcm_hw_params_set_buffer_size_near);                            \
  62     MAGIC(snd_pcm_hw_params_set_period_size_near);                            \
  63     MAGIC(snd_pcm_hw_params_set_buffer_size_min);                             \
  64     MAGIC(snd_pcm_hw_params_get_buffer_time_min);                             \
  65     MAGIC(snd_pcm_hw_params_get_buffer_time_max);                             \
  66     MAGIC(snd_pcm_hw_params_get_period_time_min);                             \
  67     MAGIC(snd_pcm_hw_params_get_period_time_max);                             \
  68     MAGIC(snd_pcm_hw_params_get_buffer_size);                                 \
  69     MAGIC(snd_pcm_hw_params_get_period_size);                                 \
  70     MAGIC(snd_pcm_hw_params_get_access);                                      \
  71     MAGIC(snd_pcm_hw_params_get_periods);                                     \
  72     MAGIC(snd_pcm_hw_params_test_format);                                     \
  73     MAGIC(snd_pcm_hw_params_test_channels);                                   \
  74     MAGIC(snd_pcm_hw_params);                                                 \
  75     MAGIC(snd_pcm_sw_params_malloc);                                          \
  76     MAGIC(snd_pcm_sw_params_current);                                         \
  77     MAGIC(snd_pcm_sw_params_set_avail_min);                                   \
  78     MAGIC(snd_pcm_sw_params_set_stop_threshold);                              \
  79     MAGIC(snd_pcm_sw_params);                                                 \
  80     MAGIC(snd_pcm_sw_params_free);                                            \
  81     MAGIC(snd_pcm_prepare);                                                   \
  82     MAGIC(snd_pcm_start);                                                     \
  83     MAGIC(snd_pcm_resume);                                                    \
  84     MAGIC(snd_pcm_reset);                                                     \
  85     MAGIC(snd_pcm_wait);                                                      \
  86     MAGIC(snd_pcm_delay);                                                     \
  87     MAGIC(snd_pcm_state);                                                     \
  88     MAGIC(snd_pcm_avail_update);                                              \
  89     MAGIC(snd_pcm_areas_silence);                                             \
  90     MAGIC(snd_pcm_mmap_begin);                                                \
  91     MAGIC(snd_pcm_mmap_commit);                                               \
  92     MAGIC(snd_pcm_readi);                                                     \
  93     MAGIC(snd_pcm_writei);                                                    \
  94     MAGIC(snd_pcm_drain);                                                     \
  95     MAGIC(snd_pcm_drop);                                                      \
  96     MAGIC(snd_pcm_recover);                                                   \
  97     MAGIC(snd_pcm_info_malloc);                                               \
  98     MAGIC(snd_pcm_info_free);                                                 \
  99     MAGIC(snd_pcm_info_set_device);                                           \
 100     MAGIC(snd_pcm_info_set_subdevice);                                        \
 101     MAGIC(snd_pcm_info_set_stream);                                           \
 102     MAGIC(snd_pcm_info_get_name);                                             \
 103     MAGIC(snd_ctl_pcm_next_device);                                           \
 104     MAGIC(snd_ctl_pcm_info);                                                  \
 105     MAGIC(snd_ctl_open);                                                      \
 106     MAGIC(snd_ctl_close);                                                     \
 107     MAGIC(snd_ctl_card_info_malloc);                                          \
 108     MAGIC(snd_ctl_card_info_free);                                            \
 109     MAGIC(snd_ctl_card_info);                                                 \
 110     MAGIC(snd_ctl_card_info_get_name);                                        \
 111     MAGIC(snd_ctl_card_info_get_id);                                          \
 112     MAGIC(snd_card_next);                                                     \
 113     MAGIC(snd_config_update_free_global)
 114
 115 static void *alsa_handle;
 116 #define MAKE_FUNC(f) static __typeof(f) * p##f
 117 ALSA_FUNCS(MAKE_FUNC);
 118 #undef MAKE_FUNC
 119
 120 #define snd_strerror psnd_strerror
 121 #define snd_pcm_open psnd_pcm_open
 122 #define snd_pcm_close psnd_pcm_close
 123 #define snd_pcm_nonblock psnd_pcm_nonblock
 124 #define snd_pcm_frames_to_bytes psnd_pcm_frames_to_bytes
 125 #define snd_pcm_bytes_to_frames psnd_pcm_bytes_to_frames
 126 #define snd_pcm_hw_params_malloc psnd_pcm_hw_params_malloc
 127 #define snd_pcm_hw_params_free psnd_pcm_hw_params_free
 128 #define snd_pcm_hw_params_any psnd_pcm_hw_params_any
 129 #define snd_pcm_hw_params_current psnd_pcm_hw_params_current
 130 #define snd_pcm_hw_params_set_access psnd_pcm_hw_params_set_access
 131 #define snd_pcm_hw_params_set_format psnd_pcm_hw_params_set_format
 132 #define snd_pcm_hw_params_set_channels psnd_pcm_hw_params_set_channels
 133 #define snd_pcm_hw_params_set_periods_near psnd_pcm_hw_params_set_periods_near
 134 #define snd_pcm_hw_params_set_rate_near psnd_pcm_hw_params_set_rate_near
 135 #define snd_pcm_hw_params_set_rate psnd_pcm_hw_params_set_rate
 136 #define snd_pcm_hw_params_set_rate_resample psnd_pcm_hw_params_set_rate_resample
 137 #define snd_pcm_hw_params_set_buffer_time_near psnd_pcm_hw_params_set_buffer_time_near
 138 #define snd_pcm_hw_params_set_period_time_near psnd_pcm_hw_params_set_period_time_near
 139 #define snd_pcm_hw_params_set_buffer_size_near psnd_pcm_hw_params_set_buffer_size_near
 140 #define snd_pcm_hw_params_set_period_size_near psnd_pcm_hw_params_set_period_size_near
 141 #define snd_pcm_hw_params_set_buffer_size_min psnd_pcm_hw_params_set_buffer_size_min
 142 #define snd_pcm_hw_params_get_buffer_time_min psnd_pcm_hw_params_get_buffer_time_min
 143 #define snd_pcm_hw_params_get_buffer_time_max psnd_pcm_hw_params_get_buffer_time_max
 144 #define snd_pcm_hw_params_get_period_time_min psnd_pcm_hw_params_get_period_time_min
 145 #define snd_pcm_hw_params_get_period_time_max psnd_pcm_hw_params_get_period_time_max
 146 #define snd_pcm_hw_params_get_buffer_size psnd_pcm_hw_params_get_buffer_size
 147 #define snd_pcm_hw_params_get_period_size psnd_pcm_hw_params_get_period_size
 148 #define snd_pcm_hw_params_get_access psnd_pcm_hw_params_get_access
 149 #define snd_pcm_hw_params_get_periods psnd_pcm_hw_params_get_periods
 150 #define snd_pcm_hw_params_test_format psnd_pcm_hw_params_test_format
 151 #define snd_pcm_hw_params_test_channels psnd_pcm_hw_params_test_channels
 152 #define snd_pcm_hw_params psnd_pcm_hw_params
 153 #define snd_pcm_sw_params_malloc psnd_pcm_sw_params_malloc
 154 #define snd_pcm_sw_params_current psnd_pcm_sw_params_current
 155 #define snd_pcm_sw_params_set_avail_min psnd_pcm_sw_params_set_avail_min
 156 #define snd_pcm_sw_params_set_stop_threshold psnd_pcm_sw_params_set_stop_threshold
 157 #define snd_pcm_sw_params psnd_pcm_sw_params
 158 #define snd_pcm_sw_params_free psnd_pcm_sw_params_free
 159 #define snd_pcm_prepare psnd_pcm_prepare
 160 #define snd_pcm_start psnd_pcm_start
 161 #define snd_pcm_resume psnd_pcm_resume
 162 #define snd_pcm_reset psnd_pcm_reset
 163 #define snd_pcm_wait psnd_pcm_wait
 164 #define snd_pcm_delay psnd_pcm_delay
 165 #define snd_pcm_state psnd_pcm_state
 166 #define snd_pcm_avail_update psnd_pcm_avail_update
 167 #define snd_pcm_areas_silence psnd_pcm_areas_silence
 168 #define snd_pcm_mmap_begin psnd_pcm_mmap_begin
 169 #define snd_pcm_mmap_commit psnd_pcm_mmap_commit
 170 #define snd_pcm_readi psnd_pcm_readi
 171 #define snd_pcm_writei psnd_pcm_writei
 172 #define snd_pcm_drain psnd_pcm_drain
 173 #define snd_pcm_drop psnd_pcm_drop
 174 #define snd_pcm_recover psnd_pcm_recover
 175 #define snd_pcm_info_malloc psnd_pcm_info_malloc
 176 #define snd_pcm_info_free psnd_pcm_info_free
 177 #define snd_pcm_info_set_device psnd_pcm_info_set_device
 178 #define snd_pcm_info_set_subdevice psnd_pcm_info_set_subdevice
 179 #define snd_pcm_info_set_stream psnd_pcm_info_set_stream
 180 #define snd_pcm_info_get_name psnd_pcm_info_get_name
 181 #define snd_ctl_pcm_next_device psnd_ctl_pcm_next_device
 182 #define snd_ctl_pcm_info psnd_ctl_pcm_info
 183 #define snd_ctl_open psnd_ctl_open
 184 #define snd_ctl_close psnd_ctl_close
 185 #define snd_ctl_card_info_malloc psnd_ctl_card_info_malloc
 186 #define snd_ctl_card_info_free psnd_ctl_card_info_free
 187 #define snd_ctl_card_info psnd_ctl_card_info
 188 #define snd_ctl_card_info_get_name psnd_ctl_card_info_get_name
 189 #define snd_ctl_card_info_get_id psnd_ctl_card_info_get_id
 190 #define snd_card_next psnd_card_next
 191 #define snd_config_update_free_global psnd_config_update_free_global
 192 #endif
 193
 194
 195 static ALCboolean alsa_load(void)
 196 {
 197     ALCboolean error = ALC_FALSE;
 198
 199 #ifdef HAVE_DYNLOAD
 200     if(!alsa_handle)
 201     {
 202         alsa_handle = LoadLib("libasound.so.2");
 203         if(!alsa_handle)
 204             return ALC_FALSE;
 205
 206         error = ALC_FALSE;
 207 #define LOAD_FUNC(f) do {                                                     \
 208     p##f = GetSymbol(alsa_handle, #f);                                        \
 209     if(p##f == NULL) {                                                        \
 210         error = ALC_TRUE;                                                     \
 211     }                                                                         \
 212 } while(0)
 213         ALSA_FUNCS(LOAD_FUNC);
 214 #undef LOAD_FUNC
 215
 216         if(error)
 217         {
 218             CloseLib(alsa_handle);
 219             alsa_handle = NULL;
 220             return ALC_FALSE;
 221         }
 222     }
 223 #endif
 224
 225     return !error;
 226 }
 227
 228
 229 typedef struct {
 230     al_string name;
 231     al_string device_name;
 232 } DevMap;
 233 TYPEDEF_VECTOR(DevMap, vector_DevMap)
 234
 235 static vector_DevMap PlaybackDevices;
 236 static vector_DevMap CaptureDevices;
 237
 238 static void clear_devlist(vector_DevMap *devlist)
 239 {
 240 #define FREE_DEV(i) do {                                                      \
 241     AL_STRING_DEINIT((i)->name);                                              \
 242     AL_STRING_DEINIT((i)->device_name);                                       \
 243 } while(0)
 244     VECTOR_FOR_EACH(DevMap, *devlist, FREE_DEV);
 245     VECTOR_RESIZE(*devlist, 0);
 246 #undef FREE_DEV
 247 }
 248
 249
 250 static const char *prefix_name(snd_pcm_stream_t stream)
 251 {
 252     assert(stream == SND_PCM_STREAM_PLAYBACK || stream == SND_PCM_STREAM_CAPTURE);
 253     return (stream==SND_PCM_STREAM_PLAYBACK) ? "device-prefix" : "capture-prefix";
 254 }
 255
 256 static void probe_devices(snd_pcm_stream_t stream, vector_DevMap *DeviceList)
 257 {
 258     const char *main_prefix = "plughw:";
 259     snd_ctl_t *handle;
 260     snd_ctl_card_info_t *info;
 261     snd_pcm_info_t *pcminfo;
 262     int card, err, dev;
 263     DevMap entry;
 264
 265     clear_devlist(DeviceList);
 266
 267     snd_ctl_card_info_malloc(&info);
 268     snd_pcm_info_malloc(&pcminfo);
 269
 270     AL_STRING_INIT(entry.name);
 271     AL_STRING_INIT(entry.device_name);
 272     al_string_copy_cstr(&entry.name, alsaDevice);
 273     al_string_copy_cstr(&entry.device_name, GetConfigValue(NULL, "alsa", (stream==SND_PCM_STREAM_PLAYBACK) ?
 274                                                            "device" : "capture", "default"));
 275     VECTOR_PUSH_BACK(*DeviceList, entry);
 276
 277     card = -1;
 278     if((err=snd_card_next(&card)) < 0)
 279         ERR("Failed to find a card: %s\n", snd_strerror(err));
 280     ConfigValueStr(NULL, "alsa", prefix_name(stream), &main_prefix);
 281     while(card >= 0)
 282     {
 283         const char *card_prefix = main_prefix;
 284         const char *cardname, *cardid;
 285         char name[256];
 286
 287         snprintf(name, sizeof(name), "hw:%d", card);
 288         if((err = snd_ctl_open(&handle, name, 0)) < 0)
 289         {
 290             ERR("control open (hw:%d): %s\n", card, snd_strerror(err));
 291             goto next_card;
 292         }
 293         if((err = snd_ctl_card_info(handle, info)) < 0)
 294         {
 295             ERR("control hardware info (hw:%d): %s\n", card, snd_strerror(err));
 296             snd_ctl_close(handle);
 297             goto next_card;
 298         }
 299
 300         cardname = snd_ctl_card_info_get_name(info);
 301         cardid = snd_ctl_card_info_get_id(info);
 302
 303         snprintf(name, sizeof(name), "%s-%s", prefix_name(stream), cardid);
 304         ConfigValueStr(NULL, "alsa", name, &card_prefix);
 305
 306         dev = -1;
 307         while(1)
 308         {
 309             const char *device_prefix = card_prefix;
 310             const char *devname;
 311             char device[128];
 312
 313             if(snd_ctl_pcm_next_device(handle, &dev) < 0)
 314                 ERR("snd_ctl_pcm_next_device failed\n");
 315             if(dev < 0)
 316                 break;
 317
 318             snd_pcm_info_set_device(pcminfo, dev);
 319             snd_pcm_info_set_subdevice(pcminfo, 0);
 320             snd_pcm_info_set_stream(pcminfo, stream);
 321             if((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
 322                 if(err != -ENOENT)
 323                     ERR("control digital audio info (hw:%d): %s\n", card, snd_strerror(err));
 324                 continue;
 325             }
 326
 327             devname = snd_pcm_info_get_name(pcminfo);
 328
 329             snprintf(name, sizeof(name), "%s-%s-%d", prefix_name(stream), cardid, dev);
 330             ConfigValueStr(NULL, "alsa", name, &device_prefix);
 331
 332             snprintf(name, sizeof(name), "%s, %s (CARD=%s,DEV=%d)",
 333                         cardname, devname, cardid, dev);
 334             snprintf(device, sizeof(device), "%sCARD=%s,DEV=%d",
 335                         device_prefix, cardid, dev);
 336
 337             TRACE("Got device \"%s\", \"%s\"\n", name, device);
 338             AL_STRING_INIT(entry.name);
 339             AL_STRING_INIT(entry.device_name);
 340             al_string_copy_cstr(&entry.name, name);
 341             al_string_copy_cstr(&entry.device_name, device);
 342             VECTOR_PUSH_BACK(*DeviceList, entry);
 343         }
 344         snd_ctl_close(handle);
 345     next_card:
 346         if(snd_card_next(&card) < 0) {
 347             ERR("snd_card_next failed\n");
 348             break;
 349         }
 350     }
 351
 352     snd_pcm_info_free(pcminfo);
 353     snd_ctl_card_info_free(info);
 354 }
 355
 356
 357 static int verify_state(snd_pcm_t *handle)
 358 {
 359     snd_pcm_state_t state = snd_pcm_state(handle);
 360     int err;
 361
 362     switch(state)
 363     {
 364         case SND_PCM_STATE_OPEN:
 365         case SND_PCM_STATE_SETUP:
 366         case SND_PCM_STATE_PREPARED:
 367         case SND_PCM_STATE_RUNNING:
 368         case SND_PCM_STATE_DRAINING:
 369         case SND_PCM_STATE_PAUSED:
 370             /* All Okay */
 371             break;
 372
 373         case SND_PCM_STATE_XRUN:
 374             if((err=snd_pcm_recover(handle, -EPIPE, 1)) < 0)
 375                 return err;
 376             break;
 377         case SND_PCM_STATE_SUSPENDED:
 378             if((err=snd_pcm_recover(handle, -ESTRPIPE, 1)) < 0)
 379                 return err;
 380             break;
 381         case SND_PCM_STATE_DISCONNECTED:
 382             return -ENODEV;
 383     }
 384
 385     return state;
 386 }
 387
 388
 389 typedef struct ALCplaybackAlsa {
 390     DERIVE_FROM_TYPE(ALCbackend);
 391
 392     snd_pcm_t *pcmHandle;
 393
 394     ALvoid *buffer;
 395     ALsizei size;
 396
 397     volatile int killNow;
 398     althrd_t thread;
 399 } ALCplaybackAlsa;
 400
 401 static int ALCplaybackAlsa_mixerProc(void *ptr);
 402 static int ALCplaybackAlsa_mixerNoMMapProc(void *ptr);
 403
 404 static void ALCplaybackAlsa_Construct(ALCplaybackAlsa *self, ALCdevice *device);
 405 static DECLARE_FORWARD(ALCplaybackAlsa, ALCbackend, void, Destruct)
 406 static ALCenum ALCplaybackAlsa_open(ALCplaybackAlsa *self, const ALCchar *name);
 407 static void ALCplaybackAlsa_close(ALCplaybackAlsa *self);
 408 static ALCboolean ALCplaybackAlsa_reset(ALCplaybackAlsa *self);
 409 static ALCboolean ALCplaybackAlsa_start(ALCplaybackAlsa *self);
 410 static void ALCplaybackAlsa_stop(ALCplaybackAlsa *self);
 411 static DECLARE_FORWARD2(ALCplaybackAlsa, ALCbackend, ALCenum, captureSamples, void*, ALCuint)
 412 static DECLARE_FORWARD(ALCplaybackAlsa, ALCbackend, ALCuint, availableSamples)
 413 static ALint64 ALCplaybackAlsa_getLatency(ALCplaybackAlsa *self);
 414 static DECLARE_FORWARD(ALCplaybackAlsa, ALCbackend, void, lock)
 415 static DECLARE_FORWARD(ALCplaybackAlsa, ALCbackend, void, unlock)
 416 DECLARE_DEFAULT_ALLOCATORS(ALCplaybackAlsa)
 417
 418 DEFINE_ALCBACKEND_VTABLE(ALCplaybackAlsa);
 419
 420
 421 static void ALCplaybackAlsa_Construct(ALCplaybackAlsa *self, ALCdevice *device)
 422 {
 423     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
 424     SET_VTABLE2(ALCplaybackAlsa, ALCbackend, self);
 425 }
 426
 427
 428 static int ALCplaybackAlsa_mixerProc(void *ptr)
 429 {
 430     ALCplaybackAlsa *self = (ALCplaybackAlsa*)ptr;
 431     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 432     const snd_pcm_channel_area_t *areas = NULL;
 433     snd_pcm_uframes_t update_size, num_updates;
 434     snd_pcm_sframes_t avail, commitres;
 435     snd_pcm_uframes_t offset, frames;
 436     char *WritePtr;
 437     int err;
 438
 439     SetRTPriority();
 440     althrd_setname(althrd_current(), MIXER_THREAD_NAME);
 441
 442     update_size = device->UpdateSize;
 443     num_updates = device->NumUpdates;
 444     while(!self->killNow)
 445     {
 446         int state = verify_state(self->pcmHandle);
 447         if(state < 0)
 448         {
 449             ERR("Invalid state detected: %s\n", snd_strerror(state));
 450             ALCplaybackAlsa_lock(self);
 451             aluHandleDisconnect(device);
 452             ALCplaybackAlsa_unlock(self);
 453             break;
 454         }
 455
 456         avail = snd_pcm_avail_update(self->pcmHandle);
 457         if(avail < 0)
 458         {
 459             ERR("available update failed: %s\n", snd_strerror(avail));
 460             continue;
 461         }
 462
 463         if((snd_pcm_uframes_t)avail > update_size*(num_updates+1))
 464         {
 465             WARN("available samples exceeds the buffer size\n");
 466             snd_pcm_reset(self->pcmHandle);
 467             continue;
 468         }
 469
 470         // make sure there's frames to process
 471         if((snd_pcm_uframes_t)avail < update_size)
 472         {
 473             if(state != SND_PCM_STATE_RUNNING)
 474             {
 475                 err = snd_pcm_start(self->pcmHandle);
 476                 if(err < 0)
 477                 {
 478                     ERR("start failed: %s\n", snd_strerror(err));
 479                     continue;
 480                 }
 481             }
 482             if(snd_pcm_wait(self->pcmHandle, 1000) == 0)
 483                 ERR("Wait timeout... buffer size too low?\n");
 484             continue;
 485         }
 486         avail -= avail%update_size;
 487
 488         // it is possible that contiguous areas are smaller, thus we use a loop
 489         ALCplaybackAlsa_lock(self);
 490         while(avail > 0)
 491         {
 492             frames = avail;
 493
 494             err = snd_pcm_mmap_begin(self->pcmHandle, &areas, &offset, &frames);
 495             if(err < 0)
 496             {
 497                 ERR("mmap begin error: %s\n", snd_strerror(err));
 498                 break;
 499             }
 500
 501             WritePtr = (char*)areas->addr + (offset * areas->step / 8);
 502             aluMixData(device, WritePtr, frames);
 503
 504             commitres = snd_pcm_mmap_commit(self->pcmHandle, offset, frames);
 505             if(commitres < 0 || (commitres-frames) != 0)
 506             {
 507                 ERR("mmap commit error: %s\n",
 508                     snd_strerror(commitres >= 0 ? -EPIPE : commitres));
 509                 break;
 510             }
 511
 512             avail -= frames;
 513         }
 514         ALCplaybackAlsa_unlock(self);
 515     }
 516
 517     return 0;
 518 }
 519
 520 static int ALCplaybackAlsa_mixerNoMMapProc(void *ptr)
 521 {
 522     ALCplaybackAlsa *self = (ALCplaybackAlsa*)ptr;
 523     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 524     snd_pcm_uframes_t update_size, num_updates;
 525     snd_pcm_sframes_t avail;
 526     char *WritePtr;
 527     int err;
 528
 529     SetRTPriority();
 530     althrd_setname(althrd_current(), MIXER_THREAD_NAME);
 531
 532     update_size = device->UpdateSize;
 533     num_updates = device->NumUpdates;
 534     while(!self->killNow)
 535     {
 536         int state = verify_state(self->pcmHandle);
 537         if(state < 0)
 538         {
 539             ERR("Invalid state detected: %s\n", snd_strerror(state));
 540             ALCplaybackAlsa_lock(self);
 541             aluHandleDisconnect(device);
 542             ALCplaybackAlsa_unlock(self);
 543             break;
 544         }
 545
 546         avail = snd_pcm_avail_update(self->pcmHandle);
 547         if(avail < 0)
 548         {
 549             ERR("available update failed: %s\n", snd_strerror(avail));
 550             continue;
 551         }
 552
 553         if((snd_pcm_uframes_t)avail > update_size*num_updates)
 554         {
 555             WARN("available samples exceeds the buffer size\n");
 556             snd_pcm_reset(self->pcmHandle);
 557             continue;
 558         }
 559
 560         if((snd_pcm_uframes_t)avail < update_size)
 561         {
 562             if(state != SND_PCM_STATE_RUNNING)
 563             {
 564                 err = snd_pcm_start(self->pcmHandle);
 565                 if(err < 0)
 566                 {
 567                     ERR("start failed: %s\n", snd_strerror(err));
 568                     continue;
 569                 }
 570             }
 571             if(snd_pcm_wait(self->pcmHandle, 1000) == 0)
 572                 ERR("Wait timeout... buffer size too low?\n");
 573             continue;
 574         }
 575
 576         ALCplaybackAlsa_lock(self);
 577         WritePtr = self->buffer;
 578         avail = snd_pcm_bytes_to_frames(self->pcmHandle, self->size);
 579         aluMixData(device, WritePtr, avail);
 580
 581         while(avail > 0)
 582         {
 583             int ret = snd_pcm_writei(self->pcmHandle, WritePtr, avail);
 584             switch (ret)
 585             {
 586             case -EAGAIN:
 587                 continue;
 588 #if ESTRPIPE != EPIPE
 589             case -ESTRPIPE:
 590 #endif
 591             case -EPIPE:
 592             case -EINTR:
 593                 ret = snd_pcm_recover(self->pcmHandle, ret, 1);
 594                 if(ret < 0)
 595                     avail = 0;
 596                 break;
 597             default:
 598                 if (ret >= 0)
 599                 {
 600                     WritePtr += snd_pcm_frames_to_bytes(self->pcmHandle, ret);
 601                     avail -= ret;
 602                 }
 603                 break;
 604             }
 605             if (ret < 0)
 606             {
 607                 ret = snd_pcm_prepare(self->pcmHandle);
 608                 if(ret < 0)
 609                     break;
 610             }
 611         }
 612         ALCplaybackAlsa_unlock(self);
 613     }
 614
 615     return 0;
 616 }
 617
 618
 619 static ALCenum ALCplaybackAlsa_open(ALCplaybackAlsa *self, const ALCchar *name)
 620 {
 621     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 622     const char *driver = NULL;
 623     int err;
 624
 625     if(name)
 626     {
 627         const DevMap *iter;
 628
 629         if(VECTOR_SIZE(PlaybackDevices) == 0)
 630             probe_devices(SND_PCM_STREAM_PLAYBACK, &PlaybackDevices);
 631
 632 #define MATCH_NAME(i)  (al_string_cmp_cstr((i)->name, name) == 0)
 633         VECTOR_FIND_IF(iter, const DevMap, PlaybackDevices, MATCH_NAME);
 634 #undef MATCH_NAME
 635         if(iter == VECTOR_END(PlaybackDevices))
 636             return ALC_INVALID_VALUE;
 637         driver = al_string_get_cstr(iter->device_name);
 638     }
 639     else
 640     {
 641         name = alsaDevice;
 642         driver = GetConfigValue(NULL, "alsa", "device", "default");
 643     }
 644
 645     TRACE("Opening device \"%s\"\n", driver);
 646     err = snd_pcm_open(&self->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 647     if(err < 0)
 648     {
 649         ERR("Could not open playback device '%s': %s\n", driver, snd_strerror(err));
 650         return ALC_OUT_OF_MEMORY;
 651     }
 652
 653     /* Free alsa's global config tree. Otherwise valgrind reports a ton of leaks. */
 654     snd_config_update_free_global();
 655
 656     al_string_copy_cstr(&device->DeviceName, name);
 657
 658     return ALC_NO_ERROR;
 659 }
 660
 661 static void ALCplaybackAlsa_close(ALCplaybackAlsa *self)
 662 {
 663     snd_pcm_close(self->pcmHandle);
 664 }
 665
 666 static ALCboolean ALCplaybackAlsa_reset(ALCplaybackAlsa *self)
 667 {
 668     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 669     snd_pcm_uframes_t periodSizeInFrames;
 670     unsigned int periodLen, bufferLen;
 671     snd_pcm_sw_params_t *sp = NULL;
 672     snd_pcm_hw_params_t *hp = NULL;
 673     snd_pcm_format_t format = -1;
 674     snd_pcm_access_t access;
 675     unsigned int periods;
 676     unsigned int rate;
 677     const char *funcerr;
 678     int allowmmap;
 679     int dir;
 680     int err;
 681
 682     switch(device->FmtType)
 683     {
 684         case DevFmtByte:
 685             format = SND_PCM_FORMAT_S8;
 686             break;
 687         case DevFmtUByte:
 688             format = SND_PCM_FORMAT_U8;
 689             break;
 690         case DevFmtShort:
 691             format = SND_PCM_FORMAT_S16;
 692             break;
 693         case DevFmtUShort:
 694             format = SND_PCM_FORMAT_U16;
 695             break;
 696         case DevFmtInt:
 697             format = SND_PCM_FORMAT_S32;
 698             break;
 699         case DevFmtUInt:
 700             format = SND_PCM_FORMAT_U32;
 701             break;
 702         case DevFmtFloat:
 703             format = SND_PCM_FORMAT_FLOAT;
 704             break;
 705     }
 706
 707     allowmmap = GetConfigValueBool(al_string_get_cstr(device->DeviceName), "alsa", "mmap", 1);
 708     periods = device->NumUpdates;
 709     periodLen = (ALuint64)device->UpdateSize * 1000000 / device->Frequency;
 710     bufferLen = periodLen * periods;
 711     rate = device->Frequency;
 712
 713     snd_pcm_hw_params_malloc(&hp);
 714 #define CHECK(x) if((funcerr=#x),(err=(x)) < 0) goto error
 715     CHECK(snd_pcm_hw_params_any(self->pcmHandle, hp));
 716     /* set interleaved access */
 717     if(!allowmmap || snd_pcm_hw_params_set_access(self->pcmHandle, hp, SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0)
 718     {
 719         /* No mmap */
 720         CHECK(snd_pcm_hw_params_set_access(self->pcmHandle, hp, SND_PCM_ACCESS_RW_INTERLEAVED));
 721     }
 722     /* test and set format (implicitly sets sample bits) */
 723     if(snd_pcm_hw_params_test_format(self->pcmHandle, hp, format) < 0)
 724     {
 725         static const struct {
 726             snd_pcm_format_t format;
 727             enum DevFmtType fmttype;
 728         } formatlist[] = {
 729             { SND_PCM_FORMAT_FLOAT, DevFmtFloat  },
 730             { SND_PCM_FORMAT_S32,   DevFmtInt    },
 731             { SND_PCM_FORMAT_U32,   DevFmtUInt   },
 732             { SND_PCM_FORMAT_S16,   DevFmtShort  },
 733             { SND_PCM_FORMAT_U16,   DevFmtUShort },
 734             { SND_PCM_FORMAT_S8,    DevFmtByte   },
 735             { SND_PCM_FORMAT_U8,    DevFmtUByte  },
 736         };
 737         size_t k;
 738
 739         for(k = 0;k < COUNTOF(formatlist);k++)
 740         {
 741             format = formatlist[k].format;
 742             if(snd_pcm_hw_params_test_format(self->pcmHandle, hp, format) >= 0)
 743             {
 744                 device->FmtType = formatlist[k].fmttype;
 745                 break;
 746             }
 747         }
 748     }
 749     CHECK(snd_pcm_hw_params_set_format(self->pcmHandle, hp, format));
 750     /* test and set channels (implicitly sets frame bits) */
 751     if(snd_pcm_hw_params_test_channels(self->pcmHandle, hp, ChannelsFromDevFmt(device->FmtChans)) < 0)
 752     {
 753         static const enum DevFmtChannels channellist[] = {
 754             DevFmtStereo,
 755             DevFmtQuad,
 756             DevFmtX51,
 757             DevFmtX71,
 758             DevFmtMono,
 759         };
 760         size_t k;
 761
 762         for(k = 0;k < COUNTOF(channellist);k++)
 763         {
 764             if(snd_pcm_hw_params_test_channels(self->pcmHandle, hp, ChannelsFromDevFmt(channellist[k])) >= 0)
 765             {
 766                 device->FmtChans = channellist[k];
 767                 break;
 768             }
 769         }
 770     }
 771     CHECK(snd_pcm_hw_params_set_channels(self->pcmHandle, hp, ChannelsFromDevFmt(device->FmtChans)));
 772     /* set rate (implicitly constrains period/buffer parameters) */
 773     if(!GetConfigValueBool(al_string_get_cstr(device->DeviceName), "alsa", "allow-resampler", 0) ||
 774        !(device->Flags&DEVICE_FREQUENCY_REQUEST))
 775     {
 776         if(snd_pcm_hw_params_set_rate_resample(self->pcmHandle, hp, 0) < 0)
 777             ERR("Failed to disable ALSA resampler\n");
 778     }
 779     else if(snd_pcm_hw_params_set_rate_resample(self->pcmHandle, hp, 1) < 0)
 780         ERR("Failed to enable ALSA resampler\n");
 781     CHECK(snd_pcm_hw_params_set_rate_near(self->pcmHandle, hp, &rate, NULL));
 782     /* set buffer time (implicitly constrains period/buffer parameters) */
 783     if((err=snd_pcm_hw_params_set_buffer_time_near(self->pcmHandle, hp, &bufferLen, NULL)) < 0)
 784         ERR("snd_pcm_hw_params_set_buffer_time_near failed: %s\n", snd_strerror(err));
 785     /* set period time (implicitly sets buffer size/bytes/time and period size/bytes) */
 786     if((err=snd_pcm_hw_params_set_period_time_near(self->pcmHandle, hp, &periodLen, NULL)) < 0)
 787         ERR("snd_pcm_hw_params_set_period_time_near failed: %s\n", snd_strerror(err));
 788     /* install and prepare hardware configuration */
 789     CHECK(snd_pcm_hw_params(self->pcmHandle, hp));
 790     /* retrieve configuration info */
 791     CHECK(snd_pcm_hw_params_get_access(hp, &access));
 792     CHECK(snd_pcm_hw_params_get_period_size(hp, &periodSizeInFrames, NULL));
 793     CHECK(snd_pcm_hw_params_get_periods(hp, &periods, &dir));
 794     if(dir != 0)
 795         WARN("Inexact period count: %u (%d)\n", periods, dir);
 796
 797     snd_pcm_hw_params_free(hp);
 798     hp = NULL;
 799     snd_pcm_sw_params_malloc(&sp);
 800
 801     CHECK(snd_pcm_sw_params_current(self->pcmHandle, sp));
 802     CHECK(snd_pcm_sw_params_set_avail_min(self->pcmHandle, sp, periodSizeInFrames));
 803     CHECK(snd_pcm_sw_params_set_stop_threshold(self->pcmHandle, sp, periodSizeInFrames*periods));
 804     CHECK(snd_pcm_sw_params(self->pcmHandle, sp));
 805 #undef CHECK
 806     snd_pcm_sw_params_free(sp);
 807     sp = NULL;
 808
 809     device->NumUpdates = periods;
 810     device->UpdateSize = periodSizeInFrames;
 811     device->Frequency = rate;
 812
 813     SetDefaultChannelOrder(device);
 814
 815     return ALC_TRUE;
 816
 817 error:
 818     ERR("%s failed: %s\n", funcerr, snd_strerror(err));
 819     if(hp) snd_pcm_hw_params_free(hp);
 820     if(sp) snd_pcm_sw_params_free(sp);
 821     return ALC_FALSE;
 822 }
 823
 824 static ALCboolean ALCplaybackAlsa_start(ALCplaybackAlsa *self)
 825 {
 826     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 827     int (*thread_func)(void*) = NULL;
 828     snd_pcm_hw_params_t *hp = NULL;
 829     snd_pcm_access_t access;
 830     const char *funcerr;
 831     int err;
 832
 833     snd_pcm_hw_params_malloc(&hp);
 834 #define CHECK(x) if((funcerr=#x),(err=(x)) < 0) goto error
 835     CHECK(snd_pcm_hw_params_current(self->pcmHandle, hp));
 836     /* retrieve configuration info */
 837     CHECK(snd_pcm_hw_params_get_access(hp, &access));
 838 #undef CHECK
 839     snd_pcm_hw_params_free(hp);
 840     hp = NULL;
 841
 842     self->size = snd_pcm_frames_to_bytes(self->pcmHandle, device->UpdateSize);
 843     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
 844     {
 845         self->buffer = al_malloc(16, self->size);
 846         if(!self->buffer)
 847         {
 848             ERR("buffer malloc failed\n");
 849             return ALC_FALSE;
 850         }
 851         thread_func = ALCplaybackAlsa_mixerNoMMapProc;
 852     }
 853     else
 854     {
 855         err = snd_pcm_prepare(self->pcmHandle);
 856         if(err < 0)
 857         {
 858             ERR("snd_pcm_prepare(data->pcmHandle) failed: %s\n", snd_strerror(err));
 859             return ALC_FALSE;
 860         }
 861         thread_func = ALCplaybackAlsa_mixerProc;
 862     }
 863     self->killNow = 0;
 864     if(althrd_create(&self->thread, thread_func, self) != althrd_success)
 865     {
 866         ERR("Could not create playback thread\n");
 867         al_free(self->buffer);
 868         self->buffer = NULL;
 869         return ALC_FALSE;
 870     }
 871
 872     return ALC_TRUE;
 873
 874 error:
 875     ERR("%s failed: %s\n", funcerr, snd_strerror(err));
 876     if(hp) snd_pcm_hw_params_free(hp);
 877     return ALC_FALSE;
 878 }
 879
 880 static void ALCplaybackAlsa_stop(ALCplaybackAlsa *self)
 881 {
 882     int res;
 883
 884     if(self->killNow)
 885         return;
 886
 887     self->killNow = 1;
 888     althrd_join(self->thread, &res);
 889
 890     al_free(self->buffer);
 891     self->buffer = NULL;
 892 }
 893
 894 static ALint64 ALCplaybackAlsa_getLatency(ALCplaybackAlsa *self)
 895 {
 896     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 897     snd_pcm_sframes_t delay = 0;
 898     int err;
 899
 900     if((err=snd_pcm_delay(self->pcmHandle, &delay)) < 0)
 901     {
 902         ERR("Failed to get pcm delay: %s\n", snd_strerror(err));
 903         return 0;
 904     }
 905     return maxi64((ALint64)delay*1000000000/device->Frequency, 0);
 906 }
 907
 908
 909 typedef struct ALCcaptureAlsa {
 910     DERIVE_FROM_TYPE(ALCbackend);
 911
 912     snd_pcm_t *pcmHandle;
 913
 914     ALvoid *buffer;
 915     ALsizei size;
 916
 917     ALboolean doCapture;
 918     ll_ringbuffer_t *ring;
 919
 920     snd_pcm_sframes_t last_avail;
 921 } ALCcaptureAlsa;
 922
 923 static void ALCcaptureAlsa_Construct(ALCcaptureAlsa *self, ALCdevice *device);
 924 static DECLARE_FORWARD(ALCcaptureAlsa, ALCbackend, void, Destruct)
 925 static ALCenum ALCcaptureAlsa_open(ALCcaptureAlsa *self, const ALCchar *name);
 926 static void ALCcaptureAlsa_close(ALCcaptureAlsa *self);
 927 static DECLARE_FORWARD(ALCcaptureAlsa, ALCbackend, ALCboolean, reset)
 928 static ALCboolean ALCcaptureAlsa_start(ALCcaptureAlsa *self);
 929 static void ALCcaptureAlsa_stop(ALCcaptureAlsa *self);
 930 static ALCenum ALCcaptureAlsa_captureSamples(ALCcaptureAlsa *self, ALCvoid *buffer, ALCuint samples);
 931 static ALCuint ALCcaptureAlsa_availableSamples(ALCcaptureAlsa *self);
 932 static ALint64 ALCcaptureAlsa_getLatency(ALCcaptureAlsa *self);
 933 static DECLARE_FORWARD(ALCcaptureAlsa, ALCbackend, void, lock)
 934 static DECLARE_FORWARD(ALCcaptureAlsa, ALCbackend, void, unlock)
 935 DECLARE_DEFAULT_ALLOCATORS(ALCcaptureAlsa)
 936
 937 DEFINE_ALCBACKEND_VTABLE(ALCcaptureAlsa);
 938
 939
 940 static void ALCcaptureAlsa_Construct(ALCcaptureAlsa *self, ALCdevice *device)
 941 {
 942     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
 943     SET_VTABLE2(ALCcaptureAlsa, ALCbackend, self);
 944 }
 945
 946
 947 static ALCenum ALCcaptureAlsa_open(ALCcaptureAlsa *self, const ALCchar *name)
 948 {
 949     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 950     const char *driver = NULL;
 951     snd_pcm_hw_params_t *hp;
 952     snd_pcm_uframes_t bufferSizeInFrames;
 953     snd_pcm_uframes_t periodSizeInFrames;
 954     ALboolean needring = AL_FALSE;
 955     snd_pcm_format_t format = -1;
 956     const char *funcerr;
 957     int err;
 958
 959     if(name)
 960     {
 961         const DevMap *iter;
 962
 963         if(VECTOR_SIZE(CaptureDevices) == 0)
 964             probe_devices(SND_PCM_STREAM_CAPTURE, &CaptureDevices);
 965
 966 #define MATCH_NAME(i)  (al_string_cmp_cstr((i)->name, name) == 0)
 967         VECTOR_FIND_IF(iter, const DevMap, CaptureDevices, MATCH_NAME);
 968 #undef MATCH_NAME
 969         if(iter == VECTOR_END(CaptureDevices))
 970             return ALC_INVALID_VALUE;
 971         driver = al_string_get_cstr(iter->device_name);
 972     }
 973     else
 974     {
 975         name = alsaDevice;
 976         driver = GetConfigValue(NULL, "alsa", "capture", "default");
 977     }
 978
 979     TRACE("Opening device \"%s\"\n", driver);
 980     err = snd_pcm_open(&self->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
 981     if(err < 0)
 982     {
 983         ERR("Could not open capture device '%s': %s\n", driver, snd_strerror(err));
 984         return ALC_INVALID_VALUE;
 985     }
 986
 987     /* Free alsa's global config tree. Otherwise valgrind reports a ton of leaks. */
 988     snd_config_update_free_global();
 989
 990     switch(device->FmtType)
 991     {
 992         case DevFmtByte:
 993             format = SND_PCM_FORMAT_S8;
 994             break;
 995         case DevFmtUByte:
 996             format = SND_PCM_FORMAT_U8;
 997             break;
 998         case DevFmtShort:
 999             format = SND_PCM_FORMAT_S16;
1000             break;
1001         case DevFmtUShort:
1002             format = SND_PCM_FORMAT_U16;
1003             break;
1004         case DevFmtInt:
1005             format = SND_PCM_FORMAT_S32;
1006             break;
1007         case DevFmtUInt:
1008             format = SND_PCM_FORMAT_U32;
1009             break;
1010         case DevFmtFloat:
1011             format = SND_PCM_FORMAT_FLOAT;
1012             break;
1013     }
1014
1015     funcerr = NULL;
1016     bufferSizeInFrames = maxu(device->UpdateSize*device->NumUpdates,
1017                               100*device->Frequency/1000);
1018     periodSizeInFrames = minu(bufferSizeInFrames, 25*device->Frequency/1000);
1019
1020     snd_pcm_hw_params_malloc(&hp);
1021 #define CHECK(x) if((funcerr=#x),(err=(x)) < 0) goto error
1022     CHECK(snd_pcm_hw_params_any(self->pcmHandle, hp));
1023     /* set interleaved access */
1024     CHECK(snd_pcm_hw_params_set_access(self->pcmHandle, hp, SND_PCM_ACCESS_RW_INTERLEAVED));
1025     /* set format (implicitly sets sample bits) */
1026     CHECK(snd_pcm_hw_params_set_format(self->pcmHandle, hp, format));
1027     /* set channels (implicitly sets frame bits) */
1028     CHECK(snd_pcm_hw_params_set_channels(self->pcmHandle, hp, ChannelsFromDevFmt(device->FmtChans)));
1029     /* set rate (implicitly constrains period/buffer parameters) */
1030     CHECK(snd_pcm_hw_params_set_rate(self->pcmHandle, hp, device->Frequency, 0));
1031     /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
1032     if(snd_pcm_hw_params_set_buffer_size_min(self->pcmHandle, hp, &bufferSizeInFrames) < 0)
1033     {
1034         TRACE("Buffer too large, using intermediate ring buffer\n");
1035         needring = AL_TRUE;
1036         CHECK(snd_pcm_hw_params_set_buffer_size_near(self->pcmHandle, hp, &bufferSizeInFrames));
1037     }
1038     /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
1039     CHECK(snd_pcm_hw_params_set_period_size_near(self->pcmHandle, hp, &periodSizeInFrames, NULL));
1040     /* install and prepare hardware configuration */
1041     CHECK(snd_pcm_hw_params(self->pcmHandle, hp));
1042     /* retrieve configuration info */
1043     CHECK(snd_pcm_hw_params_get_period_size(hp, &periodSizeInFrames, NULL));
1044 #undef CHECK
1045     snd_pcm_hw_params_free(hp);
1046     hp = NULL;
1047
1048     if(needring)
1049     {
1050         self->ring = ll_ringbuffer_create(
1051             device->UpdateSize*device->NumUpdates + 1,
1052             FrameSizeFromDevFmt(device->FmtChans, device->FmtType)
1053         );
1054         if(!self->ring)
1055         {
1056             ERR("ring buffer create failed\n");
1057             goto error2;
1058         }
1059     }
1060
1061     al_string_copy_cstr(&device->DeviceName, name);
1062
1063     return ALC_NO_ERROR;
1064
1065 error:
1066     ERR("%s failed: %s\n", funcerr, snd_strerror(err));
1067     if(hp) snd_pcm_hw_params_free(hp);
1068
1069 error2:
1070     ll_ringbuffer_free(self->ring);
1071     self->ring = NULL;
1072     snd_pcm_close(self->pcmHandle);
1073
1074     return ALC_INVALID_VALUE;
1075 }
1076
1077 static void ALCcaptureAlsa_close(ALCcaptureAlsa *self)
1078 {
1079     snd_pcm_close(self->pcmHandle);
1080     ll_ringbuffer_free(self->ring);
1081
1082     al_free(self->buffer);
1083     self->buffer = NULL;
1084 }
1085
1086 static ALCboolean ALCcaptureAlsa_start(ALCcaptureAlsa *self)
1087 {
1088     int err = snd_pcm_start(self->pcmHandle);
1089     if(err < 0)
1090     {
1091         ERR("start failed: %s\n", snd_strerror(err));
1092         aluHandleDisconnect(STATIC_CAST(ALCbackend, self)->mDevice);
1093         return ALC_FALSE;
1094     }
1095
1096     self->doCapture = AL_TRUE;
1097     return ALC_TRUE;
1098 }
1099
1100 static void ALCcaptureAlsa_stop(ALCcaptureAlsa *self)
1101 {
1102     ALCuint avail;
1103     int err;
1104
1105     /* OpenAL requires access to unread audio after stopping, but ALSA's
1106      * snd_pcm_drain is unreliable and snd_pcm_drop drops it. Capture what's
1107      * available now so it'll be available later after the drop. */
1108     avail = ALCcaptureAlsa_availableSamples(self);
1109     if(!self->ring && avail > 0)
1110     {
1111         /* The ring buffer implicitly captures when checking availability.
1112          * Direct access needs to explicitly capture it into temp storage. */
1113         ALsizei size;
1114         void *ptr;
1115
1116         size = snd_pcm_frames_to_bytes(self->pcmHandle, avail);
1117         ptr = al_malloc(16, size);
1118         if(ptr)
1119         {
1120             ALCcaptureAlsa_captureSamples(self, ptr, avail);
1121             al_free(self->buffer);
1122             self->buffer = ptr;
1123             self->size = size;
1124         }
1125     }
1126     err = snd_pcm_drop(self->pcmHandle);
1127     if(err < 0)
1128         ERR("drop failed: %s\n", snd_strerror(err));
1129     self->doCapture = AL_FALSE;
1130 }
1131
1132 static ALCenum ALCcaptureAlsa_captureSamples(ALCcaptureAlsa *self, ALCvoid *buffer, ALCuint samples)
1133 {
1134     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
1135
1136     if(self->ring)
1137     {
1138         ll_ringbuffer_read(self->ring, buffer, samples);
1139         return ALC_NO_ERROR;
1140     }
1141
1142     self->last_avail -= samples;
1143     while(device->Connected && samples > 0)
1144     {
1145         snd_pcm_sframes_t amt = 0;
1146
1147         if(self->size > 0)
1148         {
1149             /* First get any data stored from the last stop */
1150             amt = snd_pcm_bytes_to_frames(self->pcmHandle, self->size);
1151             if((snd_pcm_uframes_t)amt > samples) amt = samples;
1152
1153             amt = snd_pcm_frames_to_bytes(self->pcmHandle, amt);
1154             memcpy(buffer, self->buffer, amt);
1155
1156             if(self->size > amt)
1157             {
1158                 memmove(self->buffer, self->buffer+amt, self->size - amt);
1159                 self->size -= amt;
1160             }
1161             else
1162             {
1163                 al_free(self->buffer);
1164                 self->buffer = NULL;
1165                 self->size = 0;
1166             }
1167             amt = snd_pcm_bytes_to_frames(self->pcmHandle, amt);
1168         }
1169         else if(self->doCapture)
1170             amt = snd_pcm_readi(self->pcmHandle, buffer, samples);
1171         if(amt < 0)
1172         {
1173             ERR("read error: %s\n", snd_strerror(amt));
1174
1175             if(amt == -EAGAIN)
1176                 continue;
1177             if((amt=snd_pcm_recover(self->pcmHandle, amt, 1)) >= 0)
1178             {
1179                 amt = snd_pcm_start(self->pcmHandle);
1180                 if(amt >= 0)
1181                     amt = snd_pcm_avail_update(self->pcmHandle);
1182             }
1183             if(amt < 0)
1184             {
1185                 ERR("restore error: %s\n", snd_strerror(amt));
1186                 aluHandleDisconnect(device);
1187                 break;
1188             }
1189             /* If the amount available is less than what's asked, we lost it
1190              * during recovery. So just give silence instead. */
1191             if((snd_pcm_uframes_t)amt < samples)
1192                 break;
1193             continue;
1194         }
1195
1196         buffer = (ALbyte*)buffer + amt;
1197         samples -= amt;
1198     }
1199     if(samples > 0)
1200         memset(buffer, ((device->FmtType == DevFmtUByte) ? 0x80 : 0),
1201                snd_pcm_frames_to_bytes(self->pcmHandle, samples));
1202
1203     return ALC_NO_ERROR;
1204 }
1205
1206 static ALCuint ALCcaptureAlsa_availableSamples(ALCcaptureAlsa *self)
1207 {
1208     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
1209     snd_pcm_sframes_t avail = 0;
1210
1211     if(device->Connected && self->doCapture)
1212         avail = snd_pcm_avail_update(self->pcmHandle);
1213     if(avail < 0)
1214     {
1215         ERR("avail update failed: %s\n", snd_strerror(avail));
1216
1217         if((avail=snd_pcm_recover(self->pcmHandle, avail, 1)) >= 0)
1218         {
1219             if(self->doCapture)
1220                 avail = snd_pcm_start(self->pcmHandle);
1221             if(avail >= 0)
1222                 avail = snd_pcm_avail_update(self->pcmHandle);
1223         }
1224         if(avail < 0)
1225         {
1226             ERR("restore error: %s\n", snd_strerror(avail));
1227             aluHandleDisconnect(device);
1228         }
1229     }
1230
1231     if(!self->ring)
1232     {
1233         if(avail < 0) avail = 0;
1234         avail += snd_pcm_bytes_to_frames(self->pcmHandle, self->size);
1235         if(avail > self->last_avail) self->last_avail = avail;
1236         return self->last_avail;
1237     }
1238
1239     while(avail > 0)
1240     {
1241         ll_ringbuffer_data_t vec[2];
1242         snd_pcm_sframes_t amt;
1243
1244         ll_ringbuffer_get_write_vector(self->ring, vec);
1245         if(vec[0].len == 0) break;
1246
1247         amt = (vec[0].len < (snd_pcm_uframes_t)avail) ?
1248               vec[0].len : (snd_pcm_uframes_t)avail;
1249         amt = snd_pcm_readi(self->pcmHandle, vec[0].buf, amt);
1250         if(amt < 0)
1251         {
1252             ERR("read error: %s\n", snd_strerror(amt));
1253
1254             if(amt == -EAGAIN)
1255                 continue;
1256             if((amt=snd_pcm_recover(self->pcmHandle, amt, 1)) >= 0)
1257             {
1258                 if(self->doCapture)
1259                     amt = snd_pcm_start(self->pcmHandle);
1260                 if(amt >= 0)
1261                     amt = snd_pcm_avail_update(self->pcmHandle);
1262             }
1263             if(amt < 0)
1264             {
1265                 ERR("restore error: %s\n", snd_strerror(amt));
1266                 aluHandleDisconnect(device);
1267                 break;
1268             }
1269             avail = amt;
1270             continue;
1271         }
1272
1273         ll_ringbuffer_write_advance(self->ring, amt);
1274         avail -= amt;
1275     }
1276
1277     return ll_ringbuffer_read_space(self->ring);
1278 }
1279
1280 static ALint64 ALCcaptureAlsa_getLatency(ALCcaptureAlsa *self)
1281 {
1282     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
1283     snd_pcm_sframes_t delay = 0;
1284     int err;
1285
1286     if((err=snd_pcm_delay(self->pcmHandle, &delay)) < 0)
1287     {
1288         ERR("Failed to get pcm delay: %s\n", snd_strerror(err));
1289         return 0;
1290     }
1291     return maxi64((ALint64)delay*1000000000/device->Frequency, 0);
1292 }
1293
1294
1295 static inline void AppendAllDevicesList2(const DevMap *entry)
1296 { AppendAllDevicesList(al_string_get_cstr(entry->name)); }
1297 static inline void AppendCaptureDeviceList2(const DevMap *entry)
1298 { AppendCaptureDeviceList(al_string_get_cstr(entry->name)); }
1299
1300 typedef struct ALCalsaBackendFactory {
1301     DERIVE_FROM_TYPE(ALCbackendFactory);
1302 } ALCalsaBackendFactory;
1303 #define ALCALSABACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCalsaBackendFactory, ALCbackendFactory) } }
1304
1305 static ALCboolean ALCalsaBackendFactory_init(ALCalsaBackendFactory* UNUSED(self))
1306 {
1307     VECTOR_INIT(PlaybackDevices);
1308     VECTOR_INIT(CaptureDevices);
1309
1310     if(!alsa_load())
1311         return ALC_FALSE;
1312     return ALC_TRUE;
1313 }
1314
1315 static void ALCalsaBackendFactory_deinit(ALCalsaBackendFactory* UNUSED(self))
1316 {
1317     clear_devlist(&PlaybackDevices);
1318     VECTOR_DEINIT(PlaybackDevices);
1319
1320     clear_devlist(&CaptureDevices);
1321     VECTOR_DEINIT(CaptureDevices);
1322
1323 #ifdef HAVE_DYNLOAD
1324     if(alsa_handle)
1325         CloseLib(alsa_handle);
1326     alsa_handle = NULL;
1327 #endif
1328 }
1329
1330 static ALCboolean ALCalsaBackendFactory_querySupport(ALCalsaBackendFactory* UNUSED(self), ALCbackend_Type type)
1331 {
1332     if(type == ALCbackend_Playback || type == ALCbackend_Capture)
1333         return ALC_TRUE;
1334     return ALC_FALSE;
1335 }
1336
1337 static void ALCalsaBackendFactory_probe(ALCalsaBackendFactory* UNUSED(self), enum DevProbe type)
1338 {
1339     switch(type)
1340     {
1341         case ALL_DEVICE_PROBE:
1342             probe_devices(SND_PCM_STREAM_PLAYBACK, &PlaybackDevices);
1343             VECTOR_FOR_EACH(const DevMap, PlaybackDevices, AppendAllDevicesList2);
1344             break;
1345
1346         case CAPTURE_DEVICE_PROBE:
1347             probe_devices(SND_PCM_STREAM_CAPTURE, &CaptureDevices);
1348             VECTOR_FOR_EACH(const DevMap, CaptureDevices, AppendCaptureDeviceList2);
1349             break;
1350     }
1351 }
1352
1353 static ALCbackend* ALCalsaBackendFactory_createBackend(ALCalsaBackendFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type)
1354 {
1355     if(type == ALCbackend_Playback)
1356     {
1357         ALCplaybackAlsa *backend;
1358         NEW_OBJ(backend, ALCplaybackAlsa)(device);
1359         if(!backend) return NULL;
1360         return STATIC_CAST(ALCbackend, backend);
1361     }
1362     if(type == ALCbackend_Capture)
1363     {
1364         ALCcaptureAlsa *backend;
1365         NEW_OBJ(backend, ALCcaptureAlsa)(device);
1366         if(!backend) return NULL;
1367         return STATIC_CAST(ALCbackend, backend);
1368     }
1369
1370     return NULL;
1371 }
1372
1373 DEFINE_ALCBACKENDFACTORY_VTABLE(ALCalsaBackendFactory);
1374
1375
1376 ALCbackendFactory *ALCalsaBackendFactory_getFactory(void)
1377 {
1378     static ALCalsaBackendFactory factory = ALCALSABACKENDFACTORY_INITIALIZER;
1379     return STATIC_CAST(ALCbackendFactory, &factory);
1380 }