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 ALSource::ALSource(ALContext *context)
 168   : mContext(context), mId(0), mBuffer(0), mGroup(nullptr), mIsAsync(false),
 169     mDirectFilter(AL_FILTER_NULL)
 170 {
 171     resetProperties();
 172 }
 173
 174 ALSource::~ALSource()
 175 {
 176 }
 177
 178
 179 void ALSource::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 ALSource::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 ALSource::setGroup(ALSourceGroup *group)
 288 {
 289     if(mGroup)
 290         mGroup->removeSource(Source(this));
 291     mGroup = group;
 292     groupUpdate();
 293 }
 294
 295 void ALSource::unsetGroup()
 296 {
 297     mGroup = nullptr;
 298     groupUpdate();
 299 }
 300
 301 void ALSource::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 ALSource::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 ALSource::play(Buffer buffer)
 329 {
 330     ALBuffer *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(mIsAsync.load(std::memory_order_acquire))
 339     {
 340         mContext->removeStream(this);
 341         mIsAsync.store(false, std::memory_order_release);
 342     }
 343
 344     if(mId == 0)
 345     {
 346         mId = mContext->getSourceId(mPriority);
 347         applyProperties(mLooping, (ALuint)std::min<uint64_t>(mOffset, std::numeric_limits<ALint>::max()));
 348     }
 349     else
 350     {
 351         alSourceRewind(mId);
 352         alSourcei(mId, AL_BUFFER, 0);
 353         alSourcei(mId, AL_LOOPING, mLooping ? AL_TRUE : AL_FALSE);
 354         alSourcei(mId, AL_SAMPLE_OFFSET, (ALuint)std::min<uint64_t>(mOffset, std::numeric_limits<ALint>::max()));
 355     }
 356     mOffset = 0;
 357
 358     mStream.reset();
 359
 360     if(mBuffer)
 361         mBuffer->removeSource(Source(this));
 362     mBuffer = albuf;
 363     mBuffer->addSource(Source(this));
 364
 365     alSourcei(mId, AL_BUFFER, mBuffer->getId());
 366     alSourcePlay(mId);
 367     mPaused.store(false, std::memory_order_release);
 368 }
 369
 370 void ALSource::play(SharedPtr<Decoder> decoder, ALuint updatelen, ALuint queuesize)
 371 {
 372     if(updatelen < 64)
 373         throw std::runtime_error("Update length out of range");
 374     if(queuesize < 2)
 375         throw std::runtime_error("Queue size out of range");
 376     CheckContext(mContext);
 377
 378     auto stream = MakeUnique<ALBufferStream>(decoder, updatelen, queuesize);
 379     stream->prepare();
 380
 381     if(mIsAsync.load(std::memory_order_acquire))
 382     {
 383         mContext->removeStream(this);
 384         mIsAsync.store(false, std::memory_order_release);
 385     }
 386
 387     if(mId == 0)
 388     {
 389         mId = mContext->getSourceId(mPriority);
 390         applyProperties(false, 0);
 391     }
 392     else
 393     {
 394         alSourceRewind(mId);
 395         alSourcei(mId, AL_BUFFER, 0);
 396         alSourcei(mId, AL_LOOPING, AL_FALSE);
 397         alSourcei(mId, AL_SAMPLE_OFFSET, 0);
 398     }
 399
 400     if(mBuffer)
 401         mBuffer->removeSource(Source(this));
 402     mBuffer = 0;
 403
 404     mStream = std::move(stream);
 405
 406     mStream->seek(mOffset);
 407     mOffset = 0;
 408
 409     for(ALuint i = 0;i < mStream->getNumUpdates();i++)
 410     {
 411         if(!mStream->streamMoreData(mId, mLooping))
 412             break;
 413     }
 414     alSourcePlay(mId);
 415     mPaused.store(false, std::memory_order_release);
 416
 417     mContext->addStream(this);
 418     mIsAsync.store(true, std::memory_order_release);
 419 }
 420
 421
 422 void ALSource::makeStopped()
 423 {
 424     if(mIsAsync.load(std::memory_order_acquire))
 425     {
 426         mContext->removeStreamNoLock(this);
 427         mIsAsync.store(false, std::memory_order_release);
 428     }
 429
 430     if(mId != 0)
 431     {
 432         alSourceRewind(mId);
 433         alSourcei(mId, AL_BUFFER, 0);
 434         if(mContext->hasExtension(EXT_EFX))
 435         {
 436             alSourcei(mId, AL_DIRECT_FILTER, AL_FILTER_NULL);
 437             for(auto &i : mEffectSlots)
 438                 alSource3i(mId, AL_AUXILIARY_SEND_FILTER, 0, i.first, AL_FILTER_NULL);
 439         }
 440         mContext->insertSourceId(mId);
 441         mId = 0;
 442     }
 443
 444     if(mBuffer)
 445         mBuffer->removeSource(Source(this));
 446     mBuffer = 0;
 447
 448     mStream.reset();
 449
 450     mPaused.store(false, std::memory_order_release);
 451 }
 452
 453 void ALSource::stop()
 454 {
 455     CheckContext(mContext);
 456     if(mIsAsync.load(std::memory_order_acquire))
 457     {
 458         mContext->removeStream(this);
 459         mIsAsync.store(false, std::memory_order_release);
 460     }
 461     makeStopped();
 462 }
 463
 464
 465 void ALSource::checkPaused()
 466 {
 467     if(mPaused.load(std::memory_order_acquire) || mId == 0)
 468         return;
 469
 470     ALint state = -1;
 471     alGetSourcei(mId, AL_SOURCE_STATE, &state);
 472     // Streaming sources may be in a stopped state if underrun
 473     mPaused.store((state == AL_PAUSED) ||
 474                   (state == AL_STOPPED && mStream && mStream->hasMoreData()),
 475                   std::memory_order_release);
 476 }
 477
 478 void ALSource::pause()
 479 {
 480     CheckContext(mContext);
 481     if(mPaused.load(std::memory_order_acquire))
 482         return;
 483
 484     if(mId != 0)
 485     {
 486         std::lock_guard<std::mutex> lock(mMutex);
 487         alSourcePause(mId);
 488         ALint state = -1;
 489         alGetSourcei(mId, AL_SOURCE_STATE, &state);
 490         // Streaming sources may be in a stopped state if underrun
 491         mPaused.store((state == AL_PAUSED) ||
 492                       (state == AL_STOPPED && mStream && mStream->hasMoreData()),
 493                       std::memory_order_release);
 494     }
 495 }
 496
 497 void ALSource::resume()
 498 {
 499     CheckContext(mContext);
 500     if(!mPaused.load(std::memory_order_acquire))
 501         return;
 502
 503     if(mId != 0)
 504         alSourcePlay(mId);
 505     mPaused.store(false, std::memory_order_release);
 506 }
 507
 508
 509 bool ALSource::isPlaying() const
 510 {
 511     CheckContext(mContext);
 512     if(mId == 0) return false;
 513
 514     ALint state = -1;
 515     alGetSourcei(mId, AL_SOURCE_STATE, &state);
 516     if(state == -1)
 517         throw std::runtime_error("Source state error");
 518
 519     return state == AL_PLAYING || (!mPaused.load(std::memory_order_acquire) &&
 520                                    mStream && mStream->hasMoreData());
 521 }
 522
 523 bool ALSource::isPaused() const
 524 {
 525     CheckContext(mContext);
 526     if(mId == 0) return false;
 527
 528     ALint state = -1;
 529     alGetSourcei(mId, AL_SOURCE_STATE, &state);
 530     if(state == -1)
 531         throw std::runtime_error("Source state error");
 532
 533     return state == AL_PAUSED || mPaused.load(std::memory_order_acquire);
 534 }
 535
 536
 537 ALint ALSource::refillBufferStream()
 538 {
 539     ALint processed;
 540     alGetSourcei(mId, AL_BUFFERS_PROCESSED, &processed);
 541     while(processed > 0)
 542     {
 543         ALuint buf;
 544         alSourceUnqueueBuffers(mId, 1, &buf);
 545         --processed;
 546     }
 547
 548     ALint queued;
 549     alGetSourcei(mId, AL_BUFFERS_QUEUED, &queued);
 550     for(;(ALuint)queued < mStream->getNumUpdates();queued++)
 551     {
 552         if(!mStream->streamMoreData(mId, mLooping))
 553             break;
 554     }
 555
 556     return queued;
 557 }
 558
 559
 560 void ALSource::updateNoCtxCheck()
 561 {
 562     if(mId == 0)
 563         return;
 564
 565     if(mStream)
 566     {
 567         if(!mIsAsync.load(std::memory_order_acquire))
 568         {
 569             stop();
 570             mContext->send(&MessageHandler::sourceStopped, Source(this));
 571         }
 572     }
 573     else
 574     {
 575         ALint state = -1;
 576         alGetSourcei(mId, AL_SOURCE_STATE, &state);
 577         if(state != AL_PLAYING && state != AL_PAUSED)
 578         {
 579             stop();
 580             mContext->send(&MessageHandler::sourceStopped, Source(this));
 581         }
 582     }
 583 }
 584
 585 bool ALSource::updateAsync()
 586 {
 587     std::lock_guard<std::mutex> lock(mMutex);
 588
 589     ALint queued = refillBufferStream();
 590     if(queued == 0)
 591     {
 592         mIsAsync.store(false, std::memory_order_release);
 593         return false;
 594     }
 595     if(!mPaused.load(std::memory_order_acquire))
 596     {
 597         ALint state = -1;
 598         alGetSourcei(mId, AL_SOURCE_STATE, &state);
 599         if(state != AL_PLAYING)
 600             alSourcePlay(mId);
 601     }
 602     return true;
 603 }
 604
 605
 606 void ALSource::setPriority(ALuint priority)
 607 {
 608     mPriority = priority;
 609 }
 610
 611
 612 void ALSource::setOffset(uint64_t offset)
 613 {
 614     CheckContext(mContext);
 615     if(mId == 0)
 616     {
 617         mOffset = offset;
 618         return;
 619     }
 620
 621     if(!mStream)
 622     {
 623         if(offset >= std::numeric_limits<ALint>::max())
 624             throw std::runtime_error("Offset out of range");
 625         alGetError();
 626         alSourcei(mId, AL_SAMPLE_OFFSET, (ALint)offset);
 627         if(alGetError() != AL_NO_ERROR)
 628             throw std::runtime_error("Offset out of range");
 629     }
 630     else
 631     {
 632         std::lock_guard<std::mutex> lock(mMutex);
 633         if(!mStream->seek(offset))
 634             throw std::runtime_error("Failed to seek to offset");
 635         alSourceRewind(mId);
 636         alSourcei(mId, AL_BUFFER, 0);
 637         ALint queued = refillBufferStream();
 638         if(queued > 0 && !mPaused)
 639             alSourcePlay(mId);
 640     }
 641 }
 642
 643 std::pair<uint64_t,std::chrono::nanoseconds> ALSource::getSampleOffsetLatency() const
 644 {
 645     CheckContext(mContext);
 646     if(mId == 0)
 647         return { 0, std::chrono::nanoseconds::zero() };
 648
 649     if(mStream)
 650     {
 651         std::lock_guard<std::mutex> lock(mMutex);
 652         ALint queued = 0, state = -1, srcpos = 0;
 653         std::chrono::nanoseconds latency(0);
 654
 655         alGetSourcei(mId, AL_BUFFERS_QUEUED, &queued);
 656         if(mContext->hasExtension(SOFT_source_latency))
 657         {
 658             ALint64SOFT val[2];
 659             mContext->alGetSourcei64vSOFT(mId, AL_SAMPLE_OFFSET_LATENCY_SOFT, val);
 660             srcpos = val[0]>>32;
 661             latency = std::chrono::nanoseconds(val[1]);
 662         }
 663         else
 664             alGetSourcei(mId, AL_SAMPLE_OFFSET, &srcpos);
 665         alGetSourcei(mId, AL_SOURCE_STATE, &state);
 666
 667         int64_t streampos = mStream->getPosition();
 668         if(state != AL_STOPPED)
 669         {
 670             // The amount of samples in the queue waiting to play
 671             ALuint inqueue = queued*mStream->getUpdateLength() - srcpos;
 672             if(!mStream->hasLooped())
 673             {
 674                 // A non-looped stream should never have more samples queued
 675                 // than have been read...
 676                 streampos = std::max<int64_t>(streampos, inqueue) - inqueue;
 677             }
 678             else
 679             {
 680                 streampos -= inqueue;
 681                 int64_t looplen = mStream->getLoopEnd() - mStream->getLoopStart();
 682                 while(streampos < mStream->getLoopStart())
 683                     streampos += looplen;
 684             }
 685         }
 686
 687         return { streampos, latency };
 688     }
 689
 690     std::chrono::nanoseconds latency(0);
 691     ALint srcpos = 0;
 692     if(mContext->hasExtension(SOFT_source_latency))
 693     {
 694         ALint64SOFT val[2];
 695         mContext->alGetSourcei64vSOFT(mId, AL_SAMPLE_OFFSET_LATENCY_SOFT, val);
 696         srcpos = val[0]>>32;
 697         latency = std::chrono::nanoseconds(val[1]);
 698     }
 699     else
 700         alGetSourcei(mId, AL_SAMPLE_OFFSET, &srcpos);
 701     return { srcpos, latency };
 702 }
 703
 704 std::pair<Seconds,Seconds> ALSource::getSecOffsetLatency() const
 705 {
 706     CheckContext(mContext);
 707     if(mId == 0)
 708         return { Seconds::zero(), Seconds::zero() };
 709
 710     if(mStream)
 711     {
 712         std::lock_guard<std::mutex> lock(mMutex);
 713         ALint queued = 0, state = -1;
 714         ALdouble srcpos = 0;
 715         Seconds latency(0.0);
 716
 717         alGetSourcei(mId, AL_BUFFERS_QUEUED, &queued);
 718         if(mContext->hasExtension(SOFT_source_latency))
 719         {
 720             ALdouble val[2];
 721             mContext->alGetSourcedvSOFT(mId, AL_SEC_OFFSET_LATENCY_SOFT, val);
 722             srcpos = val[0];
 723             latency = Seconds(val[1]);
 724         }
 725         else
 726         {
 727             ALfloat f;
 728             alGetSourcef(mId, AL_SEC_OFFSET, &f);
 729             srcpos = f;
 730         }
 731         alGetSourcei(mId, AL_SOURCE_STATE, &state);
 732
 733         ALdouble frac = 0.0;
 734         int64_t streampos = mStream->getPosition();
 735         if(state != AL_STOPPED)
 736         {
 737             ALdouble ipos;
 738             frac = std::modf(srcpos * mStream->getFrequency(), &ipos);
 739
 740             // The amount of samples in the queue waiting to play
 741             ALuint inqueue = queued*mStream->getUpdateLength() - (ALuint)ipos;
 742             if(!mStream->hasLooped())
 743             {
 744                 // A non-looped stream should never have more samples queued
 745                 // than have been read...
 746                 streampos = std::max<int64_t>(streampos, inqueue) - inqueue;
 747             }
 748             else
 749             {
 750                 streampos -= inqueue;
 751                 int64_t looplen = mStream->getLoopEnd() - mStream->getLoopStart();
 752                 while(streampos < mStream->getLoopStart())
 753                     streampos += looplen;
 754             }
 755         }
 756
 757         return { Seconds((streampos+frac) / mStream->getFrequency()), latency };
 758     }
 759
 760     ALdouble srcpos = 0.0;
 761     Seconds latency(0.0);
 762     if(mContext->hasExtension(SOFT_source_latency))
 763     {
 764         ALdouble val[2];
 765         mContext->alGetSourcedvSOFT(mId, AL_SEC_OFFSET_LATENCY_SOFT, val);
 766         srcpos = val[0];
 767         latency = Seconds(val[1]);
 768     }
 769     else
 770     {
 771         ALfloat f;
 772         alGetSourcef(mId, AL_SEC_OFFSET, &f);
 773         srcpos = f;
 774     }
 775     return { Seconds(srcpos), latency };
 776 }
 777
 778
 779 void ALSource::setLooping(bool looping)
 780 {
 781     CheckContext(mContext);
 782
 783     if(mId && !mStream)
 784         alSourcei(mId, AL_LOOPING, looping ? AL_TRUE : AL_FALSE);
 785     mLooping = looping;
 786 }
 787
 788
 789 void ALSource::setPitch(ALfloat pitch)
 790 {
 791     if(!(pitch > 0.0f))
 792         throw std::runtime_error("Pitch out of range");
 793     CheckContext(mContext);
 794     if(mId != 0)
 795         alSourcef(mId, AL_PITCH, pitch * (mGroup ? mGroup->getAppliedPitch() : 1.0f));
 796     mPitch = pitch;
 797 }
 798
 799
 800 void ALSource::setGain(ALfloat gain)
 801 {
 802     if(!(gain >= 0.0f))
 803         throw std::runtime_error("Gain out of range");
 804     CheckContext(mContext);
 805     if(mId != 0)
 806         alSourcef(mId, AL_GAIN, gain * (mGroup ? mGroup->getAppliedGain() : 1.0f));
 807     mGain = gain;
 808 }
 809
 810 void ALSource::setGainRange(ALfloat mingain, ALfloat maxgain)
 811 {
 812     if(!(mingain >= 0.0f && maxgain <= 1.0f && maxgain >= mingain))
 813         throw std::runtime_error("Gain range out of range");
 814     CheckContext(mContext);
 815     if(mId != 0)
 816     {
 817         alSourcef(mId, AL_MIN_GAIN, mingain);
 818         alSourcef(mId, AL_MAX_GAIN, maxgain);
 819     }
 820     mMinGain = mingain;
 821     mMaxGain = maxgain;
 822 }
 823
 824
 825 void ALSource::setDistanceRange(ALfloat refdist, ALfloat maxdist)
 826 {
 827     if(!(refdist >= 0.0f && maxdist <= std::numeric_limits<float>::max() && refdist <= maxdist))
 828         throw std::runtime_error("Distance range out of range");
 829     CheckContext(mContext);
 830     if(mId != 0)
 831     {
 832         alSourcef(mId, AL_REFERENCE_DISTANCE, refdist);
 833         alSourcef(mId, AL_MAX_DISTANCE, maxdist);
 834     }
 835     mRefDist = refdist;
 836     mMaxDist = maxdist;
 837 }
 838
 839
 840 void ALSource::set3DParameters(const Vector3 &position, const Vector3 &velocity, const Vector3 &direction)
 841 {
 842     CheckContext(mContext);
 843     if(mId != 0)
 844     {
 845         Batcher batcher = mContext->getBatcher();
 846         alSourcefv(mId, AL_POSITION, position.getPtr());
 847         alSourcefv(mId, AL_VELOCITY, velocity.getPtr());
 848         alSourcefv(mId, AL_DIRECTION, direction.getPtr());
 849     }
 850     mPosition = position;
 851     mVelocity = velocity;
 852     mDirection = direction;
 853 }
 854
 855 void ALSource::set3DParameters(const Vector3 &position, const Vector3 &velocity, std::pair<Vector3,Vector3> orientation)
 856 {
 857     static_assert(sizeof(orientation) == sizeof(ALfloat[6]), "Invalid Vector3 pair size");
 858     CheckContext(mContext);
 859     if(mId != 0)
 860     {
 861         Batcher batcher = mContext->getBatcher();
 862         alSourcefv(mId, AL_POSITION, position.getPtr());
 863         alSourcefv(mId, AL_VELOCITY, velocity.getPtr());
 864         if(mContext->hasExtension(EXT_BFORMAT))
 865             alSourcefv(mId, AL_ORIENTATION, orientation.first.getPtr());
 866         alSourcefv(mId, AL_DIRECTION, orientation.first.getPtr());
 867     }
 868     mPosition = position;
 869     mVelocity = velocity;
 870     mDirection = mOrientation[0] = orientation.first;
 871     mOrientation[1] = orientation.second;
 872 }
 873
 874
 875 void ALSource::setPosition(ALfloat x, ALfloat y, ALfloat z)
 876 {
 877     CheckContext(mContext);
 878     if(mId != 0)
 879         alSource3f(mId, AL_POSITION, x, y, z);
 880     mPosition[0] = x;
 881     mPosition[1] = y;
 882     mPosition[2] = z;
 883 }
 884
 885 void ALSource::setPosition(const ALfloat *pos)
 886 {
 887     CheckContext(mContext);
 888     if(mId != 0)
 889         alSourcefv(mId, AL_POSITION, pos);
 890     mPosition[0] = pos[0];
 891     mPosition[1] = pos[1];
 892     mPosition[2] = pos[2];
 893 }
 894
 895 void ALSource::setVelocity(ALfloat x, ALfloat y, ALfloat z)
 896 {
 897     CheckContext(mContext);
 898     if(mId != 0)
 899         alSource3f(mId, AL_VELOCITY, x, y, z);
 900     mVelocity[0] = x;
 901     mVelocity[1] = y;
 902     mVelocity[2] = z;
 903 }
 904
 905 void ALSource::setVelocity(const ALfloat *vel)
 906 {
 907     CheckContext(mContext);
 908     if(mId != 0)
 909         alSourcefv(mId, AL_VELOCITY, vel);
 910     mVelocity[0] = vel[0];
 911     mVelocity[1] = vel[1];
 912     mVelocity[2] = vel[2];
 913 }
 914
 915 void ALSource::setDirection(ALfloat x, ALfloat y, ALfloat z)
 916 {
 917     CheckContext(mContext);
 918     if(mId != 0)
 919         alSource3f(mId, AL_DIRECTION, x, y, z);
 920     mDirection[0] = x;
 921     mDirection[1] = y;
 922     mDirection[2] = z;
 923 }
 924
 925 void ALSource::setDirection(const ALfloat *dir)
 926 {
 927     CheckContext(mContext);
 928     if(mId != 0)
 929         alSourcefv(mId, AL_DIRECTION, dir);
 930     mDirection[0] = dir[0];
 931     mDirection[1] = dir[1];
 932     mDirection[2] = dir[2];
 933 }
 934
 935 void ALSource::setOrientation(ALfloat x1, ALfloat y1, ALfloat z1, ALfloat x2, ALfloat y2, ALfloat z2)
 936 {
 937     CheckContext(mContext);
 938     if(mId != 0)
 939     {
 940         ALfloat ori[6] = { x1, y1, z1, x2, y2, z2 };
 941         if(mContext->hasExtension(EXT_BFORMAT))
 942             alSourcefv(mId, AL_ORIENTATION, ori);
 943         alSourcefv(mId, AL_DIRECTION, ori);
 944     }
 945     mDirection[0] = mOrientation[0][0] = x1;
 946     mDirection[1] = mOrientation[0][1] = y1;
 947     mDirection[2] = mOrientation[0][2] = z1;
 948     mOrientation[1][0] = x2;
 949     mOrientation[1][1] = y2;
 950     mOrientation[1][2] = z2;
 951 }
 952
 953 void ALSource::setOrientation(const ALfloat *at, const ALfloat *up)
 954 {
 955     CheckContext(mContext);
 956     if(mId != 0)
 957     {
 958         ALfloat ori[6] = { at[0], at[1], at[2], up[0], up[1], up[2] };
 959         if(mContext->hasExtension(EXT_BFORMAT))
 960             alSourcefv(mId, AL_ORIENTATION, ori);
 961         alSourcefv(mId, AL_DIRECTION, ori);
 962     }
 963     mDirection[0] = mOrientation[0][0] = at[0];
 964     mDirection[1] = mOrientation[0][1] = at[1];
 965     mDirection[2] = mOrientation[0][2] = at[2];
 966     mOrientation[1][0] = up[0];
 967     mOrientation[1][1] = up[1];
 968     mOrientation[1][2] = up[2];
 969 }
 970
 971 void ALSource::setOrientation(const ALfloat *ori)
 972 {
 973     CheckContext(mContext);
 974     if(mId != 0)
 975     {
 976         if(mContext->hasExtension(EXT_BFORMAT))
 977             alSourcefv(mId, AL_ORIENTATION, ori);
 978         alSourcefv(mId, AL_DIRECTION, ori);
 979     }
 980     mDirection[0] = mOrientation[0][0] = ori[0];
 981     mDirection[1] = mOrientation[0][1] = ori[1];
 982     mDirection[2] = mOrientation[0][2] = ori[2];
 983     mOrientation[1][0] = ori[3];
 984     mOrientation[1][1] = ori[4];
 985     mOrientation[1][2] = ori[5];
 986 }
 987
 988
 989 void ALSource::setConeAngles(ALfloat inner, ALfloat outer)
 990 {
 991     if(!(inner >= 0.0f && outer <= 360.0f && outer >= inner))
 992         throw std::runtime_error("Cone angles out of range");
 993     CheckContext(mContext);
 994     if(mId != 0)
 995     {
 996         alSourcef(mId, AL_CONE_INNER_ANGLE, inner);
 997         alSourcef(mId, AL_CONE_OUTER_ANGLE, outer);
 998     }
 999     mConeInnerAngle = inner;
1000     mConeOuterAngle = outer;
1001 }
1002
1003 void ALSource::setOuterConeGains(ALfloat gain, ALfloat gainhf)
1004 {
1005     if(!(gain >= 0.0f && gain <= 1.0f && gainhf >= 0.0f && gainhf <= 1.0f))
1006         throw std::runtime_error("Outer cone gain out of range");
1007     CheckContext(mContext);
1008     if(mId != 0)
1009     {
1010         alSourcef(mId, AL_CONE_OUTER_GAIN, gain);
1011         if(mContext->hasExtension(EXT_EFX))
1012             alSourcef(mId, AL_CONE_OUTER_GAINHF, gainhf);
1013     }
1014     mConeOuterGain = gain;
1015     mConeOuterGainHF = gainhf;
1016 }
1017
1018
1019 void ALSource::setRolloffFactors(ALfloat factor, ALfloat roomfactor)
1020 {
1021     if(!(factor >= 0.0f && roomfactor >= 0.0f))
1022         throw std::runtime_error("Rolloff factor out of range");
1023     CheckContext(mContext);
1024     if(mId != 0)
1025     {
1026         alSourcef(mId, AL_ROLLOFF_FACTOR, factor);
1027         if(mContext->hasExtension(EXT_EFX))
1028             alSourcef(mId, AL_ROOM_ROLLOFF_FACTOR, roomfactor);
1029     }
1030     mRolloffFactor = factor;
1031     mRoomRolloffFactor = roomfactor;
1032 }
1033
1034 void ALSource::setDopplerFactor(ALfloat factor)
1035 {
1036     if(!(factor >= 0.0f && factor <= 1.0f))
1037         throw std::runtime_error("Doppler factor out of range");
1038     CheckContext(mContext);
1039     if(mId != 0)
1040         alSourcef(mId, AL_DOPPLER_FACTOR, factor);
1041     mDopplerFactor = factor;
1042 }
1043
1044 void ALSource::setAirAbsorptionFactor(ALfloat factor)
1045 {
1046     if(!(factor >= 0.0f && factor <= 10.0f))
1047         throw std::runtime_error("Absorption factor out of range");
1048     CheckContext(mContext);
1049     if(mId != 0 && mContext->hasExtension(EXT_EFX))
1050         alSourcef(mId, AL_AIR_ABSORPTION_FACTOR, factor);
1051     mAirAbsorptionFactor = factor;
1052 }
1053
1054 void ALSource::setRadius(ALfloat radius)
1055 {
1056     if(!(mRadius >= 0.0f))
1057         throw std::runtime_error("Radius out of range");
1058     CheckContext(mContext);
1059     if(mId != 0 && mContext->hasExtension(EXT_SOURCE_RADIUS))
1060         alSourcef(mId, AL_SOURCE_RADIUS, radius);
1061     mRadius = radius;
1062 }
1063
1064 void ALSource::setStereoAngles(ALfloat leftAngle, ALfloat rightAngle)
1065 {
1066     CheckContext(mContext);
1067     if(mId != 0 && mContext->hasExtension(EXT_STEREO_ANGLES))
1068     {
1069         ALfloat angles[2] = { leftAngle, rightAngle };
1070         alSourcefv(mId, AL_STEREO_ANGLES, angles);
1071     }
1072     mStereoAngles[0] = leftAngle;
1073     mStereoAngles[1] = rightAngle;
1074 }
1075
1076 void ALSource::set3DSpatialize(Spatialize spatialize)
1077 {
1078     CheckContext(mContext);
1079     if(mId != 0 && mContext->hasExtension(SOFT_source_spatialize))
1080         alSourcei(mId, AL_SOURCE_SPATIALIZE_SOFT, (ALint)spatialize);
1081     mSpatialize = spatialize;
1082 }
1083
1084 void ALSource::setResamplerIndex(ALsizei index)
1085 {
1086     if(index < 0)
1087         throw std::runtime_error("Resampler index out of range");
1088     index = std::min<ALsizei>(index, mContext->getAvailableResamplers().size());
1089     if(mId != 0 && mContext->hasExtension(SOFT_source_resampler))
1090         alSourcei(mId, AL_SOURCE_RESAMPLER_SOFT, index);
1091     mResampler = index;
1092 }
1093
1094 void ALSource::setRelative(bool relative)
1095 {
1096     CheckContext(mContext);
1097     if(mId != 0)
1098         alSourcei(mId, AL_SOURCE_RELATIVE, relative ? AL_TRUE : AL_FALSE);
1099     mRelative = relative;
1100 }
1101
1102 void ALSource::setGainAuto(bool directhf, bool send, bool sendhf)
1103 {
1104     CheckContext(mContext);
1105     if(mId != 0 && mContext->hasExtension(EXT_EFX))
1106     {
1107         alSourcei(mId, AL_DIRECT_FILTER_GAINHF_AUTO, directhf ? AL_TRUE : AL_FALSE);
1108         alSourcei(mId, AL_AUXILIARY_SEND_FILTER_GAIN_AUTO, send ? AL_TRUE : AL_FALSE);
1109         alSourcei(mId, AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO, sendhf ? AL_TRUE : AL_FALSE);
1110     }
1111     mDryGainHFAuto = directhf;
1112     mWetGainAuto = send;
1113     mWetGainHFAuto = sendhf;
1114 }
1115
1116
1117 void ALSource::setFilterParams(ALuint &filterid, const FilterParams &params)
1118 {
1119     if(!mContext->hasExtension(EXT_EFX))
1120         return;
1121
1122     if(!(params.mGain < 1.0f || params.mGainHF < 1.0f || params.mGainLF < 1.0f))
1123     {
1124         if(filterid)
1125             mContext->alFilteri(filterid, AL_FILTER_TYPE, AL_FILTER_NULL);
1126         return;
1127     }
1128
1129     alGetError();
1130     if(!filterid)
1131     {
1132         mContext->alGenFilters(1, &filterid);
1133         if(alGetError() != AL_NO_ERROR)
1134             throw std::runtime_error("Failed to create Filter");
1135     }
1136     bool filterset = false;
1137     if(params.mGainHF < 1.0f && params.mGainLF < 1.0f)
1138     {
1139         mContext->alFilteri(filterid, AL_FILTER_TYPE, AL_FILTER_BANDPASS);
1140         if(alGetError() == AL_NO_ERROR)
1141         {
1142             mContext->alFilterf(filterid, AL_BANDPASS_GAIN, std::min(params.mGain, 1.0f));
1143             mContext->alFilterf(filterid, AL_BANDPASS_GAINHF, std::min(params.mGainHF, 1.0f));
1144             mContext->alFilterf(filterid, AL_BANDPASS_GAINLF, std::min(params.mGainLF, 1.0f));
1145             filterset = true;
1146         }
1147     }
1148     if(!filterset && !(params.mGainHF < 1.0f) && params.mGainLF < 1.0f)
1149     {
1150         mContext->alFilteri(filterid, AL_FILTER_TYPE, AL_FILTER_HIGHPASS);
1151         if(alGetError() == AL_NO_ERROR)
1152         {
1153             mContext->alFilterf(filterid, AL_HIGHPASS_GAIN, std::min(params.mGain, 1.0f));
1154             mContext->alFilterf(filterid, AL_HIGHPASS_GAINLF, std::min(params.mGainLF, 1.0f));
1155             filterset = true;
1156         }
1157     }
1158     if(!filterset)
1159     {
1160         mContext->alFilteri(filterid, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
1161         if(alGetError() == AL_NO_ERROR)
1162         {
1163             mContext->alFilterf(filterid, AL_LOWPASS_GAIN, std::min(params.mGain, 1.0f));
1164             mContext->alFilterf(filterid, AL_LOWPASS_GAINHF, std::min(params.mGainHF, 1.0f));
1165             filterset = true;
1166         }
1167     }
1168 }
1169
1170
1171 void ALSource::setDirectFilter(const FilterParams &filter)
1172 {
1173     if(!(filter.mGain >= 0.0f && filter.mGainHF >= 0.0f && filter.mGainLF >= 0.0f))
1174         throw std::runtime_error("Gain value out of range");
1175     CheckContext(mContext);
1176
1177     setFilterParams(mDirectFilter, filter);
1178     if(mId)
1179         alSourcei(mId, AL_DIRECT_FILTER, mDirectFilter);
1180 }
1181
1182 void ALSource::setSendFilter(ALuint send, const FilterParams &filter)
1183 {
1184     if(!(filter.mGain >= 0.0f && filter.mGainHF >= 0.0f && filter.mGainLF >= 0.0f))
1185         throw std::runtime_error("Gain value out of range");
1186     CheckContext(mContext);
1187
1188     SendPropMap::iterator siter = mEffectSlots.find(send);
1189     if(siter == mEffectSlots.end())
1190     {
1191         ALuint filterid = 0;
1192
1193         setFilterParams(filterid, filter);
1194         if(!filterid) return;
1195
1196         siter = mEffectSlots.insert(std::make_pair(send, SendProps(filterid))).first;
1197     }
1198     else
1199         setFilterParams(siter->second.mFilter, filter);
1200
1201     if(mId)
1202     {
1203         ALuint slotid = (siter->second.mSlot ? siter->second.mSlot->getId() : 0);
1204         alSource3i(mId, AL_AUXILIARY_SEND_FILTER, slotid, send, siter->second.mFilter);
1205     }
1206 }
1207
1208 void ALSource::setAuxiliarySend(AuxiliaryEffectSlot auxslot, ALuint send)
1209 {
1210     ALAuxiliaryEffectSlot *slot = auxslot.getHandle();
1211     if(slot) CheckContext(slot->getContext());
1212     CheckContext(mContext);
1213
1214     SendPropMap::iterator siter = mEffectSlots.find(send);
1215     if(siter == mEffectSlots.end())
1216     {
1217         if(!slot) return;
1218         slot->addSourceSend(Source(this), send);
1219         siter = mEffectSlots.insert(std::make_pair(send, SendProps(slot))).first;
1220     }
1221     else if(siter->second.mSlot != slot)
1222     {
1223         if(slot) slot->addSourceSend(Source(this), send);
1224         if(siter->second.mSlot)
1225             siter->second.mSlot->removeSourceSend(Source(this), send);
1226         siter->second.mSlot = slot;
1227     }
1228
1229     if(mId)
1230     {
1231         ALuint slotid = (siter->second.mSlot ? siter->second.mSlot->getId() : 0);
1232         alSource3i(mId, AL_AUXILIARY_SEND_FILTER, slotid, send, siter->second.mFilter);
1233     }
1234 }
1235
1236 void ALSource::setAuxiliarySendFilter(AuxiliaryEffectSlot auxslot, ALuint send, const FilterParams &filter)
1237 {
1238     if(!(filter.mGain >= 0.0f && filter.mGainHF >= 0.0f && filter.mGainLF >= 0.0f))
1239         throw std::runtime_error("Gain value out of range");
1240     ALAuxiliaryEffectSlot *slot = auxslot.getHandle();
1241     if(slot) CheckContext(slot->getContext());
1242     CheckContext(mContext);
1243
1244     SendPropMap::iterator siter = mEffectSlots.find(send);
1245     if(siter == mEffectSlots.end())
1246     {
1247         ALuint filterid = 0;
1248
1249         setFilterParams(filterid, filter);
1250         if(!filterid && !slot)
1251             return;
1252
1253         if(slot) slot->addSourceSend(Source(this), send);
1254         siter = mEffectSlots.insert(std::make_pair(send, SendProps(slot, filterid))).first;
1255     }
1256     else
1257     {
1258         if(siter->second.mSlot != slot)
1259         {
1260             if(slot) slot->addSourceSend(Source(this), send);
1261             if(siter->second.mSlot)
1262                 siter->second.mSlot->removeSourceSend(Source(this), send);
1263             siter->second.mSlot = slot;
1264         }
1265         setFilterParams(siter->second.mFilter, filter);
1266     }
1267
1268     if(mId)
1269     {
1270         ALuint slotid = (siter->second.mSlot ? siter->second.mSlot->getId() : 0);
1271         alSource3i(mId, AL_AUXILIARY_SEND_FILTER, slotid, send, siter->second.mFilter);
1272     }
1273 }
1274
1275
1276 void ALSource::release()
1277 {
1278     CheckContext(mContext);
1279
1280     if(mIsAsync.load(std::memory_order_acquire))
1281     {
1282         mContext->removeStream(this);
1283         mIsAsync.store(false, std::memory_order_release);
1284     }
1285
1286     if(mId != 0)
1287     {
1288         alSourceRewind(mId);
1289         alSourcei(mId, AL_BUFFER, 0);
1290         if(mContext->hasExtension(EXT_EFX))
1291         {
1292             alSourcei(mId, AL_DIRECT_FILTER, AL_FILTER_NULL);
1293             for(auto &i : mEffectSlots)
1294                 alSource3i(mId, AL_AUXILIARY_SEND_FILTER, 0, i.first, AL_FILTER_NULL);
1295         }
1296         mContext->insertSourceId(mId);
1297         mId = 0;
1298     }
1299
1300     mContext->freeSource(this);
1301
1302     if(mDirectFilter)
1303         mContext->alDeleteFilters(1, &mDirectFilter);
1304     mDirectFilter = AL_FILTER_NULL;
1305
1306     for(auto &i : mEffectSlots)
1307     {
1308         if(i.second.mSlot)
1309             i.second.mSlot->removeSourceSend(Source(this), i.first);
1310         if(i.second.mFilter)
1311             mContext->alDeleteFilters(1, &i.second.mFilter);
1312     }
1313     mEffectSlots.clear();
1314
1315     if(mBuffer)
1316         mBuffer->removeSource(Source(this));
1317     mBuffer = 0;
1318
1319     mStream.reset();
1320
1321     resetProperties();
1322 }
1323
1324
1325 // Need to use these to avoid extraneous commas in macro parameter lists
1326 using UInt64NSecPair = std::pair<uint64_t,std::chrono::nanoseconds>;
1327 using SecondsPair = std::pair<Seconds,Seconds>;
1328 using ALfloatPair = std::pair<ALfloat,ALfloat>;
1329 using Vector3Pair = std::pair<Vector3,Vector3>;
1330 using BoolTriple = std::tuple<bool,bool,bool>;
1331
1332 DECL_THUNK1(void, Source, play,, Buffer)
1333 DECL_THUNK3(void, Source, play,, SharedPtr<Decoder>, ALuint, ALuint)
1334 DECL_THUNK0(void, Source, stop,)
1335 DECL_THUNK0(void, Source, pause,)
1336 DECL_THUNK0(void, Source, resume,)
1337 DECL_THUNK0(bool, Source, isPlaying, const)
1338 DECL_THUNK0(bool, Source, isPaused, const)
1339 DECL_THUNK1(void, Source, setPriority,, ALuint)
1340 DECL_THUNK0(ALuint, Source, getPriority, const)
1341 DECL_THUNK1(void, Source, setOffset,, uint64_t)
1342 DECL_THUNK0(UInt64NSecPair, Source, getSampleOffsetLatency, const)
1343 DECL_THUNK0(SecondsPair, Source, getSecOffsetLatency, const)
1344 DECL_THUNK1(void, Source, setLooping,, bool)
1345 DECL_THUNK0(bool, Source, getLooping, const)
1346 DECL_THUNK1(void, Source, setPitch,, ALfloat)
1347 DECL_THUNK0(ALfloat, Source, getPitch, const)
1348 DECL_THUNK1(void, Source, setGain,, ALfloat)
1349 DECL_THUNK0(ALfloat, Source, getGain, const)
1350 DECL_THUNK2(void, Source, setGainRange,, ALfloat, ALfloat)
1351 DECL_THUNK0(ALfloatPair, Source, getGainRange, const)
1352 DECL_THUNK2(void, Source, setDistanceRange,, ALfloat, ALfloat)
1353 DECL_THUNK0(ALfloatPair, Source, getDistanceRange, const)
1354 DECL_THUNK3(void, Source, set3DParameters,, const Vector3&, const Vector3&, const Vector3&)
1355 DECL_THUNK3(void, Source, set3DParameters,, const Vector3&, const Vector3&, Vector3Pair)
1356 DECL_THUNK3(void, Source, setPosition,, ALfloat, ALfloat, ALfloat)
1357 DECL_THUNK1(void, Source, setPosition,, const ALfloat*)
1358 DECL_THUNK0(Vector3, Source, getPosition, const)
1359 DECL_THUNK3(void, Source, setVelocity,, ALfloat, ALfloat, ALfloat)
1360 DECL_THUNK1(void, Source, setVelocity,, const ALfloat*)
1361 DECL_THUNK0(Vector3, Source, getVelocity, const)
1362 DECL_THUNK3(void, Source, setDirection,, ALfloat, ALfloat, ALfloat)
1363 DECL_THUNK1(void, Source, setDirection,, const ALfloat*)
1364 DECL_THUNK0(Vector3, Source, getDirection, const)
1365 DECL_THUNK6(void, Source, setOrientation,, ALfloat, ALfloat, ALfloat, ALfloat, ALfloat, ALfloat)
1366 DECL_THUNK2(void, Source, setOrientation,, const ALfloat*, const ALfloat*)
1367 DECL_THUNK1(void, Source, setOrientation,, const ALfloat*)
1368 DECL_THUNK0(Vector3Pair, Source, getOrientation, const)
1369 DECL_THUNK2(void, Source, setConeAngles,, ALfloat, ALfloat)
1370 DECL_THUNK0(ALfloatPair, Source, getConeAngles, const)
1371 DECL_THUNK2(void, Source, setOuterConeGains,, ALfloat, ALfloat)
1372 DECL_THUNK0(ALfloatPair, Source, getOuterConeGains, const)
1373 DECL_THUNK2(void, Source, setRolloffFactors,, ALfloat, ALfloat)
1374 DECL_THUNK0(ALfloatPair, Source, getRolloffFactors, const)
1375 DECL_THUNK1(void, Source, setDopplerFactor,, ALfloat)
1376 DECL_THUNK0(ALfloat, Source, getDopplerFactor, const)
1377 DECL_THUNK1(void, Source, setRelative,, bool)
1378 DECL_THUNK0(bool, Source, getRelative, const)
1379 DECL_THUNK1(void, Source, setRadius,, ALfloat)
1380 DECL_THUNK0(ALfloat, Source, getRadius, const)
1381 DECL_THUNK2(void, Source, setStereoAngles,, ALfloat, ALfloat)
1382 DECL_THUNK0(ALfloatPair, Source, getStereoAngles, const)
1383 DECL_THUNK1(void, Source, set3DSpatialize,, Spatialize)
1384 DECL_THUNK0(Spatialize, Source, get3DSpatialize, const)
1385 DECL_THUNK1(void, Source, setResamplerIndex,, ALsizei)
1386 DECL_THUNK0(ALsizei, Source, getResamplerIndex, const)
1387 DECL_THUNK1(void, Source, setAirAbsorptionFactor,, ALfloat)
1388 DECL_THUNK0(ALfloat, Source, getAirAbsorptionFactor, const)
1389 DECL_THUNK3(void, Source, setGainAuto,, bool, bool, bool)
1390 DECL_THUNK0(BoolTriple, Source, getGainAuto, const)
1391 DECL_THUNK1(void, Source, setDirectFilter,, const FilterParams&)
1392 DECL_THUNK2(void, Source, setSendFilter,, ALuint, const FilterParams&)
1393 DECL_THUNK2(void, Source, setAuxiliarySend,, AuxiliaryEffectSlot, ALuint)
1394 DECL_THUNK3(void, Source, setAuxiliarySendFilter,, AuxiliaryEffectSlot, ALuint, const FilterParams&)
1395 void Source::release()
1396 {
1397     pImpl->release();
1398     pImpl = nullptr;
1399 }
1400
1401 }