src/source.cpp

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