Alc/backends/alsa.cpp

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