src/source.cpp

   1
   2 #include "config.h"
   3
   4 #include "source.h"
   5
   6 #include <cstring>
   7
   8 #include <stdexcept>
   9 #include <sstream>
  10 #include <memory>
  11 #include <limits>
  12
  13 #include "al.h"
  14 #include "alext.h"
  15
  16 #include "context.h"
  17 #include "buffer.h"
  18 #include "auxeffectslot.h"
  19 #include "sourcegroup.h"
  20
  21 namespace alure
  22 {
  23
  24 class ALBufferStream {
  25     SharedPtr<Decoder> mDecoder;
  26
  27     ALuint mUpdateLen;
  28     ALuint mNumUpdates;
  29
  30     ALenum mFormat;
  31     ALuint mFrequency;
  32     ALuint mFrameSize;
  33
  34     Vector<ALbyte> mData;
  35     ALbyte mSilence;
  36
  37     Vector<ALuint> mBufferIds;
  38     ALuint mCurrentIdx;
  39
  40     uint64_t mSamplePos;
  41     std::pair<uint64_t,uint64_t> mLoopPts;
  42     bool mHasLooped;
  43     std::atomic<bool> mDone;
  44
  45 public:
  46     ALBufferStream(SharedPtr<Decoder> decoder, ALuint updatelen, ALuint numupdates)
  47       : mDecoder(decoder), mUpdateLen(updatelen), mNumUpdates(numupdates),
  48         mFormat(AL_NONE), mFrequency(0), mFrameSize(0), mSilence(0),
  49         mCurrentIdx(0), mSamplePos(0), mLoopPts{0,0}, mHasLooped(false),
  50         mDone(false)
  51     { }
  52     ~ALBufferStream()
  53     {
  54         if(!mBufferIds.empty())
  55         {
  56             alDeleteBuffers(mBufferIds.size(), mBufferIds.data());
  57             mBufferIds.clear();
  58         }
  59     }
  60
  61     uint64_t getLength() const { return mDecoder->getLength(); }
  62     uint64_t getPosition() const { return mSamplePos; }
  63
  64     ALuint getNumUpdates() const { return mNumUpdates; }
  65     ALuint getUpdateLength() const { return mUpdateLen; }
  66
  67     ALuint getFrequency() const { return mFrequency; }
  68
  69     bool seek(uint64_t pos)
  70     {
  71         if(!mDecoder->seek(pos))
  72             return false;
  73         mSamplePos = pos;
  74         mHasLooped = false;
  75         mDone.store(false, std::memory_order_release);
  76         return true;
  77     }
  78
  79     void prepare()
  80     {
  81         ALuint srate = mDecoder->getFrequency();
  82         ChannelConfig chans = mDecoder->getChannelConfig();
  83         SampleType type = mDecoder->getSampleType();
  84
  85         mLoopPts = mDecoder->getLoopPoints();
  86         if(mLoopPts.first >= mLoopPts.second)
  87         {
  88             mLoopPts.first = 0;
  89             mLoopPts.second = std::numeric_limits<uint64_t>::max();
  90         }
  91
  92         mFrequency = srate;
  93         mFrameSize = FramesToBytes(1, chans, type);
  94         mFormat = GetFormat(chans, type);
  95         if(mFormat == AL_NONE)
  96         {
  97             std::stringstream sstr;
  98             sstr<< "Format not supported ("<<GetSampleTypeName(type)<<", "<<GetChannelConfigName(chans)<<")";
  99             throw std::runtime_error(sstr.str());
 100         }
 101
 102         mData.resize(mUpdateLen * mFrameSize);
 103         if(type == SampleType::UInt8) mSilence = 0x80;
 104         else if(type == SampleType::Mulaw) mSilence = 0x7f;
 105         else mSilence = 0x00;
 106
 107         mBufferIds.assign(mNumUpdates, 0);
 108         alGenBuffers(mBufferIds.size(), mBufferIds.data());
 109     }
 110
 111     int64_t getLoopStart() const { return mLoopPts.first; }
 112     int64_t getLoopEnd() const { return mLoopPts.second; }
 113
 114     bool hasLooped() const { return mHasLooped; }
 115     bool hasMoreData() const { return !mDone.load(std::memory_order_acquire); }
 116     bool streamMoreData(ALuint srcid, bool loop)
 117     {
 118         if(mDone.load(std::memory_order_acquire))
 119             return false;
 120
 121         ALuint frames;
 122         ALuint len = mUpdateLen;
 123         if(loop && mSamplePos <= mLoopPts.second)
 124             len = std::min<uint64_t>(len, mLoopPts.second - mSamplePos);
 125         else
 126             loop = false;
 127
 128         frames = mDecoder->read(mData.data(), len);
 129         mSamplePos += frames;
 130         if(frames < mUpdateLen && loop && mSamplePos > 0)
 131         {
 132             if(mSamplePos < mLoopPts.second)
 133             {
 134                 mLoopPts.second = mSamplePos;
 135                 mLoopPts.first = std::min(mLoopPts.first, mLoopPts.second-1);
 136             }
 137
 138             do {
 139                 if(!mDecoder->seek(mLoopPts.first))
 140                     break;
 141                 mSamplePos = mLoopPts.first;
 142                 mHasLooped = true;
 143
 144                 len = std::min<uint64_t>(mUpdateLen-frames, mLoopPts.second-mLoopPts.first);
 145                 ALuint got = mDecoder->read(&mData[frames*mFrameSize], len);
 146                 if(got == 0) break;
 147                 mSamplePos += got;
 148                 frames += got;
 149             } while(frames < mUpdateLen);
 150         }
 151         if(frames < mUpdateLen)
 152         {
 153             mDone.store(true, std::memory_order_release);
 154             if(frames == 0) return false;
 155             mSamplePos += mUpdateLen - frames;
 156             std::fill(mData.begin() + frames*mFrameSize, mData.end(), mSilence);
 157         }
 158
 159         alBufferData(mBufferIds[mCurrentIdx], mFormat, mData.data(), mData.size(), mFrequency);
 160         alSourceQueueBuffers(srcid, 1, &mBufferIds[mCurrentIdx]);
 161         mCurrentIdx = (mCurrentIdx+1) % mBufferIds.size();
 162         return true;
 163     }
 164 };
 165
 166
 167 SourceImpl::SourceImpl(ContextImpl *context)
 168   : mContext(context), mId(0), mBuffer(0), mGroup(nullptr), mIsAsync(false),
 169     mDirectFilter(AL_FILTER_NULL)
 170 {
 171     resetProperties();
 172 }
 173
 174 SourceImpl::~SourceImpl()
 175 {
 176 }
 177
 178
 179 void SourceImpl::resetProperties()
 180 {
 181     if(mGroup)
 182         mGroup->removeSource(Source(this));
 183     mGroup = nullptr;
 184
 185     mPaused.store(false, std::memory_order_release);
 186     mOffset = 0;
 187     mPitch = 1.0f;
 188     mGain = 1.0f;
 189     mMinGain = 0.0f;
 190     mMaxGain = 1.0f;
 191     mRefDist = 1.0f;
 192     mMaxDist = std::numeric_limits<float>::max();
 193     mPosition = Vector3(0.0f);
 194     mVelocity = Vector3(0.0f);
 195     mDirection = Vector3(0.0f);
 196     mOrientation[0] = Vector3(0.0f, 0.0f, -1.0f);
 197     mOrientation[1] = Vector3(0.0f, 1.0f,  0.0f);
 198     mConeInnerAngle = 360.0f;
 199     mConeOuterAngle = 360.0f;
 200     mConeOuterGain = 0.0f;
 201     mConeOuterGainHF = 1.0f;
 202     mRolloffFactor = 1.0f;
 203     mRoomRolloffFactor = 0.0f;
 204     mDopplerFactor = 1.0f;
 205     mAirAbsorptionFactor = 0.0f;
 206     mRadius = 0.0f;
 207     mStereoAngles[0] =  F_PI / 6.0f;
 208     mStereoAngles[1] = -F_PI / 6.0f;
 209     mSpatialize = Spatialize::Auto;
 210     mResampler = mContext->hasExtension(SOFT_source_resampler) ?
 211                  alGetInteger(AL_DEFAULT_RESAMPLER_SOFT) : 0;
 212     mLooping = false;
 213     mRelative = false;
 214     mDryGainHFAuto = true;
 215     mWetGainAuto = true;
 216     mWetGainHFAuto = true;
 217     if(mDirectFilter)
 218         mContext->alDeleteFilters(1, &mDirectFilter);
 219     mDirectFilter = 0;
 220     for(auto &i : mEffectSlots)
 221     {
 222         if(i.second.mSlot)
 223             i.second.mSlot->removeSourceSend(Source(this), i.first);
 224         if(i.second.mFilter)
 225             mContext->alDeleteFilters(1, &i.second.mFilter);
 226     }
 227     mEffectSlots.clear();
 228
 229     mPriority = 0;
 230 }
 231
 232 void SourceImpl::applyProperties(bool looping, ALuint offset) const
 233 {
 234     alSourcei(mId, AL_LOOPING, looping ? AL_TRUE : AL_FALSE);
 235     alSourcei(mId, AL_SAMPLE_OFFSET, offset);
 236     if(mGroup)
 237     {
 238         alSourcef(mId, AL_PITCH, mPitch * mGroup->getAppliedPitch());
 239         alSourcef(mId, AL_GAIN, mGain * mGroup->getAppliedGain());
 240     }
 241     else
 242     {
 243         alSourcef(mId, AL_PITCH, mPitch);
 244         alSourcef(mId, AL_GAIN, mGain);
 245     }
 246     alSourcef(mId, AL_MIN_GAIN, mMinGain);
 247     alSourcef(mId, AL_MAX_GAIN, mMaxGain);
 248     alSourcef(mId, AL_REFERENCE_DISTANCE, mRefDist);
 249     alSourcef(mId, AL_MAX_DISTANCE, mMaxDist);
 250     alSourcefv(mId, AL_POSITION, mPosition.getPtr());
 251     alSourcefv(mId, AL_VELOCITY, mVelocity.getPtr());
 252     alSourcefv(mId, AL_DIRECTION, mDirection.getPtr());
 253     if(mContext->hasExtension(EXT_BFORMAT))
 254         alSourcefv(mId, AL_ORIENTATION, &mOrientation[0][0]);
 255     alSourcef(mId, AL_CONE_INNER_ANGLE, mConeInnerAngle);
 256     alSourcef(mId, AL_CONE_OUTER_ANGLE, mConeOuterAngle);
 257     alSourcef(mId, AL_CONE_OUTER_GAIN, mConeOuterGain);
 258     alSourcef(mId, AL_ROLLOFF_FACTOR, mRolloffFactor);
 259     alSourcef(mId, AL_DOPPLER_FACTOR, mDopplerFactor);
 260     if(mContext->hasExtension(EXT_SOURCE_RADIUS))
 261         alSourcef(mId, AL_SOURCE_RADIUS, mRadius);
 262     if(mContext->hasExtension(EXT_STEREO_ANGLES))
 263         alSourcefv(mId, AL_STEREO_ANGLES, mStereoAngles);
 264     if(mContext->hasExtension(SOFT_source_spatialize))
 265         alSourcei(mId, AL_SOURCE_SPATIALIZE_SOFT, (ALint)mSpatialize);
 266     if(mContext->hasExtension(SOFT_source_resampler))
 267         alSourcei(mId, AL_SOURCE_RESAMPLER_SOFT, mResampler);
 268     alSourcei(mId, AL_SOURCE_RELATIVE, mRelative ? AL_TRUE : AL_FALSE);
 269     if(mContext->hasExtension(EXT_EFX))
 270     {
 271         alSourcef(mId, AL_CONE_OUTER_GAINHF, mConeOuterGainHF);
 272         alSourcef(mId, AL_ROOM_ROLLOFF_FACTOR, mRoomRolloffFactor);
 273         alSourcef(mId, AL_AIR_ABSORPTION_FACTOR, mAirAbsorptionFactor);
 274         alSourcei(mId, AL_DIRECT_FILTER_GAINHF_AUTO, mDryGainHFAuto ? AL_TRUE : AL_FALSE);
 275         alSourcei(mId, AL_AUXILIARY_SEND_FILTER_GAIN_AUTO, mWetGainAuto ? AL_TRUE : AL_FALSE);
 276         alSourcei(mId, AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO, mWetGainHFAuto ? AL_TRUE : AL_FALSE);
 277         alSourcei(mId, AL_DIRECT_FILTER, mDirectFilter);
 278         for(const auto &i : mEffectSlots)
 279         {
 280             ALuint slotid = (i.second.mSlot ? i.second.mSlot->getId() : 0);
 281             alSource3i(mId, AL_AUXILIARY_SEND_FILTER, slotid, i.first, i.second.mFilter);
 282         }
 283     }
 284 }
 285
 286
 287 void SourceImpl::setGroup(SourceGroupImpl *group)
 288 {
 289     if(mGroup)
 290         mGroup->removeSource(Source(this));
 291     mGroup = group;
 292     groupUpdate();
 293 }
 294
 295 void SourceImpl::unsetGroup()
 296 {
 297     mGroup = nullptr;
 298     groupUpdate();
 299 }
 300
 301 void SourceImpl::groupUpdate()
 302 {
 303     if(mId)
 304     {
 305         if(mGroup)
 306         {
 307             alSourcef(mId, AL_PITCH, mPitch * mGroup->getAppliedPitch());
 308             alSourcef(mId, AL_GAIN, mGain * mGroup->getAppliedGain());
 309         }
 310         else
 311         {
 312             alSourcef(mId, AL_PITCH, mPitch);
 313             alSourcef(mId, AL_GAIN, mGain);
 314         }
 315     }
 316 }
 317
 318 void SourceImpl::groupPropUpdate(ALfloat gain, ALfloat pitch)
 319 {
 320     if(mId)
 321     {
 322         alSourcef(mId, AL_PITCH, mPitch * pitch);
 323         alSourcef(mId, AL_GAIN, mGain * gain);
 324     }
 325 }
 326
 327
 328 void SourceImpl::play(Buffer buffer)
 329 {
 330     BufferImpl *albuf = buffer.getHandle();
 331     if(!albuf) throw std::runtime_error("Buffer is not valid");
 332     CheckContext(mContext);
 333     CheckContext(albuf->getContext());
 334
 335     if(!albuf->isReady())
 336         throw std::runtime_error("Buffer is not ready");
 337
 338     if(mStream)
 339         mContext->removeStream(this);
 340     mIsAsync.store(false, std::memory_order_release);
 341
 342     if(mId == 0)
 343     {
 344         mId = mContext->getSourceId(mPriority);
 345         applyProperties(mLooping, (ALuint)std::min<uint64_t>(mOffset, std::numeric_limits<ALint>::max()));
 346     }
 347     else
 348     {
 349         mContext->removePlayingSource(this);
 350         alSourceRewind(mId);
 351         alSourcei(mId, AL_BUFFER, 0);
 352         alSourcei(mId, AL_LOOPING, mLooping ? AL_TRUE : AL_FALSE);
 353         alSourcei(mId, AL_SAMPLE_OFFSET, (ALuint)std::min<uint64_t>(mOffset, std::numeric_limits<ALint>::max()));
 354     }
 355     mOffset = 0;
 356
 357     mStream.reset();
 358     if(mBuffer)
 359         mBuffer->removeSource(Source(this));
 360     mBuffer = albuf;
 361     mBuffer->addSource(Source(this));
 362
 363     alSourcei(mId, AL_BUFFER, mBuffer->getId());
 364     alSourcePlay(mId);
 365     mPaused.store(false, std::memory_order_release);
 366     mContext->addPlayingSource(this, mId);
 367 }
 368
 369 void SourceImpl::play(SharedPtr<Decoder> decoder, ALuint updatelen, ALuint queuesize)
 370 {
 371     if(updatelen < 64)
 372         throw std::runtime_error("Update length out of range");
 373     if(queuesize < 2)
 374         throw std::runtime_error("Queue size out of range");
 375     CheckContext(mContext);
 376
 377     auto stream = MakeUnique<ALBufferStream>(decoder, updatelen, queuesize);
 378     stream->prepare();
 379
 380     if(mStream)
 381         mContext->removeStream(this);
 382     mIsAsync.store(false, std::memory_order_release);
 383
 384     if(mId == 0)
 385     {
 386         mId = mContext->getSourceId(mPriority);
 387         applyProperties(false, 0);
 388     }
 389     else
 390     {
 391         mContext->removePlayingSource(this);
 392         alSourceRewind(mId);
 393         alSourcei(mId, AL_BUFFER, 0);
 394         alSourcei(mId, AL_LOOPING, AL_FALSE);
 395         alSourcei(mId, AL_SAMPLE_OFFSET, 0);
 396     }
 397
 398     mStream.reset();
 399     if(mBuffer)
 400         mBuffer->removeSource(Source(this));
 401     mBuffer = 0;
 402
 403     mStream = std::move(stream);
 404
 405     mStream->seek(mOffset);
 406     mOffset = 0;
 407
 408     for(ALuint i = 0;i < mStream->getNumUpdates();i++)
 409     {
 410         if(!mStream->streamMoreData(mId, mLooping))
 411             break;
 412     }
 413     alSourcePlay(mId);
 414     mPaused.store(false, std::memory_order_release);
 415
 416     mContext->addStream(this);
 417     mIsAsync.store(true, std::memory_order_release);
 418     mContext->addPlayingSource(this);
 419 }
 420
 421
 422 void SourceImpl::makeStopped(bool dolock)
 423 {
 424     if(mStream)
 425     {
 426         if(dolock)
 427             mContext->removeStream(this);
 428         else
 429             mContext->removeStreamNoLock(this);
 430     }
 431     mIsAsync.store(false, std::memory_order_release);
 432
 433     if(mId != 0)
 434     {
 435         alSourceRewind(mId);
 436         alSourcei(mId, AL_BUFFER, 0);
 437         if(mContext->hasExtension(EXT_EFX))
 438         {
 439             alSourcei(mId, AL_DIRECT_FILTER, AL_FILTER_NULL);
 440             for(auto &i : mEffectSlots)
 441                 alSource3i(mId, AL_AUXILIARY_SEND_FILTER, 0, i.first, AL_FILTER_NULL);
 442         }
 443         mContext->insertSourceId(mId);
 444         mId = 0;
 445     }
 446
 447     mStream.reset();
 448     if(mBuffer)
 449         mBuffer->removeSource(Source(this));
 450     mBuffer = 0;
 451
 452     mPaused.store(false, std::memory_order_release);
 453 }
 454
 455 void SourceImpl::stop()
 456 {
 457     CheckContext(mContext);
 458     mContext->removePlayingSource(this);
 459     makeStopped();
 460 }
 461
 462
 463 void SourceImpl::checkPaused()
 464 {
 465     if(mPaused.load(std::memory_order_acquire) || mId == 0)
 466         return;
 467
 468     ALint state = -1;
 469     alGetSourcei(mId, AL_SOURCE_STATE, &state);
 470     // Streaming sources may be in a stopped state if underrun
 471     mPaused.store((state == AL_PAUSED) ||
 472                   (state == AL_STOPPED && mStream && mStream->hasMoreData()),
 473                   std::memory_order_release);
 474 }
 475
 476 void SourceImpl::pause()
 477 {
 478     CheckContext(mContext);
 479     if(mPaused.load(std::memory_order_acquire))
 480         return;
 481
 482     if(mId != 0)
 483     {
 484         std::lock_guard<std::mutex> lock(mMutex);
 485         alSourcePause(mId);
 486         ALint state = -1;
 487         alGetSourcei(mId, AL_SOURCE_STATE, &state);
 488         // Streaming sources may be in a stopped state if underrun
 489         mPaused.store((state == AL_PAUSED) ||
 490                       (state == AL_STOPPED && mStream && mStream->hasMoreData()),
 491                       std::memory_order_release);
 492     }
 493 }
 494
 495 void SourceImpl::resume()
 496 {
 497     CheckContext(mContext);
 498     if(!mPaused.load(std::memory_order_acquire))
 499         return;
 500
 501     if(mId != 0)
 502         alSourcePlay(mId);
 503     mPaused.store(false, std::memory_order_release);
 504 }
 505
 506
 507 bool SourceImpl::isPlaying() const
 508 {
 509     CheckContext(mContext);
 510     if(mId == 0) return false;
 511
 512     ALint state = -1;
 513     alGetSourcei(mId, AL_SOURCE_STATE, &state);
 514     if(state == -1)
 515         throw std::runtime_error("Source state error");
 516
 517     return state == AL_PLAYING || (!mPaused.load(std::memory_order_acquire) &&
 518                                    mStream && mStream->hasMoreData());
 519 }
 520
 521 bool SourceImpl::isPaused() const
 522 {
 523     CheckContext(mContext);
 524     if(mId == 0) return false;
 525
 526     ALint state = -1;
 527     alGetSourcei(mId, AL_SOURCE_STATE, &state);
 528     if(state == -1)
 529         throw std::runtime_error("Source state error");
 530
 531     return state == AL_PAUSED || mPaused.load(std::memory_order_acquire);
 532 }
 533
 534
 535 bool SourceImpl::playUpdate(ALuint id)
 536 {
 537     ALint state = -1;
 538     alGetSourcei(id, AL_SOURCE_STATE, &state);
 539     if(EXPECT((state == AL_PLAYING || state == AL_PAUSED), true))
 540         return true;
 541
 542     makeStopped();
 543     mContext->send(&MessageHandler::sourceStopped, Source(this));
 544     return false;
 545 }
 546
 547 bool SourceImpl::playUpdate()
 548 {
 549     if(EXPECT(mIsAsync.load(std::memory_order_acquire), true))
 550         return true;
 551
 552     makeStopped();
 553     mContext->send(&MessageHandler::sourceStopped, Source(this));
 554     return false;
 555 }
 556
 557
 558 ALint SourceImpl::refillBufferStream()
 559 {
 560     ALint processed;
 561     alGetSourcei(mId, AL_BUFFERS_PROCESSED, &processed);
 562     while(processed > 0)
 563     {
 564         ALuint buf;
 565         alSourceUnqueueBuffers(mId, 1, &buf);
 566         --processed;
 567     }
 568
 569     ALint queued;
 570     alGetSourcei(mId, AL_BUFFERS_QUEUED, &queued);
 571     for(;(ALuint)queued < mStream->getNumUpdates();queued++)
 572     {
 573         if(!mStream->streamMoreData(mId, mLooping))
 574             break;
 575     }
 576
 577     return queued;
 578 }
 579
 580 bool SourceImpl::updateAsync()
 581 {
 582     std::lock_guard<std::mutex> lock(mMutex);
 583
 584     ALint queued = refillBufferStream();
 585     if(queued == 0)
 586     {
 587         mIsAsync.store(false, std::memory_order_release);
 588         return false;
 589     }
 590     if(!mPaused.load(std::memory_order_acquire))
 591     {
 592         ALint state = -1;
 593         alGetSourcei(mId, AL_SOURCE_STATE, &state);
 594         if(state != AL_PLAYING)
 595             alSourcePlay(mId);
 596     }
 597     return true;
 598 }
 599
 600
 601 void SourceImpl::setPriority(ALuint priority)
 602 {
 603     mPriority = priority;
 604 }
 605
 606
 607 void SourceImpl::setOffset(uint64_t offset)
 608 {
 609     CheckContext(mContext);
 610     if(mId == 0)
 611     {
 612         mOffset = offset;
 613         return;
 614     }
 615
 616     if(!mStream)
 617     {
 618         if(offset >= std::numeric_limits<ALint>::max())
 619             throw std::runtime_error("Offset out of range");
 620         alGetError();
 621         alSourcei(mId, AL_SAMPLE_OFFSET, (ALint)offset);
 622         if(alGetError() != AL_NO_ERROR)
 623             throw std::runtime_error("Offset out of range");
 624     }
 625     else
 626     {
 627         std::lock_guard<std::mutex> lock(mMutex);
 628         if(!mStream->seek(offset))
 629             throw std::runtime_error("Failed to seek to offset");
 630         alSourceRewind(mId);
 631         alSourcei(mId, AL_BUFFER, 0);
 632         ALint queued = refillBufferStream();
 633         if(queued > 0 && !mPaused)
 634             alSourcePlay(mId);
 635     }
 636 }
 637
 638 std::pair<uint64_t,std::chrono::nanoseconds> SourceImpl::getSampleOffsetLatency() const
 639 {
 640     std::pair<uint64_t,std::chrono::nanoseconds> ret{0, std::chrono::nanoseconds::zero()};
 641     CheckContext(mContext);
 642     if(mId == 0) return ret;
 643
 644     if(mStream)
 645     {
 646         std::lock_guard<std::mutex> lock(mMutex);
 647         ALint queued = 0, state = -1, srcpos = 0;
 648
 649         alGetSourcei(mId, AL_BUFFERS_QUEUED, &queued);
 650         if(mContext->hasExtension(SOFT_source_latency))
 651         {
 652             ALint64SOFT val[2];
 653             mContext->alGetSourcei64vSOFT(mId, AL_SAMPLE_OFFSET_LATENCY_SOFT, val);
 654             srcpos = val[0]>>32;
 655             ret.second = std::chrono::nanoseconds(val[1]);
 656         }
 657         else
 658             alGetSourcei(mId, AL_SAMPLE_OFFSET, &srcpos);
 659         alGetSourcei(mId, AL_SOURCE_STATE, &state);
 660
 661         int64_t streampos = mStream->getPosition();
 662         if(state != AL_STOPPED)
 663         {
 664             // The amount of samples in the queue waiting to play
 665             ALuint inqueue = queued*mStream->getUpdateLength() - srcpos;
 666             if(!mStream->hasLooped())
 667             {
 668                 // A non-looped stream should never have more samples queued
 669                 // than have been read...
 670                 streampos = std::max<int64_t>(streampos, inqueue) - inqueue;
 671             }
 672             else
 673             {
 674                 streampos -= inqueue;
 675                 int64_t looplen = mStream->getLoopEnd() - mStream->getLoopStart();
 676                 while(streampos < mStream->getLoopStart())
 677                     streampos += looplen;
 678             }
 679         }
 680
 681         ret.first = streampos;
 682         return ret;
 683     }
 684
 685     ALint srcpos = 0;
 686     if(mContext->hasExtension(SOFT_source_latency))
 687     {
 688         ALint64SOFT val[2];
 689         mContext->alGetSourcei64vSOFT(mId, AL_SAMPLE_OFFSET_LATENCY_SOFT, val);
 690         srcpos = val[0]>>32;
 691         ret.second = std::chrono::nanoseconds(val[1]);
 692     }
 693     else
 694         alGetSourcei(mId, AL_SAMPLE_OFFSET, &srcpos);
 695     ret.first = srcpos;
 696     return ret;
 697 }
 698
 699 std::pair<Seconds,Seconds> SourceImpl::getSecOffsetLatency() const
 700 {
 701     std::pair<Seconds,Seconds> ret{Seconds::zero(), Seconds::zero()};
 702     CheckContext(mContext);
 703     if(mId == 0) return ret;
 704
 705     if(mStream)
 706     {
 707         std::lock_guard<std::mutex> lock(mMutex);
 708         ALint queued = 0, state = -1;
 709         ALdouble srcpos = 0;
 710
 711         alGetSourcei(mId, AL_BUFFERS_QUEUED, &queued);
 712         if(mContext->hasExtension(SOFT_source_latency))
 713         {
 714             ALdouble val[2];
 715             mContext->alGetSourcedvSOFT(mId, AL_SEC_OFFSET_LATENCY_SOFT, val);
 716             srcpos = val[0];
 717             ret.second = Seconds(val[1]);
 718         }
 719         else
 720         {
 721             ALfloat f;
 722             alGetSourcef(mId, AL_SEC_OFFSET, &f);
 723             srcpos = f;
 724         }
 725         alGetSourcei(mId, AL_SOURCE_STATE, &state);
 726
 727         ALdouble frac = 0.0;
 728         int64_t streampos = mStream->getPosition();
 729         if(state != AL_STOPPED)
 730         {
 731             ALdouble ipos;
 732             frac = std::modf(srcpos * mStream->getFrequency(), &ipos);
 733
 734             // The amount of samples in the queue waiting to play
 735             ALuint inqueue = queued*mStream->getUpdateLength() - (ALuint)ipos;
 736             if(!mStream->hasLooped())
 737             {
 738                 // A non-looped stream should never have more samples queued
 739                 // than have been read...
 740                 streampos = std::max<int64_t>(streampos, inqueue) - inqueue;
 741             }
 742             else
 743             {
 744                 streampos -= inqueue;
 745                 int64_t looplen = mStream->getLoopEnd() - mStream->getLoopStart();
 746                 while(streampos < mStream->getLoopStart())
 747                     streampos += looplen;
 748             }
 749         }
 750
 751         ret.first = Seconds((streampos+frac) / mStream->getFrequency());
 752         return ret;
 753     }
 754
 755     ALdouble srcpos = 0.0;
 756     if(mContext->hasExtension(SOFT_source_latency))
 757     {
 758         ALdouble val[2];
 759         mContext->alGetSourcedvSOFT(mId, AL_SEC_OFFSET_LATENCY_SOFT, val);
 760         srcpos = val[0];
 761         ret.second = Seconds(val[1]);
 762     }
 763     else
 764     {
 765         ALfloat f;
 766         alGetSourcef(mId, AL_SEC_OFFSET, &f);
 767         srcpos = f;
 768     }
 769     ret.first = Seconds(srcpos);
 770     return ret;
 771 }
 772
 773
 774 void SourceImpl::setLooping(bool looping)
 775 {
 776     CheckContext(mContext);
 777
 778     if(mId && !mStream)
 779         alSourcei(mId, AL_LOOPING, looping ? AL_TRUE : AL_FALSE);
 780     mLooping = looping;
 781 }
 782
 783
 784 void SourceImpl::setPitch(ALfloat pitch)
 785 {
 786     if(!(pitch > 0.0f))
 787         throw std::runtime_error("Pitch out of range");
 788     CheckContext(mContext);
 789     if(mId != 0)
 790         alSourcef(mId, AL_PITCH, pitch * (mGroup ? mGroup->getAppliedPitch() : 1.0f));
 791     mPitch = pitch;
 792 }
 793
 794
 795 void SourceImpl::setGain(ALfloat gain)
 796 {
 797     if(!(gain >= 0.0f))
 798         throw std::runtime_error("Gain out of range");
 799     CheckContext(mContext);
 800     if(mId != 0)
 801         alSourcef(mId, AL_GAIN, gain * (mGroup ? mGroup->getAppliedGain() : 1.0f));
 802     mGain = gain;
 803 }
 804
 805 void SourceImpl::setGainRange(ALfloat mingain, ALfloat maxgain)
 806 {
 807     if(!(mingain >= 0.0f && maxgain <= 1.0f && maxgain >= mingain))
 808         throw std::runtime_error("Gain range out of range");
 809     CheckContext(mContext);
 810     if(mId != 0)
 811     {
 812         alSourcef(mId, AL_MIN_GAIN, mingain);
 813         alSourcef(mId, AL_MAX_GAIN, maxgain);
 814     }
 815     mMinGain = mingain;
 816     mMaxGain = maxgain;
 817 }
 818
 819
 820 void SourceImpl::setDistanceRange(ALfloat refdist, ALfloat maxdist)
 821 {
 822     if(!(refdist >= 0.0f && maxdist <= std::numeric_limits<float>::max() && refdist <= maxdist))
 823         throw std::runtime_error("Distance range out of range");
 824     CheckContext(mContext);
 825     if(mId != 0)
 826     {
 827         alSourcef(mId, AL_REFERENCE_DISTANCE, refdist);
 828         alSourcef(mId, AL_MAX_DISTANCE, maxdist);
 829     }
 830     mRefDist = refdist;
 831     mMaxDist = maxdist;
 832 }
 833
 834
 835 void SourceImpl::set3DParameters(const Vector3 &position, const Vector3 &velocity, const Vector3 &direction)
 836 {
 837     CheckContext(mContext);
 838     if(mId != 0)
 839     {
 840         Batcher batcher = mContext->getBatcher();
 841         alSourcefv(mId, AL_POSITION, position.getPtr());
 842         alSourcefv(mId, AL_VELOCITY, velocity.getPtr());
 843         alSourcefv(mId, AL_DIRECTION, direction.getPtr());
 844     }
 845     mPosition = position;
 846     mVelocity = velocity;
 847     mDirection = direction;
 848 }
 849
 850 void SourceImpl::set3DParameters(const Vector3 &position, const Vector3 &velocity, std::pair<Vector3,Vector3> orientation)
 851 {
 852     static_assert(sizeof(orientation) == sizeof(ALfloat[6]), "Invalid Vector3 pair size");
 853     CheckContext(mContext);
 854     if(mId != 0)
 855     {
 856         Batcher batcher = mContext->getBatcher();
 857         alSourcefv(mId, AL_POSITION, position.getPtr());
 858         alSourcefv(mId, AL_VELOCITY, velocity.getPtr());
 859         if(mContext->hasExtension(EXT_BFORMAT))
 860             alSourcefv(mId, AL_ORIENTATION, orientation.first.getPtr());
 861         alSourcefv(mId, AL_DIRECTION, orientation.first.getPtr());
 862     }
 863     mPosition = position;
 864     mVelocity = velocity;
 865     mDirection = mOrientation[0] = orientation.first;
 866     mOrientation[1] = orientation.second;
 867 }
 868
 869
 870 void SourceImpl::setPosition(ALfloat x, ALfloat y, ALfloat z)
 871 {
 872     CheckContext(mContext);
 873     if(mId != 0)
 874         alSource3f(mId, AL_POSITION, x, y, z);
 875     mPosition[0] = x;
 876     mPosition[1] = y;
 877     mPosition[2] = z;
 878 }
 879
 880 void SourceImpl::setPosition(const ALfloat *pos)
 881 {
 882     CheckContext(mContext);
 883     if(mId != 0)
 884         alSourcefv(mId, AL_POSITION, pos);
 885     mPosition[0] = pos[0];
 886     mPosition[1] = pos[1];
 887     mPosition[2] = pos[2];
 888 }
 889
 890 void SourceImpl::setVelocity(ALfloat x, ALfloat y, ALfloat z)
 891 {
 892     CheckContext(mContext);
 893     if(mId != 0)
 894         alSource3f(mId, AL_VELOCITY, x, y, z);
 895     mVelocity[0] = x;
 896     mVelocity[1] = y;
 897     mVelocity[2] = z;
 898 }
 899
 900 void SourceImpl::setVelocity(const ALfloat *vel)
 901 {
 902     CheckContext(mContext);
 903     if(mId != 0)
 904         alSourcefv(mId, AL_VELOCITY, vel);
 905     mVelocity[0] = vel[0];
 906     mVelocity[1] = vel[1];
 907     mVelocity[2] = vel[2];
 908 }
 909
 910 void SourceImpl::setDirection(ALfloat x, ALfloat y, ALfloat z)
 911 {
 912     CheckContext(mContext);
 913     if(mId != 0)
 914         alSource3f(mId, AL_DIRECTION, x, y, z);
 915     mDirection[0] = x;
 916     mDirection[1] = y;
 917     mDirection[2] = z;
 918 }
 919
 920 void SourceImpl::setDirection(const ALfloat *dir)
 921 {
 922     CheckContext(mContext);
 923     if(mId != 0)
 924         alSourcefv(mId, AL_DIRECTION, dir);
 925     mDirection[0] = dir[0];
 926     mDirection[1] = dir[1];
 927     mDirection[2] = dir[2];
 928 }
 929
 930 void SourceImpl::setOrientation(ALfloat x1, ALfloat y1, ALfloat z1, ALfloat x2, ALfloat y2, ALfloat z2)
 931 {
 932     CheckContext(mContext);
 933     if(mId != 0)
 934     {
 935         ALfloat ori[6] = { x1, y1, z1, x2, y2, z2 };
 936         if(mContext->hasExtension(EXT_BFORMAT))
 937             alSourcefv(mId, AL_ORIENTATION, ori);
 938         alSourcefv(mId, AL_DIRECTION, ori);
 939     }
 940     mDirection[0] = mOrientation[0][0] = x1;
 941     mDirection[1] = mOrientation[0][1] = y1;
 942     mDirection[2] = mOrientation[0][2] = z1;
 943     mOrientation[1][0] = x2;
 944     mOrientation[1][1] = y2;
 945     mOrientation[1][2] = z2;
 946 }
 947
 948 void SourceImpl::setOrientation(const ALfloat *at, const ALfloat *up)
 949 {
 950     CheckContext(mContext);
 951     if(mId != 0)
 952     {
 953         ALfloat ori[6] = { at[0], at[1], at[2], up[0], up[1], up[2] };
 954         if(mContext->hasExtension(EXT_BFORMAT))
 955             alSourcefv(mId, AL_ORIENTATION, ori);
 956         alSourcefv(mId, AL_DIRECTION, ori);
 957     }
 958     mDirection[0] = mOrientation[0][0] = at[0];
 959     mDirection[1] = mOrientation[0][1] = at[1];
 960     mDirection[2] = mOrientation[0][2] = at[2];
 961     mOrientation[1][0] = up[0];
 962     mOrientation[1][1] = up[1];
 963     mOrientation[1][2] = up[2];
 964 }
 965
 966 void SourceImpl::setOrientation(const ALfloat *ori)
 967 {
 968     CheckContext(mContext);
 969     if(mId != 0)
 970     {
 971         if(mContext->hasExtension(EXT_BFORMAT))
 972             alSourcefv(mId, AL_ORIENTATION, ori);
 973         alSourcefv(mId, AL_DIRECTION, ori);
 974     }
 975     mDirection[0] = mOrientation[0][0] = ori[0];
 976     mDirection[1] = mOrientation[0][1] = ori[1];
 977     mDirection[2] = mOrientation[0][2] = ori[2];
 978     mOrientation[1][0] = ori[3];
 979     mOrientation[1][1] = ori[4];
 980     mOrientation[1][2] = ori[5];
 981 }
 982
 983
 984 void SourceImpl::setConeAngles(ALfloat inner, ALfloat outer)
 985 {
 986     if(!(inner >= 0.0f && outer <= 360.0f && outer >= inner))
 987         throw std::runtime_error("Cone angles out of range");
 988     CheckContext(mContext);
 989     if(mId != 0)
 990     {
 991         alSourcef(mId, AL_CONE_INNER_ANGLE, inner);
 992         alSourcef(mId, AL_CONE_OUTER_ANGLE, outer);
 993     }
 994     mConeInnerAngle = inner;
 995     mConeOuterAngle = outer;
 996 }
 997
 998 void SourceImpl::setOuterConeGains(ALfloat gain, ALfloat gainhf)
 999 {
1000     if(!(gain >= 0.0f && gain <= 1.0f && gainhf >= 0.0f && gainhf <= 1.0f))
1001         throw std::runtime_error("Outer cone gain out of range");
1002     CheckContext(mContext);
1003     if(mId != 0)
1004     {
1005         alSourcef(mId, AL_CONE_OUTER_GAIN, gain);
1006         if(mContext->hasExtension(EXT_EFX))
1007             alSourcef(mId, AL_CONE_OUTER_GAINHF, gainhf);
1008     }
1009     mConeOuterGain = gain;
1010     mConeOuterGainHF = gainhf;
1011 }
1012
1013
1014 void SourceImpl::setRolloffFactors(ALfloat factor, ALfloat roomfactor)
1015 {
1016     if(!(factor >= 0.0f && roomfactor >= 0.0f))
1017         throw std::runtime_error("Rolloff factor out of range");
1018     CheckContext(mContext);
1019     if(mId != 0)
1020     {
1021         alSourcef(mId, AL_ROLLOFF_FACTOR, factor);
1022         if(mContext->hasExtension(EXT_EFX))
1023             alSourcef(mId, AL_ROOM_ROLLOFF_FACTOR, roomfactor);
1024     }
1025     mRolloffFactor = factor;
1026     mRoomRolloffFactor = roomfactor;
1027 }
1028
1029 void SourceImpl::setDopplerFactor(ALfloat factor)
1030 {
1031     if(!(factor >= 0.0f && factor <= 1.0f))
1032         throw std::runtime_error("Doppler factor out of range");
1033     CheckContext(mContext);
1034     if(mId != 0)
1035         alSourcef(mId, AL_DOPPLER_FACTOR, factor);
1036     mDopplerFactor = factor;
1037 }
1038
1039 void SourceImpl::setAirAbsorptionFactor(ALfloat factor)
1040 {
1041     if(!(factor >= 0.0f && factor <= 10.0f))
1042         throw std::runtime_error("Absorption factor out of range");
1043     CheckContext(mContext);
1044     if(mId != 0 && mContext->hasExtension(EXT_EFX))
1045         alSourcef(mId, AL_AIR_ABSORPTION_FACTOR, factor);
1046     mAirAbsorptionFactor = factor;
1047 }
1048
1049 void SourceImpl::setRadius(ALfloat radius)
1050 {
1051     if(!(mRadius >= 0.0f))
1052         throw std::runtime_error("Radius out of range");
1053     CheckContext(mContext);
1054     if(mId != 0 && mContext->hasExtension(EXT_SOURCE_RADIUS))
1055         alSourcef(mId, AL_SOURCE_RADIUS, radius);
1056     mRadius = radius;
1057 }
1058
1059 void SourceImpl::setStereoAngles(ALfloat leftAngle, ALfloat rightAngle)
1060 {
1061     CheckContext(mContext);
1062     if(mId != 0 && mContext->hasExtension(EXT_STEREO_ANGLES))
1063     {
1064         ALfloat angles[2] = { leftAngle, rightAngle };
1065         alSourcefv(mId, AL_STEREO_ANGLES, angles);
1066     }
1067     mStereoAngles[0] = leftAngle;
1068     mStereoAngles[1] = rightAngle;
1069 }
1070
1071 void SourceImpl::set3DSpatialize(Spatialize spatialize)
1072 {
1073     CheckContext(mContext);
1074     if(mId != 0 && mContext->hasExtension(SOFT_source_spatialize))
1075         alSourcei(mId, AL_SOURCE_SPATIALIZE_SOFT, (ALint)spatialize);
1076     mSpatialize = spatialize;
1077 }
1078
1079 void SourceImpl::setResamplerIndex(ALsizei index)
1080 {
1081     if(index < 0)
1082         throw std::runtime_error("Resampler index out of range");
1083     index = std::min<ALsizei>(index, mContext->getAvailableResamplers().size());
1084     if(mId != 0 && mContext->hasExtension(SOFT_source_resampler))
1085         alSourcei(mId, AL_SOURCE_RESAMPLER_SOFT, index);
1086     mResampler = index;
1087 }
1088
1089 void SourceImpl::setRelative(bool relative)
1090 {
1091     CheckContext(mContext);
1092     if(mId != 0)
1093         alSourcei(mId, AL_SOURCE_RELATIVE, relative ? AL_TRUE : AL_FALSE);
1094     mRelative = relative;
1095 }
1096
1097 void SourceImpl::setGainAuto(bool directhf, bool send, bool sendhf)
1098 {
1099     CheckContext(mContext);
1100     if(mId != 0 && mContext->hasExtension(EXT_EFX))
1101     {
1102         alSourcei(mId, AL_DIRECT_FILTER_GAINHF_AUTO, directhf ? AL_TRUE : AL_FALSE);
1103         alSourcei(mId, AL_AUXILIARY_SEND_FILTER_GAIN_AUTO, send ? AL_TRUE : AL_FALSE);
1104         alSourcei(mId, AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO, sendhf ? AL_TRUE : AL_FALSE);
1105     }
1106     mDryGainHFAuto = directhf;
1107     mWetGainAuto = send;
1108     mWetGainHFAuto = sendhf;
1109 }
1110
1111
1112 void SourceImpl::setFilterParams(ALuint &filterid, const FilterParams &params)
1113 {
1114     if(!mContext->hasExtension(EXT_EFX))
1115         return;
1116
1117     if(!(params.mGain < 1.0f || params.mGainHF < 1.0f || params.mGainLF < 1.0f))
1118     {
1119         if(filterid)
1120             mContext->alFilteri(filterid, AL_FILTER_TYPE, AL_FILTER_NULL);
1121         return;
1122     }
1123
1124     alGetError();
1125     if(!filterid)
1126     {
1127         mContext->alGenFilters(1, &filterid);
1128         if(alGetError() != AL_NO_ERROR)
1129             throw std::runtime_error("Failed to create Filter");
1130     }
1131     bool filterset = false;
1132     if(params.mGainHF < 1.0f && params.mGainLF < 1.0f)
1133     {
1134         mContext->alFilteri(filterid, AL_FILTER_TYPE, AL_FILTER_BANDPASS);
1135         if(alGetError() == AL_NO_ERROR)
1136         {
1137             mContext->alFilterf(filterid, AL_BANDPASS_GAIN, std::min(params.mGain, 1.0f));
1138             mContext->alFilterf(filterid, AL_BANDPASS_GAINHF, std::min(params.mGainHF, 1.0f));
1139             mContext->alFilterf(filterid, AL_BANDPASS_GAINLF, std::min(params.mGainLF, 1.0f));
1140             filterset = true;
1141         }
1142     }
1143     if(!filterset && !(params.mGainHF < 1.0f) && params.mGainLF < 1.0f)
1144     {
1145         mContext->alFilteri(filterid, AL_FILTER_TYPE, AL_FILTER_HIGHPASS);
1146         if(alGetError() == AL_NO_ERROR)
1147         {
1148             mContext->alFilterf(filterid, AL_HIGHPASS_GAIN, std::min(params.mGain, 1.0f));
1149             mContext->alFilterf(filterid, AL_HIGHPASS_GAINLF, std::min(params.mGainLF, 1.0f));
1150             filterset = true;
1151         }
1152     }
1153     if(!filterset)
1154     {
1155         mContext->alFilteri(filterid, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
1156         if(alGetError() == AL_NO_ERROR)
1157         {
1158             mContext->alFilterf(filterid, AL_LOWPASS_GAIN, std::min(params.mGain, 1.0f));
1159             mContext->alFilterf(filterid, AL_LOWPASS_GAINHF, std::min(params.mGainHF, 1.0f));
1160             filterset = true;
1161         }
1162     }
1163 }
1164
1165
1166 void SourceImpl::setDirectFilter(const FilterParams &filter)
1167 {
1168     if(!(filter.mGain >= 0.0f && filter.mGainHF >= 0.0f && filter.mGainLF >= 0.0f))
1169         throw std::runtime_error("Gain value out of range");
1170     CheckContext(mContext);
1171
1172     setFilterParams(mDirectFilter, filter);
1173     if(mId)
1174         alSourcei(mId, AL_DIRECT_FILTER, mDirectFilter);
1175 }
1176
1177 void SourceImpl::setSendFilter(ALuint send, const FilterParams &filter)
1178 {
1179     if(!(filter.mGain >= 0.0f && filter.mGainHF >= 0.0f && filter.mGainLF >= 0.0f))
1180         throw std::runtime_error("Gain value out of range");
1181     CheckContext(mContext);
1182
1183     SendPropMap::iterator siter = mEffectSlots.find(send);
1184     if(siter == mEffectSlots.end())
1185     {
1186         ALuint filterid = 0;
1187
1188         setFilterParams(filterid, filter);
1189         if(!filterid) return;
1190
1191         siter = mEffectSlots.insert(std::make_pair(send, SendProps(filterid))).first;
1192     }
1193     else
1194         setFilterParams(siter->second.mFilter, filter);
1195
1196     if(mId)
1197     {
1198         ALuint slotid = (siter->second.mSlot ? siter->second.mSlot->getId() : 0);
1199         alSource3i(mId, AL_AUXILIARY_SEND_FILTER, slotid, send, siter->second.mFilter);
1200     }
1201 }
1202
1203 void SourceImpl::setAuxiliarySend(AuxiliaryEffectSlot auxslot, ALuint send)
1204 {
1205     AuxiliaryEffectSlotImpl *slot = auxslot.getHandle();
1206     if(slot) CheckContext(slot->getContext());
1207     CheckContext(mContext);
1208
1209     SendPropMap::iterator siter = mEffectSlots.find(send);
1210     if(siter == mEffectSlots.end())
1211     {
1212         if(!slot) return;
1213         slot->addSourceSend(Source(this), send);
1214         siter = mEffectSlots.insert(std::make_pair(send, SendProps(slot))).first;
1215     }
1216     else if(siter->second.mSlot != slot)
1217     {
1218         if(slot) slot->addSourceSend(Source(this), send);
1219         if(siter->second.mSlot)
1220             siter->second.mSlot->removeSourceSend(Source(this), send);
1221         siter->second.mSlot = slot;
1222     }
1223
1224     if(mId)
1225     {
1226         ALuint slotid = (siter->second.mSlot ? siter->second.mSlot->getId() : 0);
1227         alSource3i(mId, AL_AUXILIARY_SEND_FILTER, slotid, send, siter->second.mFilter);
1228     }
1229 }
1230
1231 void SourceImpl::setAuxiliarySendFilter(AuxiliaryEffectSlot auxslot, ALuint send, const FilterParams &filter)
1232 {
1233     if(!(filter.mGain >= 0.0f && filter.mGainHF >= 0.0f && filter.mGainLF >= 0.0f))
1234         throw std::runtime_error("Gain value out of range");
1235     AuxiliaryEffectSlotImpl *slot = auxslot.getHandle();
1236     if(slot) CheckContext(slot->getContext());
1237     CheckContext(mContext);
1238
1239     SendPropMap::iterator siter = mEffectSlots.find(send);
1240     if(siter == mEffectSlots.end())
1241     {
1242         ALuint filterid = 0;
1243
1244         setFilterParams(filterid, filter);
1245         if(!filterid && !slot)
1246             return;
1247
1248         if(slot) slot->addSourceSend(Source(this), send);
1249         siter = mEffectSlots.insert(std::make_pair(send, SendProps(slot, filterid))).first;
1250     }
1251     else
1252     {
1253         if(siter->second.mSlot != slot)
1254         {
1255             if(slot) slot->addSourceSend(Source(this), send);
1256             if(siter->second.mSlot)
1257                 siter->second.mSlot->removeSourceSend(Source(this), send);
1258             siter->second.mSlot = slot;
1259         }
1260         setFilterParams(siter->second.mFilter, filter);
1261     }
1262
1263     if(mId)
1264     {
1265         ALuint slotid = (siter->second.mSlot ? siter->second.mSlot->getId() : 0);
1266         alSource3i(mId, AL_AUXILIARY_SEND_FILTER, slotid, send, siter->second.mFilter);
1267     }
1268 }
1269
1270
1271 void SourceImpl::release()
1272 {
1273     stop();
1274
1275     if(mDirectFilter)
1276         mContext->alDeleteFilters(1, &mDirectFilter);
1277     mDirectFilter = AL_FILTER_NULL;
1278
1279     for(auto &i : mEffectSlots)
1280     {
1281         if(i.second.mSlot)
1282             i.second.mSlot->removeSourceSend(Source(this), i.first);
1283         if(i.second.mFilter)
1284             mContext->alDeleteFilters(1, &i.second.mFilter);
1285     }
1286     mEffectSlots.clear();
1287
1288     resetProperties();
1289 }
1290
1291
1292 // Need to use these to avoid extraneous commas in macro parameter lists
1293 using UInt64NSecPair = std::pair<uint64_t,std::chrono::nanoseconds>;
1294 using SecondsPair = std::pair<Seconds,Seconds>;
1295 using ALfloatPair = std::pair<ALfloat,ALfloat>;
1296 using Vector3Pair = std::pair<Vector3,Vector3>;
1297 using BoolTriple = std::tuple<bool,bool,bool>;
1298
1299 DECL_THUNK1(void, Source, play,, Buffer)
1300 DECL_THUNK3(void, Source, play,, SharedPtr<Decoder>, ALuint, ALuint)
1301 DECL_THUNK0(void, Source, stop,)
1302 DECL_THUNK0(void, Source, pause,)
1303 DECL_THUNK0(void, Source, resume,)
1304 DECL_THUNK0(bool, Source, isPlaying, const)
1305 DECL_THUNK0(bool, Source, isPaused, const)
1306 DECL_THUNK1(void, Source, setPriority,, ALuint)
1307 DECL_THUNK0(ALuint, Source, getPriority, const)
1308 DECL_THUNK1(void, Source, setOffset,, uint64_t)
1309 DECL_THUNK0(UInt64NSecPair, Source, getSampleOffsetLatency, const)
1310 DECL_THUNK0(SecondsPair, Source, getSecOffsetLatency, const)
1311 DECL_THUNK1(void, Source, setLooping,, bool)
1312 DECL_THUNK0(bool, Source, getLooping, const)
1313 DECL_THUNK1(void, Source, setPitch,, ALfloat)
1314 DECL_THUNK0(ALfloat, Source, getPitch, const)
1315 DECL_THUNK1(void, Source, setGain,, ALfloat)
1316 DECL_THUNK0(ALfloat, Source, getGain, const)
1317 DECL_THUNK2(void, Source, setGainRange,, ALfloat, ALfloat)
1318 DECL_THUNK0(ALfloatPair, Source, getGainRange, const)
1319 DECL_THUNK2(void, Source, setDistanceRange,, ALfloat, ALfloat)
1320 DECL_THUNK0(ALfloatPair, Source, getDistanceRange, const)
1321 DECL_THUNK3(void, Source, set3DParameters,, const Vector3&, const Vector3&, const Vector3&)
1322 DECL_THUNK3(void, Source, set3DParameters,, const Vector3&, const Vector3&, Vector3Pair)
1323 DECL_THUNK3(void, Source, setPosition,, ALfloat, ALfloat, ALfloat)
1324 DECL_THUNK1(void, Source, setPosition,, const ALfloat*)
1325 DECL_THUNK0(Vector3, Source, getPosition, const)
1326 DECL_THUNK3(void, Source, setVelocity,, ALfloat, ALfloat, ALfloat)
1327 DECL_THUNK1(void, Source, setVelocity,, const ALfloat*)
1328 DECL_THUNK0(Vector3, Source, getVelocity, const)
1329 DECL_THUNK3(void, Source, setDirection,, ALfloat, ALfloat, ALfloat)
1330 DECL_THUNK1(void, Source, setDirection,, const ALfloat*)
1331 DECL_THUNK0(Vector3, Source, getDirection, const)
1332 DECL_THUNK6(void, Source, setOrientation,, ALfloat, ALfloat, ALfloat, ALfloat, ALfloat, ALfloat)
1333 DECL_THUNK2(void, Source, setOrientation,, const ALfloat*, const ALfloat*)
1334 DECL_THUNK1(void, Source, setOrientation,, const ALfloat*)
1335 DECL_THUNK0(Vector3Pair, Source, getOrientation, const)
1336 DECL_THUNK2(void, Source, setConeAngles,, ALfloat, ALfloat)
1337 DECL_THUNK0(ALfloatPair, Source, getConeAngles, const)
1338 DECL_THUNK2(void, Source, setOuterConeGains,, ALfloat, ALfloat)
1339 DECL_THUNK0(ALfloatPair, Source, getOuterConeGains, const)
1340 DECL_THUNK2(void, Source, setRolloffFactors,, ALfloat, ALfloat)
1341 DECL_THUNK0(ALfloatPair, Source, getRolloffFactors, const)
1342 DECL_THUNK1(void, Source, setDopplerFactor,, ALfloat)
1343 DECL_THUNK0(ALfloat, Source, getDopplerFactor, const)
1344 DECL_THUNK1(void, Source, setRelative,, bool)
1345 DECL_THUNK0(bool, Source, getRelative, const)
1346 DECL_THUNK1(void, Source, setRadius,, ALfloat)
1347 DECL_THUNK0(ALfloat, Source, getRadius, const)
1348 DECL_THUNK2(void, Source, setStereoAngles,, ALfloat, ALfloat)
1349 DECL_THUNK0(ALfloatPair, Source, getStereoAngles, const)
1350 DECL_THUNK1(void, Source, set3DSpatialize,, Spatialize)
1351 DECL_THUNK0(Spatialize, Source, get3DSpatialize, const)
1352 DECL_THUNK1(void, Source, setResamplerIndex,, ALsizei)
1353 DECL_THUNK0(ALsizei, Source, getResamplerIndex, const)
1354 DECL_THUNK1(void, Source, setAirAbsorptionFactor,, ALfloat)
1355 DECL_THUNK0(ALfloat, Source, getAirAbsorptionFactor, const)
1356 DECL_THUNK3(void, Source, setGainAuto,, bool, bool, bool)
1357 DECL_THUNK0(BoolTriple, Source, getGainAuto, const)
1358 DECL_THUNK1(void, Source, setDirectFilter,, const FilterParams&)
1359 DECL_THUNK2(void, Source, setSendFilter,, ALuint, const FilterParams&)
1360 DECL_THUNK2(void, Source, setAuxiliarySend,, AuxiliaryEffectSlot, ALuint)
1361 DECL_THUNK3(void, Source, setAuxiliarySendFilter,, AuxiliaryEffectSlot, ALuint, const FilterParams&)
1362 void Source::release()
1363 {
1364     pImpl->release();
1365     pImpl = nullptr;
1366 }
1367
1368 }