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