src/context.cpp

   1
   2 #include "config.h"
   3
   4 #include "context.h"
   5
   6 #include <stdexcept>
   7 #include <algorithm>
   8 #include <functional>
   9 #include <memory>
  10 #include <iostream>
  11 #include <sstream>
  12 #include <fstream>
  13 #include <cstring>
  14 #include <map>
  15 #include <new>
  16
  17 #include "alc.h"
  18
  19 #ifdef HAVE_VORBISFILE
  20 #include "decoders/vorbisfile.hpp"
  21 #endif
  22 #ifdef HAVE_LIBFLAC
  23 #include "decoders/flac.hpp"
  24 #endif
  25 #ifdef HAVE_OPUSFILE
  26 #include "decoders/opusfile.hpp"
  27 #endif
  28 #ifdef HAVE_LIBSNDFILE
  29 #include "decoders/sndfile.hpp"
  30 #endif
  31 #ifdef HAVE_MPG123
  32 #include "decoders/mpg123.hpp"
  33 #endif
  34 #include "decoders/wave.hpp"
  35
  36 #include "devicemanager.h"
  37 #include "device.h"
  38 #include "buffer.h"
  39 #include "source.h"
  40 #include "auxeffectslot.h"
  41 #include "effect.h"
  42 #include "sourcegroup.h"
  43
  44 #ifdef _WIN32
  45 #define WIN32_LEAN_AND_MEAN
  46 #include <windows.h>
  47 #endif
  48
  49 namespace std
  50 {
  51
  52 // Implements a FNV-1a hash for StringView. NOTE: This is *NOT* guaranteed
  53 // compatible with std::hash<String>! The standard does not give any specific
  54 // hash implementation, nor a way for applications to access the same hash
  55 // function as std::string (short of copying into a string and hashing that).
  56 // So if you need Strings and StringViews to result in the same hash for the
  57 // same set of characters, hash StringViews created from the Strings.
  58 template<>
  59 struct hash<alure::StringView> {
  60     size_t operator()(const alure::StringView &str) const noexcept
  61     {
  62         using traits_type = alure::StringView::traits_type;
  63
  64         if /*constexpr*/ (sizeof(size_t) == 8)
  65         {
  66             static constexpr size_t hash_offset = 0xcbf29ce484222325;
  67             static constexpr size_t hash_prime = 0x100000001b3;
  68
  69             size_t val = hash_offset;
  70             for(auto ch : str)
  71                 val = (val^traits_type::to_int_type(ch)) * hash_prime;
  72             return val;
  73         }
  74         else
  75         {
  76             static constexpr size_t hash_offset = 0x811c9dc5;
  77             static constexpr size_t hash_prime = 0x1000193;
  78
  79             size_t val = hash_offset;
  80             for(auto ch : str)
  81                 val = (val^traits_type::to_int_type(ch)) * hash_prime;
  82             return val;
  83         }
  84     }
  85 };
  86
  87 }
  88
  89 namespace
  90 {
  91
  92 // Global mutex to protect global context changes
  93 std::mutex mGlobalCtxMutex;
  94
  95 #ifdef _WIN32
  96 // Windows' std::ifstream fails with non-ANSI paths since the standard only
  97 // specifies names using const char* (or std::string). MSVC has a non-standard
  98 // extension using const wchar_t* (or std::wstring?) to handle Unicode paths,
  99 // but not all Windows compilers support it. So we have to make our own istream
 100 // that accepts UTF-8 paths and forwards to Unicode-aware I/O functions.
 101 class StreamBuf final : public std::streambuf {
 102     alure::Array<char_type,4096> mBuffer;
 103     HANDLE mFile;
 104
 105     int_type underflow() override
 106     {
 107         if(mFile != INVALID_HANDLE_VALUE && gptr() == egptr())
 108         {
 109             // Read in the next chunk of data, and set the pointers on success
 110             DWORD got = 0;
 111             if(!ReadFile(mFile, mBuffer.data(), mBuffer.size(), &got, NULL))
 112                 got = 0;
 113             setg(mBuffer.data(), mBuffer.data(), mBuffer.data()+got);
 114         }
 115         if(gptr() == egptr())
 116             return traits_type::eof();
 117         return traits_type::to_int_type(*gptr());
 118     }
 119
 120     pos_type seekoff(off_type offset, std::ios_base::seekdir whence, std::ios_base::openmode mode) override
 121     {
 122         if(mFile == INVALID_HANDLE_VALUE || (mode&std::ios_base::out) || !(mode&std::ios_base::in))
 123             return traits_type::eof();
 124
 125         LARGE_INTEGER fpos;
 126         switch(whence)
 127         {
 128             case std::ios_base::beg:
 129                 fpos.QuadPart = offset;
 130                 if(!SetFilePointerEx(mFile, fpos, &fpos, FILE_BEGIN))
 131                     return traits_type::eof();
 132                 break;
 133
 134             case std::ios_base::cur:
 135                 // If the offset remains in the current buffer range, just
 136                 // update the pointer.
 137                 if((offset >= 0 && offset < off_type(egptr()-gptr())) ||
 138                    (offset < 0 && -offset <= off_type(gptr()-eback())))
 139                 {
 140                     // Get the current file offset to report the correct read
 141                     // offset.
 142                     fpos.QuadPart = 0;
 143                     if(!SetFilePointerEx(mFile, fpos, &fpos, FILE_CURRENT))
 144                         return traits_type::eof();
 145                     setg(eback(), gptr()+offset, egptr());
 146                     return fpos.QuadPart - off_type(egptr()-gptr());
 147                 }
 148                 // Need to offset for the file offset being at egptr() while
 149                 // the requested offset is relative to gptr().
 150                 offset -= off_type(egptr()-gptr());
 151                 fpos.QuadPart = offset;
 152                 if(!SetFilePointerEx(mFile, fpos, &fpos, FILE_CURRENT))
 153                     return traits_type::eof();
 154                 break;
 155
 156             case std::ios_base::end:
 157                 fpos.QuadPart = offset;
 158                 if(!SetFilePointerEx(mFile, fpos, &fpos, FILE_END))
 159                     return traits_type::eof();
 160                 break;
 161
 162             default:
 163                 return traits_type::eof();
 164         }
 165         setg(0, 0, 0);
 166         return fpos.QuadPart;
 167     }
 168
 169     pos_type seekpos(pos_type pos, std::ios_base::openmode mode) override
 170     {
 171         // Simplified version of seekoff
 172         if(mFile == INVALID_HANDLE_VALUE || (mode&std::ios_base::out) || !(mode&std::ios_base::in))
 173             return traits_type::eof();
 174
 175         LARGE_INTEGER fpos;
 176         fpos.QuadPart = pos;
 177         if(!SetFilePointerEx(mFile, fpos, &fpos, FILE_BEGIN))
 178             return traits_type::eof();
 179
 180         setg(0, 0, 0);
 181         return fpos.QuadPart;
 182     }
 183
 184 public:
 185     bool open(const char *filename)
 186     {
 187         alure::Vector<wchar_t> wname;
 188         int wnamelen;
 189
 190         wnamelen = MultiByteToWideChar(CP_UTF8, 0, filename, -1, NULL, 0);
 191         if(wnamelen <= 0) return false;
 192
 193         wname.resize(wnamelen);
 194         MultiByteToWideChar(CP_UTF8, 0, filename, -1, wname.data(), wnamelen);
 195
 196         mFile = CreateFileW(wname.data(), GENERIC_READ, FILE_SHARE_READ, NULL,
 197                             OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
 198         if(mFile == INVALID_HANDLE_VALUE) return false;
 199         return true;
 200     }
 201
 202     bool is_open() const { return mFile != INVALID_HANDLE_VALUE; }
 203
 204     StreamBuf() : mFile(INVALID_HANDLE_VALUE)
 205     { }
 206     ~StreamBuf() override
 207     {
 208         if(mFile != INVALID_HANDLE_VALUE)
 209             CloseHandle(mFile);
 210         mFile = INVALID_HANDLE_VALUE;
 211     }
 212 };
 213
 214 // Inherit from std::istream to use our custom streambuf
 215 class Stream final : public std::istream {
 216 public:
 217     Stream(const char *filename) : std::istream(new StreamBuf())
 218     {
 219         // Set the failbit if the file failed to open.
 220         if(!(static_cast<StreamBuf*>(rdbuf())->open(filename)))
 221             clear(failbit);
 222     }
 223     ~Stream() override
 224     { delete rdbuf(); }
 225
 226     bool is_open() const { return static_cast<StreamBuf*>(rdbuf())->is_open(); }
 227 };
 228 #endif
 229
 230 using DecoderEntryPair = std::pair<alure::String,alure::UniquePtr<alure::DecoderFactory>>;
 231 const DecoderEntryPair sDefaultDecoders[] = {
 232     { "_alure_int_wave", alure::MakeUnique<alure::WaveDecoderFactory>() },
 233
 234 #ifdef HAVE_VORBISFILE
 235     { "_alure_int_vorbis", alure::MakeUnique<alure::VorbisFileDecoderFactory>() },
 236 #endif
 237 #ifdef HAVE_LIBFLAC
 238     { "_alure_int_flac", alure::MakeUnique<alure::FlacDecoderFactory>() },
 239 #endif
 240 #ifdef HAVE_OPUSFILE
 241     { "_alure_int_opus", alure::MakeUnique<alure::OpusFileDecoderFactory>() },
 242 #endif
 243 #ifdef HAVE_LIBSNDFILE
 244     { "_alure_int_sndfile", alure::MakeUnique<alure::SndFileDecoderFactory>() },
 245 #endif
 246 #ifdef HAVE_MPG123
 247     { "_alure_int_mpg123", alure::MakeUnique<alure::Mpg123DecoderFactory>() },
 248 #endif
 249 };
 250 alure::Vector<DecoderEntryPair> sDecoders;
 251
 252
 253 template<typename T>
 254 alure::DecoderOrExceptT GetDecoder(alure::UniquePtr<std::istream> &file, T start, T end)
 255 {
 256     alure::DecoderOrExceptT ret;
 257     while(start != end)
 258     {
 259         alure::DecoderFactory *factory = start->second.get();
 260         auto decoder = factory->createDecoder(file);
 261         if(decoder) return (ret = std::move(decoder));
 262
 263         if(!file || !(file->clear(),file->seekg(0)))
 264             return (ret = std::make_exception_ptr(std::runtime_error(
 265                 "Failed to rewind file for the next decoder factory"
 266             )));
 267
 268         ++start;
 269     }
 270
 271     return (ret = alure::SharedPtr<alure::Decoder>(nullptr));
 272 }
 273
 274 static alure::DecoderOrExceptT GetDecoder(alure::UniquePtr<std::istream> file)
 275 {
 276     auto decoder = GetDecoder(file, sDecoders.begin(), sDecoders.end());
 277     if(std::holds_alternative<std::exception_ptr>(decoder)) return decoder;
 278     if(std::get<alure::SharedPtr<alure::Decoder>>(decoder)) return decoder;
 279     decoder = GetDecoder(file, std::begin(sDefaultDecoders), std::end(sDefaultDecoders));
 280     if(std::holds_alternative<std::exception_ptr>(decoder)) return decoder;
 281     if(std::get<alure::SharedPtr<alure::Decoder>>(decoder)) return decoder;
 282     return (decoder = std::make_exception_ptr(std::runtime_error("No decoder found")));
 283 }
 284
 285 class DefaultFileIOFactory final : public alure::FileIOFactory {
 286     alure::UniquePtr<std::istream> openFile(const alure::String &name) override
 287     {
 288 #ifdef _WIN32
 289         auto file = alure::MakeUnique<Stream>(name.c_str());
 290 #else
 291         auto file = alure::MakeUnique<std::ifstream>(name.c_str(), std::ios::binary);
 292 #endif
 293         if(!file->is_open()) file = nullptr;
 294         return std::move(file);
 295     }
 296 };
 297 DefaultFileIOFactory sDefaultFileFactory;
 298
 299 alure::UniquePtr<alure::FileIOFactory> sFileFactory;
 300
 301 }
 302
 303 namespace alure
 304 {
 305
 306 using Vector3Pair = std::pair<Vector3,Vector3>;
 307
 308
 309 Decoder::~Decoder() { }
 310 DecoderFactory::~DecoderFactory() { }
 311
 312 void RegisterDecoder(StringView name, UniquePtr<DecoderFactory> factory)
 313 {
 314     auto iter = std::lower_bound(sDecoders.begin(), sDecoders.end(), name,
 315         [](const DecoderEntryPair &entry, StringView rhs) -> bool
 316         { return entry.first < rhs; }
 317     );
 318     if(iter != sDecoders.end())
 319         throw std::runtime_error("Decoder factory already registered");
 320     sDecoders.insert(iter, std::make_pair(String(name), std::move(factory)));
 321 }
 322
 323 UniquePtr<DecoderFactory> UnregisterDecoder(StringView name)
 324 {
 325     auto iter = std::lower_bound(sDecoders.begin(), sDecoders.end(), name,
 326         [](const DecoderEntryPair &entry, StringView rhs) -> bool
 327         { return entry.first < rhs; }
 328     );
 329     if(iter != sDecoders.end())
 330     {
 331         UniquePtr<DecoderFactory> factory = std::move(iter->second);
 332         sDecoders.erase(iter);
 333         return factory;
 334     }
 335     return nullptr;
 336 }
 337
 338
 339 FileIOFactory::~FileIOFactory() { }
 340
 341 UniquePtr<FileIOFactory> FileIOFactory::set(UniquePtr<FileIOFactory> factory)
 342 {
 343     std::swap(sFileFactory, factory);
 344     return factory;
 345 }
 346
 347 FileIOFactory &FileIOFactory::get()
 348 {
 349     FileIOFactory *factory = sFileFactory.get();
 350     if(factory) return *factory;
 351     return sDefaultFileFactory;
 352 }
 353
 354
 355 // Default message handler methods are no-ops.
 356 MessageHandler::~MessageHandler()
 357 {
 358 }
 359
 360 void MessageHandler::deviceDisconnected(Device)
 361 {
 362 }
 363
 364 void MessageHandler::sourceStopped(Source)
 365 {
 366 }
 367
 368 void MessageHandler::sourceForceStopped(Source)
 369 {
 370 }
 371
 372 void MessageHandler::bufferLoading(StringView, ChannelConfig, SampleType, ALuint, ArrayView<ALbyte>)
 373 {
 374 }
 375
 376 String MessageHandler::resourceNotFound(StringView)
 377 {
 378     return String();
 379 }
 380
 381
 382 template<typename T>
 383 static inline void LoadALFunc(T **func, const char *name)
 384 { *func = reinterpret_cast<T*>(alGetProcAddress(name)); }
 385
 386 static void LoadNothing(ContextImpl*) { }
 387
 388 static void LoadEFX(ContextImpl *ctx)
 389 {
 390     LoadALFunc(&ctx->alGenEffects,    "alGenEffects");
 391     LoadALFunc(&ctx->alDeleteEffects, "alDeleteEffects");
 392     LoadALFunc(&ctx->alIsEffect,      "alIsEffect");
 393     LoadALFunc(&ctx->alEffecti,       "alEffecti");
 394     LoadALFunc(&ctx->alEffectiv,      "alEffectiv");
 395     LoadALFunc(&ctx->alEffectf,       "alEffectf");
 396     LoadALFunc(&ctx->alEffectfv,      "alEffectfv");
 397     LoadALFunc(&ctx->alGetEffecti,    "alGetEffecti");
 398     LoadALFunc(&ctx->alGetEffectiv,   "alGetEffectiv");
 399     LoadALFunc(&ctx->alGetEffectf,    "alGetEffectf");
 400     LoadALFunc(&ctx->alGetEffectfv,   "alGetEffectfv");
 401
 402     LoadALFunc(&ctx->alGenFilters,    "alGenFilters");
 403     LoadALFunc(&ctx->alDeleteFilters, "alDeleteFilters");
 404     LoadALFunc(&ctx->alIsFilter,      "alIsFilter");
 405     LoadALFunc(&ctx->alFilteri,       "alFilteri");
 406     LoadALFunc(&ctx->alFilteriv,      "alFilteriv");
 407     LoadALFunc(&ctx->alFilterf,       "alFilterf");
 408     LoadALFunc(&ctx->alFilterfv,      "alFilterfv");
 409     LoadALFunc(&ctx->alGetFilteri,    "alGetFilteri");
 410     LoadALFunc(&ctx->alGetFilteriv,   "alGetFilteriv");
 411     LoadALFunc(&ctx->alGetFilterf,    "alGetFilterf");
 412     LoadALFunc(&ctx->alGetFilterfv,   "alGetFilterfv");
 413
 414     LoadALFunc(&ctx->alGenAuxiliaryEffectSlots,    "alGenAuxiliaryEffectSlots");
 415     LoadALFunc(&ctx->alDeleteAuxiliaryEffectSlots, "alDeleteAuxiliaryEffectSlots");
 416     LoadALFunc(&ctx->alIsAuxiliaryEffectSlot,      "alIsAuxiliaryEffectSlot");
 417     LoadALFunc(&ctx->alAuxiliaryEffectSloti,       "alAuxiliaryEffectSloti");
 418     LoadALFunc(&ctx->alAuxiliaryEffectSlotiv,      "alAuxiliaryEffectSlotiv");
 419     LoadALFunc(&ctx->alAuxiliaryEffectSlotf,       "alAuxiliaryEffectSlotf");
 420     LoadALFunc(&ctx->alAuxiliaryEffectSlotfv,      "alAuxiliaryEffectSlotfv");
 421     LoadALFunc(&ctx->alGetAuxiliaryEffectSloti,    "alGetAuxiliaryEffectSloti");
 422     LoadALFunc(&ctx->alGetAuxiliaryEffectSlotiv,   "alGetAuxiliaryEffectSlotiv");
 423     LoadALFunc(&ctx->alGetAuxiliaryEffectSlotf,    "alGetAuxiliaryEffectSlotf");
 424     LoadALFunc(&ctx->alGetAuxiliaryEffectSlotfv,   "alGetAuxiliaryEffectSlotfv");
 425 }
 426
 427 static void LoadSourceResampler(ContextImpl *ctx)
 428 {
 429     LoadALFunc(&ctx->alGetStringiSOFT, "alGetStringiSOFT");
 430 }
 431
 432 static void LoadSourceLatency(ContextImpl *ctx)
 433 {
 434     LoadALFunc(&ctx->alGetSourcei64vSOFT, "alGetSourcei64vSOFT");
 435     LoadALFunc(&ctx->alGetSourcedvSOFT, "alGetSourcedvSOFT");
 436 }
 437
 438 static const struct {
 439     enum AL extension;
 440     const char name[32];
 441     void (&loader)(ContextImpl*);
 442 } ALExtensionList[] = {
 443     { AL::EXT_EFX, "ALC_EXT_EFX", LoadEFX },
 444
 445     { AL::EXT_FLOAT32,   "AL_EXT_FLOAT32",   LoadNothing },
 446     { AL::EXT_MCFORMATS, "AL_EXT_MCFORMATS", LoadNothing },
 447     { AL::EXT_BFORMAT,   "AL_EXT_BFORMAT",   LoadNothing },
 448
 449     { AL::EXT_MULAW,           "AL_EXT_MULAW",           LoadNothing },
 450     { AL::EXT_MULAW_MCFORMATS, "AL_EXT_MULAW_MCFORMATS", LoadNothing },
 451     { AL::EXT_MULAW_BFORMAT,   "AL_EXT_MULAW_BFORMAT",   LoadNothing },
 452
 453     { AL::SOFT_loop_points,       "AL_SOFT_loop_points",       LoadNothing },
 454     { AL::SOFT_source_latency,    "AL_SOFT_source_latency",    LoadSourceLatency },
 455     { AL::SOFT_source_resampler,  "AL_SOFT_source_resampler",  LoadSourceResampler },
 456     { AL::SOFT_source_spatialize, "AL_SOFT_source_spatialize", LoadNothing },
 457
 458     { AL::EXT_disconnect, "ALC_EXT_disconnect", LoadNothing },
 459
 460     { AL::EXT_SOURCE_RADIUS, "AL_EXT_SOURCE_RADIUS", LoadNothing },
 461     { AL::EXT_STEREO_ANGLES, "AL_EXT_STEREO_ANGLES", LoadNothing },
 462 };
 463
 464
 465 ContextImpl *ContextImpl::sCurrentCtx = nullptr;
 466 thread_local ContextImpl *ContextImpl::sThreadCurrentCtx = nullptr;
 467
 468 std::atomic<uint64_t> ContextImpl::sContextSetCount{0};
 469
 470 void ContextImpl::MakeCurrent(ContextImpl *context)
 471 {
 472     std::unique_lock<std::mutex> ctxlock(mGlobalCtxMutex);
 473
 474     if(alcMakeContextCurrent(context ? context->getALCcontext() : nullptr) == ALC_FALSE)
 475         throw std::runtime_error("Call to alcMakeContextCurrent failed");
 476     if(context)
 477     {
 478         context->addRef();
 479         std::call_once(context->mSetExts, std::mem_fn(&ContextImpl::setupExts), context);
 480     }
 481     std::swap(sCurrentCtx, context);
 482     if(context) context->decRef();
 483
 484     if(sThreadCurrentCtx)
 485         sThreadCurrentCtx->decRef();
 486     sThreadCurrentCtx = nullptr;
 487     sContextSetCount.fetch_add(1, std::memory_order_release);
 488
 489     if((context = sCurrentCtx) != nullptr)
 490     {
 491         ctxlock.unlock();
 492         context->mWakeThread.notify_all();
 493     }
 494 }
 495
 496 void ContextImpl::MakeThreadCurrent(ContextImpl *context)
 497 {
 498     if(!DeviceManagerImpl::SetThreadContext)
 499         throw std::runtime_error("Thread-local contexts unsupported");
 500     if(DeviceManagerImpl::SetThreadContext(context ? context->getALCcontext() : nullptr) == ALC_FALSE)
 501         throw std::runtime_error("Call to alcSetThreadContext failed");
 502     if(context)
 503     {
 504         context->addRef();
 505         std::call_once(context->mSetExts, std::mem_fn(&ContextImpl::setupExts), context);
 506     }
 507     if(sThreadCurrentCtx)
 508         sThreadCurrentCtx->decRef();
 509     sThreadCurrentCtx = context;
 510     sContextSetCount.fetch_add(1, std::memory_order_release);
 511 }
 512
 513 void ContextImpl::setupExts()
 514 {
 515     ALCdevice *device = mDevice->getALCdevice();
 516     mHasExt.clear();
 517     for(const auto &entry : ALExtensionList)
 518     {
 519         if((strncmp(entry.name, "ALC", 3) == 0) ? alcIsExtensionPresent(device, entry.name) :
 520                                                   alIsExtensionPresent(entry.name))
 521         {
 522             mHasExt.set(static_cast<size_t>(entry.extension));
 523             entry.loader(this);
 524         }
 525     }
 526 }
 527
 528
 529 void ContextImpl::backgroundProc()
 530 {
 531     if(DeviceManagerImpl::SetThreadContext && mDevice->hasExtension(ALC::EXT_thread_local_context))
 532         DeviceManagerImpl::SetThreadContext(getALCcontext());
 533
 534     std::chrono::steady_clock::time_point basetime = std::chrono::steady_clock::now();
 535     std::chrono::milliseconds waketime(0);
 536     std::unique_lock<std::mutex> ctxlock(mGlobalCtxMutex);
 537     while(!mQuitThread.load(std::memory_order_acquire))
 538     {
 539         {
 540             std::lock_guard<std::mutex> srclock(mSourceStreamMutex);
 541             mStreamingSources.erase(
 542                 std::remove_if(mStreamingSources.begin(), mStreamingSources.end(),
 543                     [](SourceImpl *source) -> bool
 544                     { return !source->updateAsync(); }
 545                 ), mStreamingSources.end()
 546             );
 547         }
 548
 549         // Only do one pending buffer at a time. In case there's several large
 550         // buffers to load, we still need to process streaming sources so they
 551         // don't underrun.
 552         PendingPromise *lastpb = mPendingCurrent.load(std::memory_order_acquire);
 553         if(PendingPromise *pb = lastpb->mNext.load(std::memory_order_relaxed))
 554         {
 555             pb->mBuffer->load(pb->mFrames, pb->mFormat, std::move(pb->mDecoder), this);
 556             pb->mPromise.set_value(Buffer(pb->mBuffer));
 557             Promise<Buffer>().swap(pb->mPromise);
 558             mPendingCurrent.store(pb, std::memory_order_release);
 559             continue;
 560         }
 561
 562         std::unique_lock<std::mutex> wakelock(mWakeMutex);
 563         if(!mQuitThread.load(std::memory_order_acquire) && lastpb->mNext.load(std::memory_order_acquire) == nullptr)
 564         {
 565             ctxlock.unlock();
 566
 567             std::chrono::milliseconds interval = mWakeInterval.load(std::memory_order_relaxed);
 568             if(interval.count() == 0)
 569                 mWakeThread.wait(wakelock);
 570             else
 571             {
 572                 auto now = std::chrono::steady_clock::now() - basetime;
 573                 if(now > waketime)
 574                 {
 575                     auto mult = (now-waketime + interval-std::chrono::milliseconds(1)) / interval;
 576                     waketime += interval * mult;
 577                 }
 578                 mWakeThread.wait_until(wakelock, waketime + basetime);
 579             }
 580             wakelock.unlock();
 581
 582             ctxlock.lock();
 583             while(!mQuitThread.load(std::memory_order_acquire) &&
 584                   alcGetCurrentContext() != getALCcontext())
 585                 mWakeThread.wait(ctxlock);
 586         }
 587     }
 588     ctxlock.unlock();
 589
 590     if(DeviceManagerImpl::SetThreadContext)
 591         DeviceManagerImpl::SetThreadContext(nullptr);
 592 }
 593
 594
 595 ContextImpl::ContextImpl(ALCcontext *context, DeviceImpl *device)
 596   : mContextSetCounter(std::numeric_limits<uint64_t>::max()),
 597     mListener(this), mContext(context), mDevice(device),
 598     mWakeInterval(std::chrono::milliseconds::zero()), mQuitThread(false),
 599     mRefs(0), mIsConnected(true), mIsBatching(false),
 600     alGetSourcei64vSOFT(0), alGetSourcedvSOFT(0),
 601     alGenEffects(0), alDeleteEffects(0), alIsEffect(0),
 602     alEffecti(0), alEffectiv(0), alEffectf(0), alEffectfv(0),
 603     alGetEffecti(0), alGetEffectiv(0), alGetEffectf(0), alGetEffectfv(0),
 604     alGenFilters(0), alDeleteFilters(0), alIsFilter(0),
 605     alFilteri(0), alFilteriv(0), alFilterf(0), alFilterfv(0),
 606     alGetFilteri(0), alGetFilteriv(0), alGetFilterf(0), alGetFilterfv(0),
 607     alGenAuxiliaryEffectSlots(0), alDeleteAuxiliaryEffectSlots(0), alIsAuxiliaryEffectSlot(0),
 608     alAuxiliaryEffectSloti(0), alAuxiliaryEffectSlotiv(0), alAuxiliaryEffectSlotf(0), alAuxiliaryEffectSlotfv(0),
 609     alGetAuxiliaryEffectSloti(0), alGetAuxiliaryEffectSlotiv(0), alGetAuxiliaryEffectSlotf(0), alGetAuxiliaryEffectSlotfv(0)
 610 {
 611     mHasExt.clear();
 612     mSourceIds.reserve(256);
 613     mPendingHead = new PendingPromise;
 614     mPendingCurrent.store(mPendingHead, std::memory_order_relaxed);
 615     mPendingTail = mPendingHead;
 616 }
 617
 618 ContextImpl::~ContextImpl()
 619 {
 620     PendingPromise *pb = mPendingTail;
 621     while(pb)
 622     {
 623         PendingPromise *next = pb->mNext.load(std::memory_order_relaxed);
 624         delete pb;
 625         pb = next;
 626     }
 627     mPendingCurrent.store(nullptr, std::memory_order_relaxed);
 628     mPendingHead = nullptr;
 629     mPendingTail = nullptr;
 630 }
 631
 632
 633 void Context::destroy()
 634 {
 635     ContextImpl *i = pImpl;
 636     pImpl = nullptr;
 637     i->destroy();
 638 }
 639 void ContextImpl::destroy()
 640 {
 641     if(mRefs != 0)
 642         throw std::runtime_error("Context is in use");
 643     if(!mBuffers.empty())
 644         throw std::runtime_error("Trying to destroy a context with buffers");
 645
 646     if(mThread.joinable())
 647     {
 648         std::unique_lock<std::mutex> lock(mWakeMutex);
 649         mQuitThread.store(true, std::memory_order_release);
 650         lock.unlock();
 651         mWakeThread.notify_all();
 652         mThread.join();
 653     }
 654
 655     alcDestroyContext(mContext);
 656     mContext = nullptr;
 657
 658     mDevice->removeContext(this);
 659 }
 660
 661
 662 DECL_THUNK0(void, Context, startBatch,)
 663 void ContextImpl::startBatch()
 664 {
 665     alcSuspendContext(mContext);
 666     mIsBatching = true;
 667 }
 668
 669 DECL_THUNK0(void, Context, endBatch,)
 670 void ContextImpl::endBatch()
 671 {
 672     alcProcessContext(mContext);
 673     mIsBatching = false;
 674 }
 675
 676
 677 DECL_THUNK1(SharedPtr<MessageHandler>, Context, setMessageHandler,, SharedPtr<MessageHandler>)
 678 SharedPtr<MessageHandler> ContextImpl::setMessageHandler(SharedPtr<MessageHandler>&& handler)
 679 {
 680     std::lock_guard<std::mutex> lock(mGlobalCtxMutex);
 681     mMessage.swap(handler);
 682     return handler;
 683 }
 684
 685
 686 DECL_THUNK1(void, Context, setAsyncWakeInterval,, std::chrono::milliseconds)
 687 void ContextImpl::setAsyncWakeInterval(std::chrono::milliseconds interval)
 688 {
 689     if(interval.count() < 0 || interval > std::chrono::seconds(1))
 690         throw std::out_of_range("Async wake interval out of range");
 691     mWakeInterval.store(interval);
 692     mWakeMutex.lock(); mWakeMutex.unlock();
 693     mWakeThread.notify_all();
 694 }
 695
 696
 697 DecoderOrExceptT ContextImpl::findDecoder(StringView name)
 698 {
 699     DecoderOrExceptT ret;
 700
 701     String oldname = String(name);
 702     auto file = FileIOFactory::get().openFile(oldname);
 703     if(file) return (ret = GetDecoder(std::move(file)));
 704
 705     // Resource not found. Try to find a substitute.
 706     if(!mMessage.get())
 707         return (ret = std::make_exception_ptr(std::runtime_error("Failed to open file")));
 708     do {
 709         String newname(mMessage->resourceNotFound(oldname));
 710         if(newname.empty())
 711             return (ret = std::make_exception_ptr(std::runtime_error("Failed to open file")));
 712         file = FileIOFactory::get().openFile(newname);
 713         oldname = std::move(newname);
 714     } while(!file);
 715
 716     return (ret = GetDecoder(std::move(file)));
 717 }
 718
 719 DECL_THUNK1(SharedPtr<Decoder>, Context, createDecoder,, StringView)
 720 SharedPtr<Decoder> ContextImpl::createDecoder(StringView name)
 721 {
 722     CheckContext(this);
 723     DecoderOrExceptT dec = findDecoder(name);
 724     if(SharedPtr<Decoder> *decoder = std::get_if<SharedPtr<Decoder>>(&dec))
 725         return *decoder;
 726     std::rethrow_exception(std::get<std::exception_ptr>(dec));
 727 }
 728
 729
 730 DECL_THUNK2(bool, Context, isSupported, const, ChannelConfig, SampleType)
 731 bool ContextImpl::isSupported(ChannelConfig channels, SampleType type) const
 732 {
 733     CheckContext(this);
 734     return GetFormat(channels, type) != AL_NONE;
 735 }
 736
 737
 738 DECL_THUNK0(ArrayView<String>, Context, getAvailableResamplers,)
 739 ArrayView<String> ContextImpl::getAvailableResamplers()
 740 {
 741     CheckContext(this);
 742     if(mResamplers.empty() && hasExtension(AL::SOFT_source_resampler))
 743     {
 744         ALint num_resamplers = alGetInteger(AL_NUM_RESAMPLERS_SOFT);
 745         mResamplers.reserve(num_resamplers);
 746         for(int i = 0;i < num_resamplers;i++)
 747             mResamplers.emplace_back(alGetStringiSOFT(AL_RESAMPLER_NAME_SOFT, i));
 748         if(mResamplers.empty())
 749             mResamplers.emplace_back();
 750     }
 751     return mResamplers;
 752 }
 753
 754 DECL_THUNK0(ALsizei, Context, getDefaultResamplerIndex, const)
 755 ALsizei ContextImpl::getDefaultResamplerIndex() const
 756 {
 757     CheckContext(this);
 758     if(!hasExtension(AL::SOFT_source_resampler))
 759         return 0;
 760     return alGetInteger(AL_DEFAULT_RESAMPLER_SOFT);
 761 }
 762
 763
 764 BufferOrExceptT ContextImpl::doCreateBuffer(StringView name, Vector<UniquePtr<BufferImpl>>::iterator iter, SharedPtr<Decoder> decoder)
 765 {
 766     BufferOrExceptT retval;
 767     ALuint srate = decoder->getFrequency();
 768     ChannelConfig chans = decoder->getChannelConfig();
 769     SampleType type = decoder->getSampleType();
 770     ALuint frames = decoder->getLength();
 771
 772     Vector<ALbyte> data(FramesToBytes(frames, chans, type));
 773     frames = decoder->read(data.data(), frames);
 774     if(!frames)
 775         return (retval = std::make_exception_ptr(std::runtime_error("No samples for buffer")));
 776     data.resize(FramesToBytes(frames, chans, type));
 777
 778     std::pair<uint64_t,uint64_t> loop_pts = decoder->getLoopPoints();
 779     if(loop_pts.first >= loop_pts.second)
 780         loop_pts = std::make_pair(0, frames);
 781     else
 782     {
 783         loop_pts.second = std::min<uint64_t>(loop_pts.second, frames);
 784         loop_pts.first = std::min<uint64_t>(loop_pts.first, loop_pts.second-1);
 785     }
 786
 787     // Get the format before calling the bufferLoading message handler, to
 788     // ensure it's something OpenAL can handle.
 789     ALenum format = GetFormat(chans, type);
 790     if(format == AL_NONE)
 791     {
 792         String str("Unsupported format (");
 793         str += GetSampleTypeName(type);
 794         str += ", ";
 795         str += GetChannelConfigName(chans);
 796         str += ")";
 797         return (retval = std::make_exception_ptr(std::runtime_error(str)));
 798     }
 799
 800     if(mMessage.get())
 801         mMessage->bufferLoading(name, chans, type, srate, data);
 802
 803     alGetError();
 804     ALuint bid = 0;
 805     alGenBuffers(1, &bid);
 806     alBufferData(bid, format, data.data(), data.size(), srate);
 807     if(hasExtension(AL::SOFT_loop_points))
 808     {
 809         ALint pts[2]{(ALint)loop_pts.first, (ALint)loop_pts.second};
 810         alBufferiv(bid, AL_LOOP_POINTS_SOFT, pts);
 811     }
 812     ALenum err = alGetError();
 813     if(err != AL_NO_ERROR)
 814     {
 815         alDeleteBuffers(1, &bid);
 816         return (retval = std::make_exception_ptr(al_error(err, "Failed to buffer data")));
 817     }
 818
 819     return (retval = mBuffers.insert(iter,
 820         MakeUnique<BufferImpl>(this, bid, srate, chans, type, name)
 821     )->get());
 822 }
 823
 824 BufferOrExceptT ContextImpl::doCreateBufferAsync(StringView name, Vector<UniquePtr<BufferImpl>>::iterator iter, SharedPtr<Decoder> decoder, Promise<Buffer> promise)
 825 {
 826     BufferOrExceptT retval;
 827     ALuint srate = decoder->getFrequency();
 828     ChannelConfig chans = decoder->getChannelConfig();
 829     SampleType type = decoder->getSampleType();
 830     ALuint frames = decoder->getLength();
 831     if(!frames)
 832         return (retval = std::make_exception_ptr(std::runtime_error("No samples for buffer")));
 833
 834     ALenum format = GetFormat(chans, type);
 835     if(format == AL_NONE)
 836     {
 837         std::stringstream sstr;
 838         sstr<< "Format not supported ("<<GetSampleTypeName(type)<<", "<<GetChannelConfigName(chans)<<")";
 839         return (retval = std::make_exception_ptr(std::runtime_error(sstr.str())));
 840     }
 841
 842     alGetError();
 843     ALuint bid = 0;
 844     alGenBuffers(1, &bid);
 845     ALenum err = alGetError();
 846     if(err != AL_NO_ERROR)
 847         return (retval = std::make_exception_ptr(al_error(err, "Failed to create buffer")));
 848
 849     auto buffer = MakeUnique<BufferImpl>(this, bid, srate, chans, type, name);
 850
 851     if(mThread.get_id() == std::thread::id())
 852         mThread = std::thread(std::mem_fn(&ContextImpl::backgroundProc), this);
 853
 854     PendingPromise *pf = nullptr;
 855     if(mPendingTail == mPendingCurrent.load(std::memory_order_acquire))
 856         pf = new PendingPromise{buffer.get(), decoder, format, frames, std::move(promise)};
 857     else
 858     {
 859         pf = mPendingTail;
 860         pf->mBuffer = buffer.get();
 861         pf->mDecoder = decoder;
 862         pf->mFormat = format;
 863         pf->mFrames = frames;
 864         pf->mPromise = std::move(promise);
 865         mPendingTail = pf->mNext.exchange(nullptr, std::memory_order_relaxed);
 866     }
 867
 868     mPendingHead->mNext.store(pf, std::memory_order_release);
 869     mPendingHead = pf;
 870
 871     return (retval = mBuffers.insert(iter, std::move(buffer))->get());
 872 }
 873
 874 DECL_THUNK1(Buffer, Context, getBuffer,, StringView)
 875 Buffer ContextImpl::getBuffer(StringView name)
 876 {
 877     CheckContext(this);
 878
 879     auto hasher = std::hash<StringView>();
 880     if(UNLIKELY(!mFutureBuffers.empty()))
 881     {
 882         Buffer buffer;
 883
 884         // If the buffer is already pending for the future, wait for it
 885         auto iter = std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
 886             [hasher](const PendingBuffer &lhs, size_t rhs) -> bool
 887             { return hasher(lhs.mBuffer->getName()) < rhs; }
 888         );
 889         if(iter != mFutureBuffers.end() && iter->mBuffer->getName() == name)
 890         {
 891             buffer = iter->mFuture.get();
 892             mFutureBuffers.erase(iter);
 893         }
 894
 895         // Clear out any completed futures.
 896         mFutureBuffers.erase(
 897             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
 898                 [](const PendingBuffer &entry) -> bool
 899                 { return GetFutureState(entry.mFuture) == std::future_status::ready; }
 900             ), mFutureBuffers.end()
 901         );
 902
 903         // If we got the buffer, return it. Otherwise, go load it normally.
 904         if(buffer) return buffer;
 905     }
 906
 907     auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
 908         [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
 909         { return hasher(lhs->getName()) < rhs; }
 910     );
 911     if(iter != mBuffers.end() && (*iter)->getName() == name)
 912         return Buffer(iter->get());
 913
 914     BufferOrExceptT ret = doCreateBuffer(name, iter, createDecoder(name));
 915     Buffer *buffer = std::get_if<Buffer>(&ret);
 916     if(UNLIKELY(!buffer))
 917         std::rethrow_exception(std::get<std::exception_ptr>(ret));
 918     return *buffer;
 919 }
 920
 921 DECL_THUNK1(SharedFuture<Buffer>, Context, getBufferAsync,, StringView)
 922 SharedFuture<Buffer> ContextImpl::getBufferAsync(StringView name)
 923 {
 924     SharedFuture<Buffer> future;
 925     CheckContext(this);
 926
 927     auto hasher = std::hash<StringView>();
 928     if(UNLIKELY(!mFutureBuffers.empty()))
 929     {
 930         // Check if the future that's being created already exists
 931         auto iter = std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
 932             [hasher](const PendingBuffer &lhs, size_t rhs) -> bool
 933             { return hasher(lhs.mBuffer->getName()) < rhs; }
 934         );
 935         if(iter != mFutureBuffers.end() && iter->mBuffer->getName() == name)
 936         {
 937             future = iter->mFuture;
 938             if(GetFutureState(future) == std::future_status::ready)
 939                 mFutureBuffers.erase(iter);
 940             return future;
 941         }
 942
 943         // Clear out any fulfilled futures.
 944         mFutureBuffers.erase(
 945             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
 946                 [](const PendingBuffer &entry) -> bool
 947                 { return GetFutureState(entry.mFuture) == std::future_status::ready; }
 948             ), mFutureBuffers.end()
 949         );
 950     }
 951
 952     auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
 953         [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
 954         { return hasher(lhs->getName()) < rhs; }
 955     );
 956     if(iter != mBuffers.end() && (*iter)->getName() == name)
 957     {
 958         // User asked to create a future buffer that's already loaded. Just
 959         // construct a promise, fulfill the promise immediately, then return a
 960         // shared future that's already set.
 961         Promise<Buffer> promise;
 962         promise.set_value(Buffer(iter->get()));
 963         future = promise.get_future().share();
 964         return future;
 965     }
 966
 967     Promise<Buffer> promise;
 968     future = promise.get_future().share();
 969
 970     BufferOrExceptT ret = doCreateBufferAsync(name, iter, createDecoder(name), std::move(promise));
 971     Buffer *buffer = std::get_if<Buffer>(&ret);
 972     if(UNLIKELY(!buffer))
 973         std::rethrow_exception(std::get<std::exception_ptr>(ret));
 974     mWakeMutex.lock(); mWakeMutex.unlock();
 975     mWakeThread.notify_all();
 976
 977     mFutureBuffers.insert(
 978         std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
 979             [hasher](const PendingBuffer &lhs, size_t rhs) -> bool
 980             { return hasher(lhs.mBuffer->getName()) < rhs; }
 981         ), { buffer->getHandle(), future }
 982     );
 983
 984     return future;
 985 }
 986
 987 DECL_THUNK1(void, Context, precacheBuffersAsync,, ArrayView<StringView>)
 988 void ContextImpl::precacheBuffersAsync(ArrayView<StringView> names)
 989 {
 990     CheckContext(this);
 991
 992     if(UNLIKELY(!mFutureBuffers.empty()))
 993     {
 994         // Clear out any fulfilled futures.
 995         mFutureBuffers.erase(
 996             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
 997                 [](const PendingBuffer &entry) -> bool
 998                 { return GetFutureState(entry.mFuture) == std::future_status::ready; }
 999             ), mFutureBuffers.end()
1000         );
1001     }
1002
1003     auto hasher = std::hash<StringView>();
1004     for(const StringView name : names)
1005     {
1006         // Check if the buffer that's being created already exists
1007         auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
1008             [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
1009             { return hasher(lhs->getName()) < rhs; }
1010         );
1011         if(iter != mBuffers.end() && (*iter)->getName() == name)
1012             continue;
1013
1014         DecoderOrExceptT dec = findDecoder(name);
1015         SharedPtr<Decoder> *decoder = std::get_if<SharedPtr<Decoder>>(&dec);
1016         if(!decoder) continue;
1017
1018         Promise<Buffer> promise;
1019         SharedFuture<Buffer> future = promise.get_future().share();
1020
1021         BufferOrExceptT buf = doCreateBufferAsync(name, iter, std::move(*decoder),
1022                                                   std::move(promise));
1023         Buffer *buffer = std::get_if<Buffer>(&buf);
1024         if(UNLIKELY(!buffer)) continue;
1025
1026         mFutureBuffers.insert(
1027             std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
1028                 [hasher](const PendingBuffer &lhs, size_t rhs) -> bool
1029                 { return hasher(lhs.mBuffer->getName()) < rhs; }
1030             ), { buffer->getHandle(), future }
1031         );
1032     }
1033     mWakeMutex.lock(); mWakeMutex.unlock();
1034     mWakeThread.notify_all();
1035 }
1036
1037 DECL_THUNK2(Buffer, Context, createBufferFrom,, StringView, SharedPtr<Decoder>)
1038 Buffer ContextImpl::createBufferFrom(StringView name, SharedPtr<Decoder>&& decoder)
1039 {
1040     CheckContext(this);
1041
1042     auto hasher = std::hash<StringView>();
1043     auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
1044         [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
1045         { return hasher(lhs->getName()) < rhs; }
1046     );
1047     if(iter != mBuffers.end() && (*iter)->getName() == name)
1048         throw std::runtime_error("Buffer already exists");
1049
1050     BufferOrExceptT ret = doCreateBuffer(name, iter, std::move(decoder));
1051     Buffer *buffer = std::get_if<Buffer>(&ret);
1052     if(UNLIKELY(!buffer))
1053         std::rethrow_exception(std::get<std::exception_ptr>(ret));
1054     return *buffer;
1055 }
1056
1057 DECL_THUNK2(SharedFuture<Buffer>, Context, createBufferAsyncFrom,, StringView, SharedPtr<Decoder>)
1058 SharedFuture<Buffer> ContextImpl::createBufferAsyncFrom(StringView name, SharedPtr<Decoder>&& decoder)
1059 {
1060     SharedFuture<Buffer> future;
1061     CheckContext(this);
1062
1063     if(UNLIKELY(!mFutureBuffers.empty()))
1064     {
1065         // Clear out any fulfilled futures.
1066         mFutureBuffers.erase(
1067             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
1068                 [](const PendingBuffer &entry) -> bool
1069                 { return GetFutureState(entry.mFuture) == std::future_status::ready; }
1070             ), mFutureBuffers.end()
1071         );
1072     }
1073
1074     auto hasher = std::hash<StringView>();
1075     auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
1076         [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
1077         { return hasher(lhs->getName()) < rhs; }
1078     );
1079     if(iter != mBuffers.end() && (*iter)->getName() == name)
1080         throw std::runtime_error("Buffer already exists");
1081
1082     Promise<Buffer> promise;
1083     future = promise.get_future().share();
1084
1085     BufferOrExceptT ret = doCreateBufferAsync(name, iter, std::move(decoder), std::move(promise));
1086     Buffer *buffer = std::get_if<Buffer>(&ret);
1087     if(UNLIKELY(!buffer))
1088         std::rethrow_exception(std::get<std::exception_ptr>(ret));
1089     mWakeMutex.lock(); mWakeMutex.unlock();
1090     mWakeThread.notify_all();
1091
1092     mFutureBuffers.insert(
1093         std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
1094             [hasher](const PendingBuffer &lhs, size_t rhs) -> bool
1095             { return hasher(lhs.mBuffer->getName()) < rhs; }
1096         ), { buffer->getHandle(), future }
1097     );
1098
1099     return future;
1100 }
1101
1102
1103 DECL_THUNK1(Buffer, Context, findBuffer,, StringView)
1104 Buffer ContextImpl::findBuffer(StringView name)
1105 {
1106     Buffer buffer;
1107     CheckContext(this);
1108
1109     auto hasher = std::hash<StringView>();
1110     if(UNLIKELY(!mFutureBuffers.empty()))
1111     {
1112         // If the buffer is already pending for the future, wait for it
1113         auto iter = std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
1114             [hasher](const PendingBuffer &lhs, size_t rhs) -> bool
1115             { return hasher(lhs.mBuffer->getName()) < rhs; }
1116         );
1117         if(iter != mFutureBuffers.end() && iter->mBuffer->getName() == name)
1118         {
1119             buffer = iter->mFuture.get();
1120             mFutureBuffers.erase(iter);
1121         }
1122
1123         // Clear out any completed futures.
1124         mFutureBuffers.erase(
1125             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
1126                 [](const PendingBuffer &entry) -> bool
1127                 { return GetFutureState(entry.mFuture) == std::future_status::ready; }
1128             ), mFutureBuffers.end()
1129         );
1130     }
1131
1132     if(LIKELY(!buffer))
1133     {
1134         auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
1135             [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
1136             { return hasher(lhs->getName()) < rhs; }
1137         );
1138         if(iter != mBuffers.end() && (*iter)->getName() == name)
1139             buffer = Buffer(iter->get());
1140     }
1141     return buffer;
1142 }
1143
1144 DECL_THUNK1(SharedFuture<Buffer>, Context, findBufferAsync,, StringView)
1145 SharedFuture<Buffer> ContextImpl::findBufferAsync(StringView name)
1146 {
1147     SharedFuture<Buffer> future;
1148     CheckContext(this);
1149
1150     auto hasher = std::hash<StringView>();
1151     if(UNLIKELY(!mFutureBuffers.empty()))
1152     {
1153         // Check if the future that's being created already exists
1154         auto iter = std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
1155             [hasher](const PendingBuffer &lhs, size_t rhs) -> bool
1156             { return hasher(lhs.mBuffer->getName()) < rhs; }
1157         );
1158         if(iter != mFutureBuffers.end() && iter->mBuffer->getName() == name)
1159         {
1160             future = iter->mFuture;
1161             if(GetFutureState(future) == std::future_status::ready)
1162                 mFutureBuffers.erase(iter);
1163             return future;
1164         }
1165
1166         // Clear out any fulfilled futures.
1167         mFutureBuffers.erase(
1168             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
1169                 [](const PendingBuffer &entry) -> bool
1170                 { return GetFutureState(entry.mFuture) == std::future_status::ready; }
1171             ), mFutureBuffers.end()
1172         );
1173     }
1174
1175     auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
1176         [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
1177         { return hasher(lhs->getName()) < rhs; }
1178     );
1179     if(iter != mBuffers.end() && (*iter)->getName() == name)
1180     {
1181         // User asked to create a future buffer that's already loaded. Just
1182         // construct a promise, fulfill the promise immediately, then return a
1183         // shared future that's already set.
1184         Promise<Buffer> promise;
1185         promise.set_value(Buffer(iter->get()));
1186         future = promise.get_future().share();
1187     }
1188     return future;
1189 }
1190
1191
1192 DECL_THUNK1(void, Context, removeBuffer,, Buffer)
1193 DECL_THUNK1(void, Context, removeBuffer,, StringView)
1194 void ContextImpl::removeBuffer(StringView name)
1195 {
1196     CheckContext(this);
1197
1198     auto hasher = std::hash<StringView>();
1199     if(UNLIKELY(!mFutureBuffers.empty()))
1200     {
1201         // If the buffer is already pending for the future, wait for it to
1202         // finish before continuing.
1203         auto iter = std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
1204             [hasher](const PendingBuffer &lhs, size_t rhs) -> bool
1205             { return hasher(lhs.mBuffer->getName()) < rhs; }
1206         );
1207         if(iter != mFutureBuffers.end() && iter->mBuffer->getName() == name)
1208         {
1209             iter->mFuture.wait();
1210             mFutureBuffers.erase(iter);
1211         }
1212
1213         // Clear out any completed futures.
1214         mFutureBuffers.erase(
1215             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
1216                 [](const PendingBuffer &entry) -> bool
1217                 { return GetFutureState(entry.mFuture) == std::future_status::ready; }
1218             ), mFutureBuffers.end()
1219         );
1220     }
1221
1222     auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
1223         [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
1224         { return hasher(lhs->getName()) < rhs; }
1225     );
1226     if(iter != mBuffers.end() && (*iter)->getName() == name)
1227     {
1228         // Remove pending sources whose future was waiting for this buffer.
1229         mPendingSources.erase(
1230             std::remove_if(mPendingSources.begin(), mPendingSources.end(),
1231                 [iter](PendingSource &entry) -> bool
1232                 {
1233                     return (GetFutureState(entry.mFuture) == std::future_status::ready &&
1234                             entry.mFuture.get().getHandle() == iter->get());
1235                 }
1236             ), mPendingSources.end()
1237         );
1238         (*iter)->cleanup();
1239         mBuffers.erase(iter);
1240     }
1241 }
1242
1243
1244 ALuint ContextImpl::getSourceId(ALuint maxprio)
1245 {
1246     ALuint id = 0;
1247     if(mSourceIds.empty())
1248     {
1249         alGetError();
1250         alGenSources(1, &id);
1251         if(alGetError() == AL_NO_ERROR)
1252             return id;
1253
1254         SourceImpl *lowest = nullptr;
1255         for(SourceBufferUpdateEntry &entry : mPlaySources)
1256         {
1257             if(!lowest || entry.mSource->getPriority() < lowest->getPriority())
1258                 lowest = entry.mSource;
1259         }
1260         for(SourceStreamUpdateEntry &entry : mStreamSources)
1261         {
1262             if(!lowest || entry.mSource->getPriority() < lowest->getPriority())
1263                 lowest = entry.mSource;
1264         }
1265         if(lowest && lowest->getPriority() < maxprio)
1266         {
1267             lowest->stop();
1268             if(mMessage.get())
1269                 mMessage->sourceForceStopped(lowest);
1270         }
1271     }
1272     if(mSourceIds.empty())
1273         throw std::runtime_error("No available sources");
1274
1275     id = mSourceIds.back();
1276     mSourceIds.pop_back();
1277     return id;
1278 }
1279
1280
1281 DECL_THUNK0(Source, Context, createSource,)
1282 Source ContextImpl::createSource()
1283 {
1284     CheckContext(this);
1285
1286     SourceImpl *source;
1287     if(!mFreeSources.empty())
1288     {
1289         source = mFreeSources.back();
1290         mFreeSources.pop_back();
1291     }
1292     else
1293     {
1294         mAllSources.emplace_back(this);
1295         source = &mAllSources.back();
1296     }
1297     return Source(source);
1298 }
1299
1300
1301 void ContextImpl::addPendingSource(SourceImpl *source, SharedFuture<Buffer> future)
1302 {
1303     auto iter = std::lower_bound(mPendingSources.begin(), mPendingSources.end(), source,
1304         [](const PendingSource &lhs, SourceImpl *rhs) -> bool
1305         { return lhs.mSource < rhs; }
1306     );
1307     if(iter == mPendingSources.end() || iter->mSource != source)
1308         mPendingSources.insert(iter, {source, std::move(future)});
1309 }
1310
1311 void ContextImpl::removePendingSource(SourceImpl *source)
1312 {
1313     auto iter = std::lower_bound(mPendingSources.begin(), mPendingSources.end(), source,
1314         [](const PendingSource &lhs, SourceImpl *rhs) -> bool
1315         { return lhs.mSource < rhs; }
1316     );
1317     if(iter != mPendingSources.end() && iter->mSource == source)
1318         mPendingSources.erase(iter);
1319 }
1320
1321 bool ContextImpl::isPendingSource(const SourceImpl *source) const
1322 {
1323     auto iter = std::lower_bound(mPendingSources.begin(), mPendingSources.end(), source,
1324         [](const PendingSource &lhs, const SourceImpl *rhs) -> bool
1325         { return lhs.mSource < rhs; }
1326     );
1327     return (iter != mPendingSources.end() && iter->mSource == source);
1328 }
1329
1330 void ContextImpl::addFadingSource(SourceImpl *source)
1331 {
1332     auto iter = std::lower_bound(mFadingSources.begin(), mFadingSources.end(), source,
1333         [](SourceImpl *lhs, SourceImpl *rhs) -> bool
1334         { return lhs < rhs; }
1335     );
1336     if(iter == mFadingSources.end() || *iter != source)
1337         mFadingSources.insert(iter, source);
1338 }
1339
1340 void ContextImpl::removeFadingSource(SourceImpl *source)
1341 {
1342     auto iter = std::lower_bound(mFadingSources.begin(), mFadingSources.end(), source,
1343         [](SourceImpl *lhs, SourceImpl *rhs) -> bool
1344         { return lhs < rhs; }
1345     );
1346     if(iter != mFadingSources.end() && *iter == source)
1347         mFadingSources.erase(iter);
1348 }
1349
1350 void ContextImpl::addPlayingSource(SourceImpl *source, ALuint id)
1351 {
1352     auto iter = std::lower_bound(mPlaySources.begin(), mPlaySources.end(), source,
1353         [](const SourceBufferUpdateEntry &lhs, SourceImpl *rhs) -> bool
1354         { return lhs.mSource < rhs; }
1355     );
1356     if(iter == mPlaySources.end() || iter->mSource != source)
1357         mPlaySources.insert(iter, {source,id});
1358 }
1359
1360 void ContextImpl::addPlayingSource(SourceImpl *source)
1361 {
1362     auto iter = std::lower_bound(mStreamSources.begin(), mStreamSources.end(), source,
1363         [](const SourceStreamUpdateEntry &lhs, SourceImpl *rhs) -> bool
1364         { return lhs.mSource < rhs; }
1365     );
1366     if(iter == mStreamSources.end() || iter->mSource != source)
1367         mStreamSources.insert(iter, {source});
1368 }
1369
1370 void ContextImpl::removePlayingSource(SourceImpl *source)
1371 {
1372     auto iter0 = std::lower_bound(mPlaySources.begin(), mPlaySources.end(), source,
1373         [](const SourceBufferUpdateEntry &lhs, SourceImpl *rhs) -> bool
1374         { return lhs.mSource < rhs; }
1375     );
1376     if(iter0 != mPlaySources.end() && iter0->mSource == source)
1377         mPlaySources.erase(iter0);
1378     else
1379     {
1380         auto iter1 = std::lower_bound(mStreamSources.begin(), mStreamSources.end(), source,
1381             [](const SourceStreamUpdateEntry &lhs, SourceImpl *rhs) -> bool
1382             { return lhs.mSource < rhs; }
1383         );
1384         if(iter1 != mStreamSources.end() && iter1->mSource == source)
1385             mStreamSources.erase(iter1);
1386     }
1387 }
1388
1389
1390 void ContextImpl::addStream(SourceImpl *source)
1391 {
1392     std::lock_guard<std::mutex> lock(mSourceStreamMutex);
1393     if(mThread.get_id() == std::thread::id())
1394         mThread = std::thread(std::mem_fn(&ContextImpl::backgroundProc), this);
1395     auto iter = std::lower_bound(mStreamingSources.begin(), mStreamingSources.end(), source);
1396     if(iter == mStreamingSources.end() || *iter != source)
1397         mStreamingSources.insert(iter, source);
1398 }
1399
1400 void ContextImpl::removeStream(SourceImpl *source)
1401 {
1402     std::lock_guard<std::mutex> lock(mSourceStreamMutex);
1403     auto iter = std::lower_bound(mStreamingSources.begin(), mStreamingSources.end(), source);
1404     if(iter != mStreamingSources.end() && *iter == source)
1405         mStreamingSources.erase(iter);
1406 }
1407
1408 void ContextImpl::removeStreamNoLock(SourceImpl *source)
1409 {
1410     auto iter = std::lower_bound(mStreamingSources.begin(), mStreamingSources.end(), source);
1411     if(iter != mStreamingSources.end() && *iter == source)
1412         mStreamingSources.erase(iter);
1413 }
1414
1415
1416 DECL_THUNK0(AuxiliaryEffectSlot, Context, createAuxiliaryEffectSlot,)
1417 AuxiliaryEffectSlot ContextImpl::createAuxiliaryEffectSlot()
1418 {
1419     if(!hasExtension(AL::EXT_EFX) || !alGenAuxiliaryEffectSlots)
1420         throw std::runtime_error("AuxiliaryEffectSlots not supported");
1421     CheckContext(this);
1422
1423     alGetError();
1424     ALuint id = 0;
1425     alGenAuxiliaryEffectSlots(1, &id);
1426     ALenum err = alGetError();
1427     if(err != AL_NO_ERROR)
1428         throw al_error(err, "Failed to create AuxiliaryEffectSlot");
1429     try {
1430         return AuxiliaryEffectSlot(new AuxiliaryEffectSlotImpl(this, id));
1431     }
1432     catch(...) {
1433         alDeleteAuxiliaryEffectSlots(1, &id);
1434         throw;
1435     }
1436 }
1437
1438
1439 DECL_THUNK0(Effect, Context, createEffect,)
1440 Effect ContextImpl::createEffect()
1441 {
1442     if(!hasExtension(AL::EXT_EFX))
1443         throw std::runtime_error("Effects not supported");
1444     CheckContext(this);
1445
1446     alGetError();
1447     ALuint id = 0;
1448     alGenEffects(1, &id);
1449     ALenum err = alGetError();
1450     if(err != AL_NO_ERROR)
1451         throw al_error(err, "Failed to create Effect");
1452     try {
1453         return Effect(new EffectImpl(this, id));
1454     }
1455     catch(...) {
1456         alDeleteEffects(1, &id);
1457         throw;
1458     }
1459 }
1460
1461
1462 DECL_THUNK0(SourceGroup, Context, createSourceGroup,)
1463 SourceGroup ContextImpl::createSourceGroup()
1464 {
1465     auto srcgroup = MakeUnique<SourceGroupImpl>(this);
1466     auto iter = std::lower_bound(mSourceGroups.begin(), mSourceGroups.end(), srcgroup);
1467
1468     iter = mSourceGroups.insert(iter, std::move(srcgroup));
1469     return SourceGroup(iter->get());
1470 }
1471
1472 void ContextImpl::freeSourceGroup(SourceGroupImpl *group)
1473 {
1474     auto iter = std::lower_bound(mSourceGroups.begin(), mSourceGroups.end(), group,
1475         [](const UniquePtr<SourceGroupImpl> &lhs, SourceGroupImpl *rhs) -> bool
1476         { return lhs.get() < rhs; }
1477     );
1478     if(iter != mSourceGroups.end() && iter->get() == group)
1479         mSourceGroups.erase(iter);
1480 }
1481
1482
1483 DECL_THUNK1(void, Context, setDopplerFactor,, ALfloat)
1484 void ContextImpl::setDopplerFactor(ALfloat factor)
1485 {
1486     if(!(factor >= 0.0f))
1487         throw std::out_of_range("Doppler factor out of range");
1488     CheckContext(this);
1489     alDopplerFactor(factor);
1490 }
1491
1492
1493 DECL_THUNK1(void, Context, setSpeedOfSound,, ALfloat)
1494 void ContextImpl::setSpeedOfSound(ALfloat speed)
1495 {
1496     if(!(speed > 0.0f))
1497         throw std::out_of_range("Speed of sound out of range");
1498     CheckContext(this);
1499     alSpeedOfSound(speed);
1500 }
1501
1502
1503 DECL_THUNK1(void, Context, setDistanceModel,, DistanceModel)
1504 void ContextImpl::setDistanceModel(DistanceModel model)
1505 {
1506     CheckContext(this);
1507     alDistanceModel((ALenum)model);
1508 }
1509
1510
1511 DECL_THUNK0(void, Context, update,)
1512 void ContextImpl::update()
1513 {
1514     CheckContext(this);
1515     mPendingSources.erase(
1516         std::remove_if(mPendingSources.begin(), mPendingSources.end(),
1517             [](PendingSource &entry) -> bool
1518             { return !entry.mSource->checkPending(entry.mFuture); }
1519         ), mPendingSources.end()
1520     );
1521     if(!mFadingSources.empty())
1522     {
1523         auto cur_time = std::chrono::steady_clock::now();
1524         mFadingSources.erase(
1525             std::remove_if(mFadingSources.begin(), mFadingSources.end(),
1526                 [cur_time](SourceImpl *source) -> bool
1527                 { return !source->fadeUpdate(cur_time); }
1528             ), mFadingSources.end()
1529         );
1530     }
1531     mPlaySources.erase(
1532         std::remove_if(mPlaySources.begin(), mPlaySources.end(),
1533             [](const SourceBufferUpdateEntry &entry) -> bool
1534             { return !entry.mSource->playUpdate(entry.mId); }
1535         ), mPlaySources.end()
1536     );
1537     mStreamSources.erase(
1538         std::remove_if(mStreamSources.begin(), mStreamSources.end(),
1539             [](const SourceStreamUpdateEntry &entry) -> bool
1540             { return !entry.mSource->playUpdate(); }
1541         ), mStreamSources.end()
1542     );
1543
1544     if(!mWakeInterval.load(std::memory_order_relaxed).count())
1545     {
1546         // For performance reasons, don't wait for the thread's mutex. This
1547         // should be called often enough to keep up with any and all streams
1548         // regardless.
1549         mWakeThread.notify_all();
1550     }
1551
1552     if(hasExtension(AL::EXT_disconnect) && mIsConnected)
1553     {
1554         ALCint connected;
1555         alcGetIntegerv(mDevice->getALCdevice(), ALC_CONNECTED, 1, &connected);
1556         mIsConnected = connected;
1557         if(!connected && mMessage.get()) mMessage->deviceDisconnected(Device(mDevice));
1558     }
1559 }
1560
1561 DECL_THUNK0(Device, Context, getDevice,)
1562 DECL_THUNK0(std::chrono::milliseconds, Context, getAsyncWakeInterval, const)
1563 DECL_THUNK0(Listener, Context, getListener,)
1564 DECL_THUNK0(SharedPtr<MessageHandler>, Context, getMessageHandler, const)
1565
1566 void Context::MakeCurrent(Context context)
1567 { ContextImpl::MakeCurrent(context.pImpl); }
1568
1569 Context Context::GetCurrent()
1570 { return Context(ContextImpl::GetCurrent()); }
1571
1572 void Context::MakeThreadCurrent(Context context)
1573 { ContextImpl::MakeThreadCurrent(context.pImpl); }
1574
1575 Context Context::GetThreadCurrent()
1576 { return Context(ContextImpl::GetThreadCurrent()); }
1577
1578
1579 DECL_THUNK1(void, Listener, setGain,, ALfloat)
1580 void ListenerImpl::setGain(ALfloat gain)
1581 {
1582     if(!(gain >= 0.0f))
1583         throw std::out_of_range("Gain out of range");
1584     CheckContext(mContext);
1585     alListenerf(AL_GAIN, gain);
1586 }
1587
1588
1589 DECL_THUNK3(void, Listener, set3DParameters,, const Vector3&, const Vector3&, const Vector3Pair&)
1590 void ListenerImpl::set3DParameters(const Vector3 &position, const Vector3 &velocity, const std::pair<Vector3,Vector3> &orientation)
1591 {
1592     static_assert(sizeof(orientation) == sizeof(ALfloat[6]), "Invalid Vector3 pair size");
1593     CheckContext(mContext);
1594     Batcher batcher = mContext->getBatcher();
1595     alListenerfv(AL_POSITION, position.getPtr());
1596     alListenerfv(AL_VELOCITY, velocity.getPtr());
1597     alListenerfv(AL_ORIENTATION, orientation.first.getPtr());
1598 }
1599
1600 DECL_THUNK3(void, Listener, setPosition,, ALfloat, ALfloat, ALfloat)
1601 void ListenerImpl::setPosition(ALfloat x, ALfloat y, ALfloat z)
1602 {
1603     CheckContext(mContext);
1604     alListener3f(AL_POSITION, x, y, z);
1605 }
1606
1607 DECL_THUNK1(void, Listener, setPosition,, const ALfloat*)
1608 void ListenerImpl::setPosition(const ALfloat *pos)
1609 {
1610     CheckContext(mContext);
1611     alListenerfv(AL_POSITION, pos);
1612 }
1613
1614 DECL_THUNK3(void, Listener, setVelocity,, ALfloat, ALfloat, ALfloat)
1615 void ListenerImpl::setVelocity(ALfloat x, ALfloat y, ALfloat z)
1616 {
1617     CheckContext(mContext);
1618     alListener3f(AL_VELOCITY, x, y, z);
1619 }
1620
1621 DECL_THUNK1(void, Listener, setVelocity,, const ALfloat*)
1622 void ListenerImpl::setVelocity(const ALfloat *vel)
1623 {
1624     CheckContext(mContext);
1625     alListenerfv(AL_VELOCITY, vel);
1626 }
1627
1628 DECL_THUNK6(void, Listener, setOrientation,, ALfloat, ALfloat, ALfloat, ALfloat, ALfloat, ALfloat)
1629 void ListenerImpl::setOrientation(ALfloat x1, ALfloat y1, ALfloat z1, ALfloat x2, ALfloat y2, ALfloat z2)
1630 {
1631     CheckContext(mContext);
1632     ALfloat ori[6] = { x1, y1, z1, x2, y2, z2 };
1633     alListenerfv(AL_ORIENTATION, ori);
1634 }
1635
1636 DECL_THUNK2(void, Listener, setOrientation,, const ALfloat*, const ALfloat*)
1637 void ListenerImpl::setOrientation(const ALfloat *at, const ALfloat *up)
1638 {
1639     CheckContext(mContext);
1640     ALfloat ori[6] = { at[0], at[1], at[2], up[0], up[1], up[2] };
1641     alListenerfv(AL_ORIENTATION, ori);
1642 }
1643
1644 DECL_THUNK1(void, Listener, setOrientation,, const ALfloat*)
1645 void ListenerImpl::setOrientation(const ALfloat *ori)
1646 {
1647     CheckContext(mContext);
1648     alListenerfv(AL_ORIENTATION, ori);
1649 }
1650
1651 DECL_THUNK1(void, Listener, setMetersPerUnit,, ALfloat)
1652 void ListenerImpl::setMetersPerUnit(ALfloat m_u)
1653 {
1654     if(!(m_u > 0.0f))
1655         throw std::out_of_range("Invalid meters per unit");
1656     CheckContext(mContext);
1657     if(mContext->hasExtension(AL::EXT_EFX))
1658         alListenerf(AL_METERS_PER_UNIT, m_u);
1659 }
1660
1661 }