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::StringView name, alure::UniquePtr<std::istream> &file,
 255                                    T start, T end)
 256 {
 257     alure::DecoderOrExceptT ret;
 258     while(start != end)
 259     {
 260         alure::DecoderFactory *factory = start->second.get();
 261         auto decoder = factory->createDecoder(file);
 262         if(decoder) return (ret = std::move(decoder));
 263
 264         if(!file || !(file->clear(),file->seekg(0)))
 265             return (ret = std::runtime_error("Failed to rewind "+name+" for the next decoder factory"));
 266
 267         ++start;
 268     }
 269
 270     return (ret = nullptr);
 271 }
 272
 273 static alure::DecoderOrExceptT GetDecoder(alure::StringView name, alure::UniquePtr<std::istream> file)
 274 {
 275     auto decoder = GetDecoder(name, file, sDecoders.begin(), sDecoders.end());
 276     if(std::holds_alternative<std::runtime_error>(decoder)) return decoder;
 277     if(std::get<alure::SharedPtr<alure::Decoder>>(decoder)) return decoder;
 278     decoder = GetDecoder(name, file, std::begin(sDefaultDecoders), std::end(sDefaultDecoders));
 279     if(std::holds_alternative<std::runtime_error>(decoder)) return decoder;
 280     if(std::get<alure::SharedPtr<alure::Decoder>>(decoder)) return decoder;
 281     return (decoder = std::runtime_error("No decoder for "+name));
 282 }
 283
 284 class DefaultFileIOFactory final : public alure::FileIOFactory {
 285     alure::UniquePtr<std::istream> openFile(const alure::String &name) override
 286     {
 287 #ifdef _WIN32
 288         auto file = alure::MakeUnique<Stream>(name.c_str());
 289 #else
 290         auto file = alure::MakeUnique<std::ifstream>(name.c_str(), std::ios::binary);
 291 #endif
 292         if(!file->is_open()) file = nullptr;
 293         return std::move(file);
 294     }
 295 };
 296 DefaultFileIOFactory sDefaultFileFactory;
 297
 298 alure::UniquePtr<alure::FileIOFactory> sFileFactory;
 299
 300 }
 301
 302 namespace alure
 303 {
 304
 305 Decoder::~Decoder() { }
 306 DecoderFactory::~DecoderFactory() { }
 307
 308 void RegisterDecoder(StringView name, UniquePtr<DecoderFactory> factory)
 309 {
 310     auto iter = std::lower_bound(sDecoders.begin(), sDecoders.end(), name,
 311         [](const DecoderEntryPair &entry, StringView rhs) -> bool
 312         { return entry.first < rhs; }
 313     );
 314     if(iter != sDecoders.end())
 315         throw std::runtime_error("Decoder factory \""+name+"\" already registered");
 316     sDecoders.insert(iter, std::make_pair(String(name), std::move(factory)));
 317 }
 318
 319 UniquePtr<DecoderFactory> UnregisterDecoder(StringView name)
 320 {
 321     auto iter = std::lower_bound(sDecoders.begin(), sDecoders.end(), name,
 322         [](const DecoderEntryPair &entry, StringView rhs) -> bool
 323         { return entry.first < rhs; }
 324     );
 325     if(iter != sDecoders.end())
 326     {
 327         UniquePtr<DecoderFactory> factory = std::move(iter->second);
 328         sDecoders.erase(iter);
 329         return factory;
 330     }
 331     return nullptr;
 332 }
 333
 334
 335 FileIOFactory::~FileIOFactory() { }
 336
 337 UniquePtr<FileIOFactory> FileIOFactory::set(UniquePtr<FileIOFactory> factory)
 338 {
 339     std::swap(sFileFactory, factory);
 340     return factory;
 341 }
 342
 343 FileIOFactory &FileIOFactory::get()
 344 {
 345     FileIOFactory *factory = sFileFactory.get();
 346     if(factory) return *factory;
 347     return sDefaultFileFactory;
 348 }
 349
 350
 351 // Default message handler methods are no-ops.
 352 MessageHandler::~MessageHandler()
 353 {
 354 }
 355
 356 void MessageHandler::deviceDisconnected(Device)
 357 {
 358 }
 359
 360 void MessageHandler::sourceStopped(Source)
 361 {
 362 }
 363
 364 void MessageHandler::sourceForceStopped(Source)
 365 {
 366 }
 367
 368 void MessageHandler::bufferLoading(StringView, ChannelConfig, SampleType, ALuint, ArrayView<ALbyte>)
 369 {
 370 }
 371
 372 String MessageHandler::resourceNotFound(StringView)
 373 {
 374     return String();
 375 }
 376
 377
 378 template<typename T>
 379 static inline void LoadALFunc(T **func, const char *name)
 380 { *func = reinterpret_cast<T*>(alGetProcAddress(name)); }
 381
 382 static void LoadNothing(ContextImpl*) { }
 383
 384 static void LoadEFX(ContextImpl *ctx)
 385 {
 386     LoadALFunc(&ctx->alGenEffects,    "alGenEffects");
 387     LoadALFunc(&ctx->alDeleteEffects, "alDeleteEffects");
 388     LoadALFunc(&ctx->alIsEffect,      "alIsEffect");
 389     LoadALFunc(&ctx->alEffecti,       "alEffecti");
 390     LoadALFunc(&ctx->alEffectiv,      "alEffectiv");
 391     LoadALFunc(&ctx->alEffectf,       "alEffectf");
 392     LoadALFunc(&ctx->alEffectfv,      "alEffectfv");
 393     LoadALFunc(&ctx->alGetEffecti,    "alGetEffecti");
 394     LoadALFunc(&ctx->alGetEffectiv,   "alGetEffectiv");
 395     LoadALFunc(&ctx->alGetEffectf,    "alGetEffectf");
 396     LoadALFunc(&ctx->alGetEffectfv,   "alGetEffectfv");
 397
 398     LoadALFunc(&ctx->alGenFilters,    "alGenFilters");
 399     LoadALFunc(&ctx->alDeleteFilters, "alDeleteFilters");
 400     LoadALFunc(&ctx->alIsFilter,      "alIsFilter");
 401     LoadALFunc(&ctx->alFilteri,       "alFilteri");
 402     LoadALFunc(&ctx->alFilteriv,      "alFilteriv");
 403     LoadALFunc(&ctx->alFilterf,       "alFilterf");
 404     LoadALFunc(&ctx->alFilterfv,      "alFilterfv");
 405     LoadALFunc(&ctx->alGetFilteri,    "alGetFilteri");
 406     LoadALFunc(&ctx->alGetFilteriv,   "alGetFilteriv");
 407     LoadALFunc(&ctx->alGetFilterf,    "alGetFilterf");
 408     LoadALFunc(&ctx->alGetFilterfv,   "alGetFilterfv");
 409
 410     LoadALFunc(&ctx->alGenAuxiliaryEffectSlots,    "alGenAuxiliaryEffectSlots");
 411     LoadALFunc(&ctx->alDeleteAuxiliaryEffectSlots, "alDeleteAuxiliaryEffectSlots");
 412     LoadALFunc(&ctx->alIsAuxiliaryEffectSlot,      "alIsAuxiliaryEffectSlot");
 413     LoadALFunc(&ctx->alAuxiliaryEffectSloti,       "alAuxiliaryEffectSloti");
 414     LoadALFunc(&ctx->alAuxiliaryEffectSlotiv,      "alAuxiliaryEffectSlotiv");
 415     LoadALFunc(&ctx->alAuxiliaryEffectSlotf,       "alAuxiliaryEffectSlotf");
 416     LoadALFunc(&ctx->alAuxiliaryEffectSlotfv,      "alAuxiliaryEffectSlotfv");
 417     LoadALFunc(&ctx->alGetAuxiliaryEffectSloti,    "alGetAuxiliaryEffectSloti");
 418     LoadALFunc(&ctx->alGetAuxiliaryEffectSlotiv,   "alGetAuxiliaryEffectSlotiv");
 419     LoadALFunc(&ctx->alGetAuxiliaryEffectSlotf,    "alGetAuxiliaryEffectSlotf");
 420     LoadALFunc(&ctx->alGetAuxiliaryEffectSlotfv,   "alGetAuxiliaryEffectSlotfv");
 421 }
 422
 423 static void LoadSourceResampler(ContextImpl *ctx)
 424 {
 425     LoadALFunc(&ctx->alGetStringiSOFT, "alGetStringiSOFT");
 426 }
 427
 428 static void LoadSourceLatency(ContextImpl *ctx)
 429 {
 430     LoadALFunc(&ctx->alGetSourcei64vSOFT, "alGetSourcei64vSOFT");
 431     LoadALFunc(&ctx->alGetSourcedvSOFT, "alGetSourcedvSOFT");
 432 }
 433
 434 static const struct {
 435     enum AL extension;
 436     const char name[32];
 437     void (&loader)(ContextImpl*);
 438 } ALExtensionList[] = {
 439     { AL::EXT_EFX, "ALC_EXT_EFX", LoadEFX },
 440
 441     { AL::EXT_FLOAT32,   "AL_EXT_FLOAT32",   LoadNothing },
 442     { AL::EXT_MCFORMATS, "AL_EXT_MCFORMATS", LoadNothing },
 443     { AL::EXT_BFORMAT,   "AL_EXT_BFORMAT",   LoadNothing },
 444
 445     { AL::EXT_MULAW,           "AL_EXT_MULAW",           LoadNothing },
 446     { AL::EXT_MULAW_MCFORMATS, "AL_EXT_MULAW_MCFORMATS", LoadNothing },
 447     { AL::EXT_MULAW_BFORMAT,   "AL_EXT_MULAW_BFORMAT",   LoadNothing },
 448
 449     { AL::SOFT_loop_points,       "AL_SOFT_loop_points",       LoadNothing },
 450     { AL::SOFT_source_latency,    "AL_SOFT_source_latency",    LoadSourceLatency },
 451     { AL::SOFT_source_resampler,  "AL_SOFT_source_resampler",  LoadSourceResampler },
 452     { AL::SOFT_source_spatialize, "AL_SOFT_source_spatialize", LoadNothing },
 453
 454     { AL::EXT_disconnect, "ALC_EXT_disconnect", LoadNothing },
 455
 456     { AL::EXT_SOURCE_RADIUS, "AL_EXT_SOURCE_RADIUS", LoadNothing },
 457     { AL::EXT_STEREO_ANGLES, "AL_EXT_STEREO_ANGLES", LoadNothing },
 458 };
 459
 460
 461 ContextImpl *ContextImpl::sCurrentCtx = nullptr;
 462 thread_local ContextImpl *ContextImpl::sThreadCurrentCtx = nullptr;
 463
 464 std::atomic<uint64_t> ContextImpl::sContextSetCount{0};
 465
 466 void ContextImpl::MakeCurrent(ContextImpl *context)
 467 {
 468     std::unique_lock<std::mutex> ctxlock(mGlobalCtxMutex);
 469
 470     if(alcMakeContextCurrent(context ? context->getALCcontext() : nullptr) == ALC_FALSE)
 471         throw std::runtime_error("Call to alcMakeContextCurrent failed");
 472     if(context)
 473     {
 474         context->addRef();
 475         std::call_once(context->mSetExts, std::mem_fn(&ContextImpl::setupExts), context);
 476     }
 477     std::swap(sCurrentCtx, context);
 478     if(context) context->decRef();
 479
 480     if(sThreadCurrentCtx)
 481         sThreadCurrentCtx->decRef();
 482     sThreadCurrentCtx = nullptr;
 483     sContextSetCount.fetch_add(1, std::memory_order_release);
 484
 485     if((context = sCurrentCtx) != nullptr)
 486     {
 487         ctxlock.unlock();
 488         context->mWakeThread.notify_all();
 489     }
 490 }
 491
 492 void ContextImpl::MakeThreadCurrent(ContextImpl *context)
 493 {
 494     if(!DeviceManagerImpl::SetThreadContext)
 495         throw std::runtime_error("Thread-local contexts unsupported");
 496     if(DeviceManagerImpl::SetThreadContext(context ? context->getALCcontext() : nullptr) == ALC_FALSE)
 497         throw std::runtime_error("Call to alcSetThreadContext failed");
 498     if(context)
 499     {
 500         context->addRef();
 501         std::call_once(context->mSetExts, std::mem_fn(&ContextImpl::setupExts), context);
 502     }
 503     if(sThreadCurrentCtx)
 504         sThreadCurrentCtx->decRef();
 505     sThreadCurrentCtx = context;
 506     sContextSetCount.fetch_add(1, std::memory_order_release);
 507 }
 508
 509 void ContextImpl::setupExts()
 510 {
 511     ALCdevice *device = mDevice->getALCdevice();
 512     mHasExt.clear();
 513     for(const auto &entry : ALExtensionList)
 514     {
 515         if((strncmp(entry.name, "ALC", 3) == 0) ? alcIsExtensionPresent(device, entry.name) :
 516                                                   alIsExtensionPresent(entry.name))
 517         {
 518             mHasExt.set(static_cast<size_t>(entry.extension));
 519             entry.loader(this);
 520         }
 521     }
 522 }
 523
 524
 525 void ContextImpl::backgroundProc()
 526 {
 527     if(DeviceManagerImpl::SetThreadContext && mDevice->hasExtension(ALC::EXT_thread_local_context))
 528         DeviceManagerImpl::SetThreadContext(getALCcontext());
 529
 530     std::chrono::steady_clock::time_point basetime = std::chrono::steady_clock::now();
 531     std::chrono::milliseconds waketime(0);
 532     std::unique_lock<std::mutex> ctxlock(mGlobalCtxMutex);
 533     while(!mQuitThread.load(std::memory_order_acquire))
 534     {
 535         {
 536             std::lock_guard<std::mutex> srclock(mSourceStreamMutex);
 537             mStreamingSources.erase(
 538                 std::remove_if(mStreamingSources.begin(), mStreamingSources.end(),
 539                     [](SourceImpl *source) -> bool
 540                     { return !source->updateAsync(); }
 541                 ), mStreamingSources.end()
 542             );
 543         }
 544
 545         // Only do one pending buffer at a time. In case there's several large
 546         // buffers to load, we still need to process streaming sources so they
 547         // don't underrun.
 548         PendingBuffer *lastpb = mPendingCurrent.load(std::memory_order_acquire);
 549         if(PendingBuffer *pb = lastpb->mNext.load(std::memory_order_relaxed))
 550         {
 551             pb->mBuffer->load(pb->mFrames, pb->mFormat, std::move(pb->mDecoder), this);
 552             pb->mPromise.set_value(Buffer(pb->mBuffer));
 553             Promise<Buffer>().swap(pb->mPromise);
 554             mPendingCurrent.store(pb, std::memory_order_release);
 555             continue;
 556         }
 557
 558         std::unique_lock<std::mutex> wakelock(mWakeMutex);
 559         if(!mQuitThread.load(std::memory_order_acquire) && lastpb->mNext.load(std::memory_order_acquire) == nullptr)
 560         {
 561             ctxlock.unlock();
 562
 563             std::chrono::milliseconds interval = mWakeInterval.load(std::memory_order_relaxed);
 564             if(interval.count() == 0)
 565                 mWakeThread.wait(wakelock);
 566             else
 567             {
 568                 auto now = std::chrono::steady_clock::now() - basetime;
 569                 if(now > waketime)
 570                 {
 571                     auto mult = (now-waketime + interval-std::chrono::milliseconds(1)) / interval;
 572                     waketime += interval * mult;
 573                 }
 574                 mWakeThread.wait_until(wakelock, waketime + basetime);
 575             }
 576             wakelock.unlock();
 577
 578             ctxlock.lock();
 579             while(!mQuitThread.load(std::memory_order_acquire) &&
 580                   alcGetCurrentContext() != getALCcontext())
 581                 mWakeThread.wait(ctxlock);
 582         }
 583     }
 584     ctxlock.unlock();
 585
 586     if(DeviceManagerImpl::SetThreadContext)
 587         DeviceManagerImpl::SetThreadContext(nullptr);
 588 }
 589
 590
 591 ContextImpl::ContextImpl(ALCcontext *context, DeviceImpl *device)
 592   : mContextSetCounter(std::numeric_limits<uint64_t>::max()),
 593     mListener(this), mContext(context), mDevice(device),
 594     mWakeInterval(std::chrono::milliseconds::zero()), mQuitThread(false),
 595     mRefs(0), mIsConnected(true), mIsBatching(false),
 596     alGetSourcei64vSOFT(0), alGetSourcedvSOFT(0),
 597     alGenEffects(0), alDeleteEffects(0), alIsEffect(0),
 598     alEffecti(0), alEffectiv(0), alEffectf(0), alEffectfv(0),
 599     alGetEffecti(0), alGetEffectiv(0), alGetEffectf(0), alGetEffectfv(0),
 600     alGenFilters(0), alDeleteFilters(0), alIsFilter(0),
 601     alFilteri(0), alFilteriv(0), alFilterf(0), alFilterfv(0),
 602     alGetFilteri(0), alGetFilteriv(0), alGetFilterf(0), alGetFilterfv(0),
 603     alGenAuxiliaryEffectSlots(0), alDeleteAuxiliaryEffectSlots(0), alIsAuxiliaryEffectSlot(0),
 604     alAuxiliaryEffectSloti(0), alAuxiliaryEffectSlotiv(0), alAuxiliaryEffectSlotf(0), alAuxiliaryEffectSlotfv(0),
 605     alGetAuxiliaryEffectSloti(0), alGetAuxiliaryEffectSlotiv(0), alGetAuxiliaryEffectSlotf(0), alGetAuxiliaryEffectSlotfv(0)
 606 {
 607     mHasExt.clear();
 608     mPendingHead = new PendingBuffer;
 609     mPendingCurrent.store(mPendingHead, std::memory_order_relaxed);
 610     mPendingTail = mPendingHead;
 611 }
 612
 613 ContextImpl::~ContextImpl()
 614 {
 615     PendingBuffer *pb = mPendingTail;
 616     while(pb)
 617     {
 618         PendingBuffer *next = pb->mNext.load(std::memory_order_relaxed);
 619         delete pb;
 620         pb = next;
 621     }
 622     mPendingCurrent.store(nullptr, std::memory_order_relaxed);
 623     mPendingHead = nullptr;
 624     mPendingTail = nullptr;
 625 }
 626
 627
 628 void ContextImpl::destroy()
 629 {
 630     if(mRefs != 0)
 631         throw std::runtime_error("Context is in use");
 632     if(!mBuffers.empty())
 633         throw std::runtime_error("Trying to destroy a context with buffers");
 634
 635     if(mThread.joinable())
 636     {
 637         std::unique_lock<std::mutex> lock(mWakeMutex);
 638         mQuitThread.store(true, std::memory_order_release);
 639         lock.unlock();
 640         mWakeThread.notify_all();
 641         mThread.join();
 642     }
 643
 644     alcDestroyContext(mContext);
 645     mContext = nullptr;
 646
 647     mDevice->removeContext(this);
 648 }
 649
 650
 651 void ContextImpl::startBatch()
 652 {
 653     alcSuspendContext(mContext);
 654     mIsBatching = true;
 655 }
 656
 657 void ContextImpl::endBatch()
 658 {
 659     alcProcessContext(mContext);
 660     mIsBatching = false;
 661 }
 662
 663
 664 SharedPtr<MessageHandler> ContextImpl::setMessageHandler(SharedPtr<MessageHandler>&& handler)
 665 {
 666     std::lock_guard<std::mutex> lock(mGlobalCtxMutex);
 667     mMessage.swap(handler);
 668     return handler;
 669 }
 670
 671
 672 void ContextImpl::setAsyncWakeInterval(std::chrono::milliseconds interval)
 673 {
 674     if(interval.count() < 0 || interval > std::chrono::seconds(1))
 675         throw std::runtime_error("Async wake interval out of range");
 676     mWakeInterval.store(interval);
 677     mWakeMutex.lock(); mWakeMutex.unlock();
 678     mWakeThread.notify_all();
 679 }
 680
 681
 682 DecoderOrExceptT ContextImpl::findDecoder(StringView name)
 683 {
 684     DecoderOrExceptT ret;
 685
 686     String oldname = String(name);
 687     auto file = FileIOFactory::get().openFile(oldname);
 688     if(file) return (ret = GetDecoder(name, std::move(file)));
 689
 690     // Resource not found. Try to find a substitute.
 691     if(!mMessage.get()) return (ret = std::runtime_error("Failed to open "+oldname));
 692     do {
 693         String newname(mMessage->resourceNotFound(oldname));
 694         if(newname.empty())
 695             return (ret = std::runtime_error("Failed to open "+oldname));
 696         file = FileIOFactory::get().openFile(newname);
 697         oldname = std::move(newname);
 698     } while(!file);
 699
 700     return (ret = GetDecoder(oldname, std::move(file)));
 701 }
 702
 703 SharedPtr<Decoder> ContextImpl::createDecoder(StringView name)
 704 {
 705     CheckContext(this);
 706     DecoderOrExceptT dec = findDecoder(name);
 707     if(SharedPtr<Decoder> *decoder = std::get_if<SharedPtr<Decoder>>(&dec))
 708         return *decoder;
 709     throw std::get<std::runtime_error>(dec);
 710 }
 711
 712
 713 bool ContextImpl::isSupported(ChannelConfig channels, SampleType type) const
 714 {
 715     CheckContext(this);
 716     return GetFormat(channels, type) != AL_NONE;
 717 }
 718
 719
 720 ArrayView<String> ContextImpl::getAvailableResamplers()
 721 {
 722     CheckContext(this);
 723     if(mResamplers.empty() && hasExtension(AL::SOFT_source_resampler))
 724     {
 725         ALint num_resamplers = alGetInteger(AL_NUM_RESAMPLERS_SOFT);
 726         mResamplers.reserve(num_resamplers);
 727         for(int i = 0;i < num_resamplers;i++)
 728             mResamplers.emplace_back(alGetStringiSOFT(AL_RESAMPLER_NAME_SOFT, i));
 729         if(mResamplers.empty())
 730             mResamplers.emplace_back();
 731     }
 732     return mResamplers;
 733 }
 734
 735 ALsizei ContextImpl::getDefaultResamplerIndex() const
 736 {
 737     CheckContext(this);
 738     if(!hasExtension(AL::SOFT_source_resampler))
 739         return 0;
 740     return alGetInteger(AL_DEFAULT_RESAMPLER_SOFT);
 741 }
 742
 743
 744 BufferOrExceptT ContextImpl::doCreateBuffer(StringView name, Vector<UniquePtr<BufferImpl>>::iterator iter, SharedPtr<Decoder> decoder)
 745 {
 746     BufferOrExceptT retval;
 747     ALuint srate = decoder->getFrequency();
 748     ChannelConfig chans = decoder->getChannelConfig();
 749     SampleType type = decoder->getSampleType();
 750     ALuint frames = decoder->getLength();
 751
 752     Vector<ALbyte> data(FramesToBytes(frames, chans, type));
 753     frames = decoder->read(data.data(), frames);
 754     if(!frames) return (retval = std::runtime_error("No samples for buffer"));
 755     data.resize(FramesToBytes(frames, chans, type));
 756
 757     std::pair<uint64_t,uint64_t> loop_pts = decoder->getLoopPoints();
 758     if(loop_pts.first >= loop_pts.second)
 759         loop_pts = std::make_pair(0, frames);
 760     else
 761     {
 762         loop_pts.second = std::min<uint64_t>(loop_pts.second, frames);
 763         loop_pts.first = std::min<uint64_t>(loop_pts.first, loop_pts.second-1);
 764     }
 765
 766     // Get the format before calling the bufferLoading message handler, to
 767     // ensure it's something OpenAL can handle.
 768     ALenum format = GetFormat(chans, type);
 769     if(format == AL_NONE)
 770     {
 771         std::stringstream sstr;
 772         sstr<< "Format not supported ("<<GetSampleTypeName(type)<<", "<<GetChannelConfigName(chans)<<")";
 773         return (retval = std::runtime_error(sstr.str()));
 774     }
 775
 776     if(mMessage.get())
 777         mMessage->bufferLoading(name, chans, type, srate, data);
 778
 779     alGetError();
 780     ALuint bid = 0;
 781     alGenBuffers(1, &bid);
 782     alBufferData(bid, format, data.data(), data.size(), srate);
 783     if(hasExtension(AL::SOFT_loop_points))
 784     {
 785         ALint pts[2]{(ALint)loop_pts.first, (ALint)loop_pts.second};
 786         alBufferiv(bid, AL_LOOP_POINTS_SOFT, pts);
 787     }
 788     if(alGetError() != AL_NO_ERROR)
 789     {
 790         alDeleteBuffers(1, &bid);
 791         return (retval = std::runtime_error("Failed to buffer data"));
 792     }
 793
 794     return (retval = mBuffers.insert(iter,
 795         MakeUnique<BufferImpl>(this, bid, srate, chans, type, name)
 796     )->get());
 797 }
 798
 799 BufferOrExceptT ContextImpl::doCreateBufferAsync(StringView name, Vector<UniquePtr<BufferImpl>>::iterator iter, SharedPtr<Decoder> decoder, Promise<Buffer> promise)
 800 {
 801     BufferOrExceptT retval;
 802     ALuint srate = decoder->getFrequency();
 803     ChannelConfig chans = decoder->getChannelConfig();
 804     SampleType type = decoder->getSampleType();
 805     ALuint frames = decoder->getLength();
 806     if(!frames) return (retval = std::runtime_error("No samples for buffer"));
 807
 808     ALenum format = GetFormat(chans, type);
 809     if(format == AL_NONE)
 810     {
 811         std::stringstream sstr;
 812         sstr<< "Format not supported ("<<GetSampleTypeName(type)<<", "<<GetChannelConfigName(chans)<<")";
 813         return (retval = std::runtime_error(sstr.str()));
 814     }
 815
 816     alGetError();
 817     ALuint bid = 0;
 818     alGenBuffers(1, &bid);
 819     if(alGetError() != AL_NO_ERROR)
 820         return (retval = std::runtime_error("Failed to create buffer"));
 821
 822     auto buffer = MakeUnique<BufferImpl>(this, bid, srate, chans, type, name);
 823
 824     if(mThread.get_id() == std::thread::id())
 825         mThread = std::thread(std::mem_fn(&ContextImpl::backgroundProc), this);
 826
 827     PendingBuffer *pb = nullptr;
 828     if(mPendingTail == mPendingCurrent.load(std::memory_order_acquire))
 829         pb = new PendingBuffer{buffer.get(), decoder, format, frames, std::move(promise)};
 830     else
 831     {
 832         pb = mPendingTail;
 833         pb->mBuffer = buffer.get();
 834         pb->mDecoder = decoder;
 835         pb->mFormat = format;
 836         pb->mFrames = frames;
 837         pb->mPromise = std::move(promise);
 838         mPendingTail = pb->mNext.exchange(nullptr, std::memory_order_relaxed);
 839     }
 840
 841     mPendingHead->mNext.store(pb, std::memory_order_release);
 842     mPendingHead = pb;
 843
 844     return (retval = mBuffers.insert(iter, std::move(buffer))->get());
 845 }
 846
 847 Buffer ContextImpl::getBuffer(StringView name)
 848 {
 849     CheckContext(this);
 850
 851     auto hasher = std::hash<StringView>();
 852     if(UNLIKELY(!mFutureBuffers.empty()))
 853     {
 854         Buffer buffer;
 855
 856         // If the buffer is already pending for the future, wait for it
 857         auto iter = std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
 858             [hasher](const PendingFuture &lhs, size_t rhs) -> bool
 859             { return hasher(lhs.mBuffer->getName()) < rhs; }
 860         );
 861         if(iter != mFutureBuffers.end() && iter->mBuffer->getName() == name)
 862         {
 863             buffer = iter->mFuture.get();
 864             mFutureBuffers.erase(iter);
 865         }
 866
 867         // Clear out any completed futures.
 868         mFutureBuffers.erase(
 869             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
 870                 [](const PendingFuture &entry) -> bool
 871                 { return entry.mFuture.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready; }
 872             ), mFutureBuffers.end()
 873         );
 874
 875         // If we got the buffer, return it. Otherwise, go load it normally.
 876         if(buffer) return buffer;
 877     }
 878
 879     auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
 880         [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
 881         { return hasher(lhs->getName()) < rhs; }
 882     );
 883     if(iter != mBuffers.end() && (*iter)->getName() == name)
 884         return Buffer(iter->get());
 885
 886     BufferOrExceptT ret = doCreateBuffer(name, iter, createDecoder(name));
 887     Buffer *buffer = std::get_if<Buffer>(&ret);
 888     if(UNLIKELY(!buffer))
 889         throw std::get<std::runtime_error>(ret);
 890     return *buffer;
 891 }
 892
 893 SharedFuture<Buffer> ContextImpl::getBufferAsync(StringView name)
 894 {
 895     SharedFuture<Buffer> future;
 896     CheckContext(this);
 897
 898     auto hasher = std::hash<StringView>();
 899     if(UNLIKELY(!mFutureBuffers.empty()))
 900     {
 901         // Check if the future that's being created already exists
 902         auto iter = std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
 903             [hasher](const PendingFuture &lhs, size_t rhs) -> bool
 904             { return hasher(lhs.mBuffer->getName()) < rhs; }
 905         );
 906         if(iter != mFutureBuffers.end() && iter->mBuffer->getName() == name)
 907         {
 908             future = iter->mFuture;
 909             if(future.wait_for(std::chrono::milliseconds::zero()) == std::future_status::ready)
 910                 mFutureBuffers.erase(iter);
 911             return future;
 912         }
 913
 914         // Clear out any fulfilled futures.
 915         mFutureBuffers.erase(
 916             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
 917                 [](const PendingFuture &entry) -> bool
 918                 { return entry.mFuture.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready; }
 919             ), mFutureBuffers.end()
 920         );
 921     }
 922
 923     auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
 924         [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
 925         { return hasher(lhs->getName()) < rhs; }
 926     );
 927     if(iter != mBuffers.end() && (*iter)->getName() == name)
 928     {
 929         // User asked to create a future buffer that's already loaded. Just
 930         // construct a promise, fulfill the promise immediately, then return a
 931         // shared future that's already set.
 932         Promise<Buffer> promise;
 933         promise.set_value(Buffer(iter->get()));
 934         return promise.get_future().share();
 935     }
 936
 937     Promise<Buffer> promise;
 938     future = promise.get_future().share();
 939
 940     BufferOrExceptT ret = doCreateBufferAsync(name, iter, createDecoder(name), std::move(promise));
 941     Buffer *buffer = std::get_if<Buffer>(&ret);
 942     if(UNLIKELY(!buffer))
 943         throw std::get<std::runtime_error>(ret);
 944     mWakeMutex.lock(); mWakeMutex.unlock();
 945     mWakeThread.notify_all();
 946
 947     mFutureBuffers.insert(
 948         std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
 949             [hasher](const PendingFuture &lhs, size_t rhs) -> bool
 950             { return hasher(lhs.mBuffer->getName()) < rhs; }
 951         ), { buffer->getHandle(), future }
 952     );
 953
 954     return future;
 955 }
 956
 957 void ContextImpl::precacheBuffersAsync(ArrayView<StringView> names)
 958 {
 959     CheckContext(this);
 960
 961     if(UNLIKELY(!mFutureBuffers.empty()))
 962     {
 963         // Clear out any fulfilled futures.
 964         mFutureBuffers.erase(
 965             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
 966                 [](const PendingFuture &entry) -> bool
 967                 { return entry.mFuture.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready; }
 968             ), mFutureBuffers.end()
 969         );
 970     }
 971
 972     auto hasher = std::hash<StringView>();
 973     for(const StringView name : names)
 974     {
 975         // Check if the buffer that's being created already exists
 976         auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
 977             [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
 978             { return hasher(lhs->getName()) < rhs; }
 979         );
 980         if(iter != mBuffers.end() && (*iter)->getName() == name)
 981             continue;
 982
 983         DecoderOrExceptT dec = findDecoder(name);
 984         SharedPtr<Decoder> *decoder = std::get_if<SharedPtr<Decoder>>(&dec);
 985         if(!decoder) continue;
 986
 987         Promise<Buffer> promise;
 988         SharedFuture<Buffer> future = promise.get_future().share();
 989
 990         BufferOrExceptT buf = doCreateBufferAsync(name, iter, std::move(*decoder),
 991                                                   std::move(promise));
 992         Buffer *buffer = std::get_if<Buffer>(&buf);
 993         if(UNLIKELY(!buffer)) continue;
 994
 995         mFutureBuffers.insert(
 996             std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
 997                 [hasher](const PendingFuture &lhs, size_t rhs) -> bool
 998                 { return hasher(lhs.mBuffer->getName()) < rhs; }
 999             ), { buffer->getHandle(), future }
1000         );
1001     }
1002     mWakeMutex.lock(); mWakeMutex.unlock();
1003     mWakeThread.notify_all();
1004 }
1005
1006 Buffer ContextImpl::createBufferFrom(StringView name, SharedPtr<Decoder>&& decoder)
1007 {
1008     CheckContext(this);
1009
1010     auto hasher = std::hash<StringView>();
1011     auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
1012         [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
1013         { return hasher(lhs->getName()) < rhs; }
1014     );
1015     if(iter != mBuffers.end() && (*iter)->getName() == name)
1016         throw std::runtime_error("Buffer \""+name+"\" already exists");
1017
1018     BufferOrExceptT ret = doCreateBuffer(name, iter, std::move(decoder));
1019     Buffer *buffer = std::get_if<Buffer>(&ret);
1020     if(UNLIKELY(!buffer))
1021         throw std::get<std::runtime_error>(ret);
1022     return *buffer;
1023 }
1024
1025 SharedFuture<Buffer> ContextImpl::createBufferAsyncFrom(StringView name, SharedPtr<Decoder>&& decoder)
1026 {
1027     SharedFuture<Buffer> future;
1028     CheckContext(this);
1029
1030     if(UNLIKELY(!mFutureBuffers.empty()))
1031     {
1032         // Clear out any fulfilled futures.
1033         mFutureBuffers.erase(
1034             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
1035                 [](const PendingFuture &entry) -> bool
1036                 { return entry.mFuture.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready; }
1037             ), mFutureBuffers.end()
1038         );
1039     }
1040
1041     auto hasher = std::hash<StringView>();
1042     auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
1043         [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
1044         { return hasher(lhs->getName()) < rhs; }
1045     );
1046     if(iter != mBuffers.end() && (*iter)->getName() == name)
1047         throw std::runtime_error("Buffer \""+name+"\" already exists");
1048
1049     Promise<Buffer> promise;
1050     future = promise.get_future().share();
1051
1052     BufferOrExceptT ret = doCreateBufferAsync(name, iter, std::move(decoder), std::move(promise));
1053     Buffer *buffer = std::get_if<Buffer>(&ret);
1054     if(UNLIKELY(!buffer))
1055         throw std::get<std::runtime_error>(ret);
1056     mWakeMutex.lock(); mWakeMutex.unlock();
1057     mWakeThread.notify_all();
1058
1059     mFutureBuffers.insert(
1060         std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
1061             [hasher](const PendingFuture &lhs, size_t rhs) -> bool
1062             { return hasher(lhs.mBuffer->getName()) < rhs; }
1063         ), { buffer->getHandle(), future }
1064     );
1065
1066     return future;
1067 }
1068
1069
1070 void ContextImpl::removeBuffer(StringView name)
1071 {
1072     CheckContext(this);
1073
1074     auto hasher = std::hash<StringView>();
1075     if(UNLIKELY(!mFutureBuffers.empty()))
1076     {
1077         // If the buffer is already pending for the future, wait for it to
1078         // finish before continuing.
1079         auto iter = std::lower_bound(mFutureBuffers.begin(), mFutureBuffers.end(), hasher(name),
1080             [hasher](const PendingFuture &lhs, size_t rhs) -> bool
1081             { return hasher(lhs.mBuffer->getName()) < rhs; }
1082         );
1083         if(iter != mFutureBuffers.end() && iter->mBuffer->getName() == name)
1084         {
1085             iter->mFuture.wait();
1086             mFutureBuffers.erase(iter);
1087         }
1088
1089         // Clear out any completed futures.
1090         mFutureBuffers.erase(
1091             std::remove_if(mFutureBuffers.begin(), mFutureBuffers.end(),
1092                 [](const PendingFuture &entry) -> bool
1093                 { return entry.mFuture.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready; }
1094             ), mFutureBuffers.end()
1095         );
1096     }
1097
1098     auto iter = std::lower_bound(mBuffers.begin(), mBuffers.end(), hasher(name),
1099         [hasher](const UniquePtr<BufferImpl> &lhs, size_t rhs) -> bool
1100         { return hasher(lhs->getName()) < rhs; }
1101     );
1102     if(iter != mBuffers.end() && (*iter)->getName() == name)
1103     {
1104         // Remove pending sources whose future was waiting for this buffer.
1105         mPendingSources.erase(
1106             std::remove_if(mPendingSources.begin(), mPendingSources.end(),
1107                 [iter](PendingSource &entry) -> bool
1108                 {
1109                     return (entry.mFuture.wait_for(std::chrono::milliseconds::zero()) == std::future_status::ready &&
1110                             entry.mFuture.get().getHandle() == iter->get());
1111                 }
1112             ), mPendingSources.end()
1113         );
1114         (*iter)->cleanup();
1115         mBuffers.erase(iter);
1116     }
1117 }
1118
1119
1120 ALuint ContextImpl::getSourceId(ALuint maxprio)
1121 {
1122     ALuint id = 0;
1123     if(mSourceIds.empty())
1124     {
1125         alGetError();
1126         alGenSources(1, &id);
1127         if(alGetError() == AL_NO_ERROR)
1128             return id;
1129
1130         SourceImpl *lowest = nullptr;
1131         for(SourceBufferUpdateEntry &entry : mPlaySources)
1132         {
1133             if(!lowest || entry.mSource->getPriority() < lowest->getPriority())
1134                 lowest = entry.mSource;
1135         }
1136         for(SourceStreamUpdateEntry &entry : mStreamSources)
1137         {
1138             if(!lowest || entry.mSource->getPriority() < lowest->getPriority())
1139                 lowest = entry.mSource;
1140         }
1141         if(lowest && lowest->getPriority() < maxprio)
1142         {
1143             lowest->stop();
1144             if(mMessage.get())
1145                 mMessage->sourceForceStopped(lowest);
1146         }
1147     }
1148     if(mSourceIds.empty())
1149         throw std::runtime_error("No available sources");
1150
1151     id = mSourceIds.top();
1152     mSourceIds.pop();
1153     return id;
1154 }
1155
1156
1157 Source ContextImpl::createSource()
1158 {
1159     CheckContext(this);
1160
1161     SourceImpl *source;
1162     if(!mFreeSources.empty())
1163     {
1164         source = mFreeSources.back();
1165         mFreeSources.pop_back();
1166     }
1167     else
1168     {
1169         mAllSources.emplace_back(this);
1170         source = &mAllSources.back();
1171     }
1172     return Source(source);
1173 }
1174
1175
1176 void ContextImpl::addPendingSource(SourceImpl *source, SharedFuture<Buffer> future)
1177 {
1178     auto iter = std::lower_bound(mPendingSources.begin(), mPendingSources.end(), source,
1179         [](const PendingSource &lhs, SourceImpl *rhs) -> bool
1180         { return lhs.mSource < rhs; }
1181     );
1182     if(iter == mPendingSources.end() || iter->mSource != source)
1183         mPendingSources.insert(iter, {source, std::move(future)});
1184 }
1185
1186 void ContextImpl::removePendingSource(SourceImpl *source)
1187 {
1188     auto iter = std::lower_bound(mPendingSources.begin(), mPendingSources.end(), source,
1189         [](const PendingSource &lhs, SourceImpl *rhs) -> bool
1190         { return lhs.mSource < rhs; }
1191     );
1192     if(iter != mPendingSources.end() && iter->mSource == source)
1193         mPendingSources.erase(iter);
1194 }
1195
1196 bool ContextImpl::isPendingSource(const SourceImpl *source) const
1197 {
1198     auto iter = std::lower_bound(mPendingSources.begin(), mPendingSources.end(), source,
1199         [](const PendingSource &lhs, const SourceImpl *rhs) -> bool
1200         { return lhs.mSource < rhs; }
1201     );
1202     return (iter != mPendingSources.end() && iter->mSource == source);
1203 }
1204
1205 void ContextImpl::addFadingSource(SourceImpl *source)
1206 {
1207     auto iter = std::lower_bound(mFadingSources.begin(), mFadingSources.end(), source,
1208         [](SourceImpl *lhs, SourceImpl *rhs) -> bool
1209         { return lhs < rhs; }
1210     );
1211     if(iter == mFadingSources.end() || *iter != source)
1212         mFadingSources.insert(iter, source);
1213 }
1214
1215 void ContextImpl::removeFadingSource(SourceImpl *source)
1216 {
1217     auto iter = std::lower_bound(mFadingSources.begin(), mFadingSources.end(), source,
1218         [](SourceImpl *lhs, SourceImpl *rhs) -> bool
1219         { return lhs < rhs; }
1220     );
1221     if(iter != mFadingSources.end() && *iter == source)
1222         mFadingSources.erase(iter);
1223 }
1224
1225 void ContextImpl::addPlayingSource(SourceImpl *source, ALuint id)
1226 {
1227     auto iter = std::lower_bound(mPlaySources.begin(), mPlaySources.end(), source,
1228         [](const SourceBufferUpdateEntry &lhs, SourceImpl *rhs) -> bool
1229         { return lhs.mSource < rhs; }
1230     );
1231     if(iter == mPlaySources.end() || iter->mSource != source)
1232         mPlaySources.insert(iter, {source,id});
1233 }
1234
1235 void ContextImpl::addPlayingSource(SourceImpl *source)
1236 {
1237     auto iter = std::lower_bound(mStreamSources.begin(), mStreamSources.end(), source,
1238         [](const SourceStreamUpdateEntry &lhs, SourceImpl *rhs) -> bool
1239         { return lhs.mSource < rhs; }
1240     );
1241     if(iter == mStreamSources.end() || iter->mSource != source)
1242         mStreamSources.insert(iter, {source});
1243 }
1244
1245 void ContextImpl::removePlayingSource(SourceImpl *source)
1246 {
1247     auto iter0 = std::lower_bound(mPlaySources.begin(), mPlaySources.end(), source,
1248         [](const SourceBufferUpdateEntry &lhs, SourceImpl *rhs) -> bool
1249         { return lhs.mSource < rhs; }
1250     );
1251     if(iter0 != mPlaySources.end() && iter0->mSource == source)
1252         mPlaySources.erase(iter0);
1253     else
1254     {
1255         auto iter1 = std::lower_bound(mStreamSources.begin(), mStreamSources.end(), source,
1256             [](const SourceStreamUpdateEntry &lhs, SourceImpl *rhs) -> bool
1257             { return lhs.mSource < rhs; }
1258         );
1259         if(iter1 != mStreamSources.end() && iter1->mSource == source)
1260             mStreamSources.erase(iter1);
1261     }
1262 }
1263
1264
1265 void ContextImpl::addStream(SourceImpl *source)
1266 {
1267     std::lock_guard<std::mutex> lock(mSourceStreamMutex);
1268     if(mThread.get_id() == std::thread::id())
1269         mThread = std::thread(std::mem_fn(&ContextImpl::backgroundProc), this);
1270     auto iter = std::lower_bound(mStreamingSources.begin(), mStreamingSources.end(), source);
1271     if(iter == mStreamingSources.end() || *iter != source)
1272         mStreamingSources.insert(iter, source);
1273 }
1274
1275 void ContextImpl::removeStream(SourceImpl *source)
1276 {
1277     std::lock_guard<std::mutex> lock(mSourceStreamMutex);
1278     auto iter = std::lower_bound(mStreamingSources.begin(), mStreamingSources.end(), source);
1279     if(iter != mStreamingSources.end() && *iter == source)
1280         mStreamingSources.erase(iter);
1281 }
1282
1283 void ContextImpl::removeStreamNoLock(SourceImpl *source)
1284 {
1285     auto iter = std::lower_bound(mStreamingSources.begin(), mStreamingSources.end(), source);
1286     if(iter != mStreamingSources.end() && *iter == source)
1287         mStreamingSources.erase(iter);
1288 }
1289
1290
1291 AuxiliaryEffectSlot ContextImpl::createAuxiliaryEffectSlot()
1292 {
1293     if(!hasExtension(AL::EXT_EFX) || !alGenAuxiliaryEffectSlots)
1294         throw std::runtime_error("AuxiliaryEffectSlots not supported");
1295     CheckContext(this);
1296
1297     alGetError();
1298     ALuint id = 0;
1299     alGenAuxiliaryEffectSlots(1, &id);
1300     if(alGetError() != AL_NO_ERROR)
1301         throw std::runtime_error("Failed to create AuxiliaryEffectSlot");
1302     try {
1303         return AuxiliaryEffectSlot(new AuxiliaryEffectSlotImpl(this, id));
1304     }
1305     catch(...) {
1306         alDeleteAuxiliaryEffectSlots(1, &id);
1307         throw;
1308     }
1309 }
1310
1311
1312 Effect ContextImpl::createEffect()
1313 {
1314     if(!hasExtension(AL::EXT_EFX))
1315         throw std::runtime_error("Effects not supported");
1316     CheckContext(this);
1317
1318     alGetError();
1319     ALuint id = 0;
1320     alGenEffects(1, &id);
1321     if(alGetError() != AL_NO_ERROR)
1322         throw std::runtime_error("Failed to create Effect");
1323     try {
1324         return Effect(new EffectImpl(this, id));
1325     }
1326     catch(...) {
1327         alDeleteEffects(1, &id);
1328         throw;
1329     }
1330 }
1331
1332
1333 SourceGroup ContextImpl::createSourceGroup(StringView name)
1334 {
1335     auto hasher = std::hash<StringView>();
1336     auto iter = std::lower_bound(mSourceGroups.begin(), mSourceGroups.end(), hasher(name),
1337         [hasher](const UniquePtr<SourceGroupImpl> &lhs, size_t rhs) -> bool
1338         { return hasher(lhs->getName()) < rhs; }
1339     );
1340     if(iter != mSourceGroups.end() && (*iter)->getName() == name)
1341         throw std::runtime_error("Duplicate source group name");
1342     iter = mSourceGroups.insert(iter, MakeUnique<SourceGroupImpl>(this, name));
1343     return SourceGroup(iter->get());
1344 }
1345
1346 SourceGroup ContextImpl::getSourceGroup(StringView name)
1347 {
1348     auto hasher = std::hash<StringView>();
1349     auto iter = std::lower_bound(mSourceGroups.begin(), mSourceGroups.end(), hasher(name),
1350         [hasher](const UniquePtr<SourceGroupImpl> &lhs, size_t rhs) -> bool
1351         { return hasher(lhs->getName()) < rhs; }
1352     );
1353     if(iter == mSourceGroups.end() || (*iter)->getName() != name)
1354         throw std::runtime_error("Source group not found");
1355     return SourceGroup(iter->get());
1356 }
1357
1358 void ContextImpl::freeSourceGroup(SourceGroupImpl *group)
1359 {
1360     auto hasher = std::hash<StringView>();
1361     auto iter = std::lower_bound(mSourceGroups.begin(), mSourceGroups.end(), hasher(group->getName()),
1362         [hasher](const UniquePtr<SourceGroupImpl> &lhs, size_t rhs) -> bool
1363         { return hasher(lhs->getName()) < rhs; }
1364     );
1365     if(iter != mSourceGroups.end() && iter->get() == group)
1366         mSourceGroups.erase(iter);
1367 }
1368
1369
1370 void ContextImpl::setDopplerFactor(ALfloat factor)
1371 {
1372     if(!(factor >= 0.0f))
1373         throw std::runtime_error("Doppler factor out of range");
1374     CheckContext(this);
1375     alDopplerFactor(factor);
1376 }
1377
1378
1379 void ContextImpl::setSpeedOfSound(ALfloat speed)
1380 {
1381     if(!(speed > 0.0f))
1382         throw std::runtime_error("Speed of sound out of range");
1383     CheckContext(this);
1384     alSpeedOfSound(speed);
1385 }
1386
1387
1388 void ContextImpl::setDistanceModel(DistanceModel model)
1389 {
1390     CheckContext(this);
1391     alDistanceModel((ALenum)model);
1392 }
1393
1394
1395 void ContextImpl::update()
1396 {
1397     CheckContext(this);
1398     mPendingSources.erase(
1399         std::remove_if(mPendingSources.begin(), mPendingSources.end(),
1400             [](PendingSource &entry) -> bool
1401             { return !entry.mSource->checkPending(entry.mFuture); }
1402         ), mPendingSources.end()
1403     );
1404     if(!mFadingSources.empty())
1405     {
1406         auto cur_time = std::chrono::steady_clock::now();
1407         mFadingSources.erase(
1408             std::remove_if(mFadingSources.begin(), mFadingSources.end(),
1409                 [cur_time](SourceImpl *source) -> bool
1410                 { return !source->fadeUpdate(cur_time); }
1411             ), mFadingSources.end()
1412         );
1413     }
1414     mPlaySources.erase(
1415         std::remove_if(mPlaySources.begin(), mPlaySources.end(),
1416             [](const SourceBufferUpdateEntry &entry) -> bool
1417             { return !entry.mSource->playUpdate(entry.mId); }
1418         ), mPlaySources.end()
1419     );
1420     mStreamSources.erase(
1421         std::remove_if(mStreamSources.begin(), mStreamSources.end(),
1422             [](const SourceStreamUpdateEntry &entry) -> bool
1423             { return !entry.mSource->playUpdate(); }
1424         ), mStreamSources.end()
1425     );
1426
1427     if(!mWakeInterval.load(std::memory_order_relaxed).count())
1428     {
1429         // For performance reasons, don't wait for the thread's mutex. This
1430         // should be called often enough to keep up with any and all streams
1431         // regardless.
1432         mWakeThread.notify_all();
1433     }
1434
1435     if(hasExtension(AL::EXT_disconnect) && mIsConnected)
1436     {
1437         ALCint connected;
1438         alcGetIntegerv(mDevice->getALCdevice(), ALC_CONNECTED, 1, &connected);
1439         mIsConnected = connected;
1440         if(!connected && mMessage.get()) mMessage->deviceDisconnected(Device(mDevice));
1441     }
1442 }
1443
1444 void Context::destroy()
1445 {
1446     pImpl->destroy();
1447     pImpl = nullptr;
1448 }
1449 DECL_THUNK0(Device, Context, getDevice,)
1450 DECL_THUNK0(void, Context, startBatch,)
1451 DECL_THUNK0(void, Context, endBatch,)
1452 DECL_THUNK0(Listener, Context, getListener,)
1453 DECL_THUNK1(SharedPtr<MessageHandler>, Context, setMessageHandler,, SharedPtr<MessageHandler>)
1454 DECL_THUNK0(SharedPtr<MessageHandler>, Context, getMessageHandler, const)
1455 DECL_THUNK1(void, Context, setAsyncWakeInterval,, std::chrono::milliseconds)
1456 DECL_THUNK0(std::chrono::milliseconds, Context, getAsyncWakeInterval, const)
1457 DECL_THUNK1(SharedPtr<Decoder>, Context, createDecoder,, StringView)
1458 DECL_THUNK2(bool, Context, isSupported, const, ChannelConfig, SampleType)
1459 DECL_THUNK0(ArrayView<String>, Context, getAvailableResamplers,)
1460 DECL_THUNK0(ALsizei, Context, getDefaultResamplerIndex, const)
1461 DECL_THUNK1(Buffer, Context, getBuffer,, StringView)
1462 DECL_THUNK1(SharedFuture<Buffer>, Context, getBufferAsync,, StringView)
1463 DECL_THUNK1(void, Context, precacheBuffersAsync,, ArrayView<StringView>)
1464 DECL_THUNK2(Buffer, Context, createBufferFrom,, StringView, SharedPtr<Decoder>)
1465 DECL_THUNK2(SharedFuture<Buffer>, Context, createBufferAsyncFrom,, StringView, SharedPtr<Decoder>)
1466 DECL_THUNK1(void, Context, removeBuffer,, StringView)
1467 DECL_THUNK1(void, Context, removeBuffer,, Buffer)
1468 DECL_THUNK0(Source, Context, createSource,)
1469 DECL_THUNK0(AuxiliaryEffectSlot, Context, createAuxiliaryEffectSlot,)
1470 DECL_THUNK0(Effect, Context, createEffect,)
1471 DECL_THUNK1(SourceGroup, Context, createSourceGroup,, StringView)
1472 DECL_THUNK1(SourceGroup, Context, getSourceGroup,, StringView)
1473 DECL_THUNK1(void, Context, setDopplerFactor,, ALfloat)
1474 DECL_THUNK1(void, Context, setSpeedOfSound,, ALfloat)
1475 DECL_THUNK1(void, Context, setDistanceModel,, DistanceModel)
1476 DECL_THUNK0(void, Context, update,)
1477
1478
1479 void Context::MakeCurrent(Context context)
1480 { ContextImpl::MakeCurrent(context.pImpl); }
1481
1482 Context Context::GetCurrent()
1483 { return Context(ContextImpl::GetCurrent()); }
1484
1485 void Context::MakeThreadCurrent(Context context)
1486 { ContextImpl::MakeThreadCurrent(context.pImpl); }
1487
1488 Context Context::GetThreadCurrent()
1489 { return Context(ContextImpl::GetThreadCurrent()); }
1490
1491
1492 void ListenerImpl::setGain(ALfloat gain)
1493 {
1494     if(!(gain >= 0.0f))
1495         throw std::runtime_error("Gain out of range");
1496     CheckContext(mContext);
1497     alListenerf(AL_GAIN, gain);
1498 }
1499
1500
1501 void ListenerImpl::set3DParameters(const Vector3 &position, const Vector3 &velocity, const std::pair<Vector3,Vector3> &orientation)
1502 {
1503     static_assert(sizeof(orientation) == sizeof(ALfloat[6]), "Invalid Vector3 pair size");
1504     CheckContext(mContext);
1505     Batcher batcher = mContext->getBatcher();
1506     alListenerfv(AL_POSITION, position.getPtr());
1507     alListenerfv(AL_VELOCITY, velocity.getPtr());
1508     alListenerfv(AL_ORIENTATION, orientation.first.getPtr());
1509 }
1510
1511 void ListenerImpl::setPosition(ALfloat x, ALfloat y, ALfloat z)
1512 {
1513     CheckContext(mContext);
1514     alListener3f(AL_POSITION, x, y, z);
1515 }
1516
1517 void ListenerImpl::setPosition(const ALfloat *pos)
1518 {
1519     CheckContext(mContext);
1520     alListenerfv(AL_POSITION, pos);
1521 }
1522
1523 void ListenerImpl::setVelocity(ALfloat x, ALfloat y, ALfloat z)
1524 {
1525     CheckContext(mContext);
1526     alListener3f(AL_VELOCITY, x, y, z);
1527 }
1528
1529 void ListenerImpl::setVelocity(const ALfloat *vel)
1530 {
1531     CheckContext(mContext);
1532     alListenerfv(AL_VELOCITY, vel);
1533 }
1534
1535 void ListenerImpl::setOrientation(ALfloat x1, ALfloat y1, ALfloat z1, ALfloat x2, ALfloat y2, ALfloat z2)
1536 {
1537     CheckContext(mContext);
1538     ALfloat ori[6] = { x1, y1, z1, x2, y2, z2 };
1539     alListenerfv(AL_ORIENTATION, ori);
1540 }
1541
1542 void ListenerImpl::setOrientation(const ALfloat *at, const ALfloat *up)
1543 {
1544     CheckContext(mContext);
1545     ALfloat ori[6] = { at[0], at[1], at[2], up[0], up[1], up[2] };
1546     alListenerfv(AL_ORIENTATION, ori);
1547 }
1548
1549 void ListenerImpl::setOrientation(const ALfloat *ori)
1550 {
1551     CheckContext(mContext);
1552     alListenerfv(AL_ORIENTATION, ori);
1553 }
1554
1555 void ListenerImpl::setMetersPerUnit(ALfloat m_u)
1556 {
1557     if(!(m_u > 0.0f))
1558         throw std::runtime_error("Invalid meters per unit");
1559     CheckContext(mContext);
1560     if(mContext->hasExtension(AL::EXT_EFX))
1561         alListenerf(AL_METERS_PER_UNIT, m_u);
1562 }
1563
1564
1565 using Vector3Pair = std::pair<Vector3,Vector3>;
1566
1567 DECL_THUNK1(void, Listener, setGain,, ALfloat)
1568 DECL_THUNK3(void, Listener, set3DParameters,, const Vector3&, const Vector3&, const Vector3Pair&)
1569 DECL_THUNK3(void, Listener, setPosition,, ALfloat, ALfloat, ALfloat)
1570 DECL_THUNK1(void, Listener, setPosition,, const ALfloat*)
1571 DECL_THUNK3(void, Listener, setVelocity,, ALfloat, ALfloat, ALfloat)
1572 DECL_THUNK1(void, Listener, setVelocity,, const ALfloat*)
1573 DECL_THUNK6(void, Listener, setOrientation,, ALfloat, ALfloat, ALfloat, ALfloat, ALfloat, ALfloat)
1574 DECL_THUNK2(void, Listener, setOrientation,, const ALfloat*, const ALfloat*)
1575 DECL_THUNK1(void, Listener, setOrientation,, const ALfloat*)
1576 DECL_THUNK1(void, Listener, setMetersPerUnit,, ALfloat)
1577
1578 }