src/sourcegroup.cpp

   1
   2 #include "sourcegroup.h"
   3
   4 #include <algorithm>
   5
   6 #include "source.h"
   7 #include "context.h"
   8
   9 namespace alure {
  10
  11 void SourceGroupImpl::insertSubGroup(SourceGroupImpl *group)
  12 {
  13     auto iter = std::lower_bound(mSubGroups.begin(), mSubGroups.end(), group);
  14     if(iter == mSubGroups.end() || *iter != group)
  15         mSubGroups.insert(iter, group);
  16 }
  17
  18 void SourceGroupImpl::eraseSubGroup(SourceGroupImpl *group)
  19 {
  20     auto iter = std::lower_bound(mSubGroups.begin(), mSubGroups.end(), group);
  21     if(iter != mSubGroups.end() && *iter == group) mSubGroups.erase(iter);
  22 }
  23
  24
  25 void SourceGroupImpl::unsetParent()
  26 {
  27     mParent = nullptr;
  28     update(1.0f, 1.0f);
  29 }
  30
  31 void SourceGroupImpl::update(ALfloat gain, ALfloat pitch)
  32 {
  33     mParentProps.mGain = gain;
  34     mParentProps.mPitch = pitch;
  35
  36     gain *= mGain;
  37     pitch *= mPitch;
  38     for(SourceImpl *alsrc : mSources)
  39         alsrc->groupPropUpdate(gain, pitch);
  40     for(SourceGroupImpl *group : mSubGroups)
  41         group->update(gain, pitch);
  42 }
  43
  44
  45 bool SourceGroupImpl::findInSubGroups(SourceGroupImpl *group) const
  46 {
  47     auto iter = std::lower_bound(mSubGroups.begin(), mSubGroups.end(), group);
  48     if(iter != mSubGroups.end() && *iter == group) return true;
  49
  50     for(SourceGroupImpl *grp : mSubGroups)
  51     {
  52         if(grp->findInSubGroups(group))
  53             return true;
  54     }
  55     return false;
  56 }
  57
  58
  59 void SourceGroupImpl::insertSource(SourceImpl *source)
  60 {
  61     auto iter = std::lower_bound(mSources.begin(), mSources.end(), source);
  62     if(iter == mSources.end() || *iter != source)
  63         mSources.insert(iter, source);
  64 }
  65
  66 void SourceGroupImpl::eraseSource(SourceImpl *source)
  67 {
  68     auto iter = std::lower_bound(mSources.begin(), mSources.end(), source);
  69     if(iter != mSources.end() && *iter == source)
  70         mSources.erase(iter);
  71 }
  72
  73
  74 DECL_THUNK1(void, SourceGroup, setParentGroup,, SourceGroup)
  75 void SourceGroupImpl::setParentGroup(SourceGroup group)
  76 {
  77     CheckContext(mContext);
  78
  79     SourceGroupImpl *parent = group.getHandle();
  80     if(!parent)
  81     {
  82         if(mParent)
  83             mParent->eraseSubGroup(this);
  84         mParent = nullptr;
  85         update(1.0f, 1.0f);
  86     }
  87     else
  88     {
  89         if(this == parent || findInSubGroups(parent))
  90             throw std::runtime_error("Attempted circular group chain");
  91
  92         parent->insertSubGroup(this);
  93
  94         Batcher batcher = mContext.getBatcher();
  95         if(mParent)
  96             mParent->eraseSubGroup(this);
  97         mParent = parent;
  98         update(mParent->getAppliedGain(), mParent->getAppliedPitch());
  99     }
 100 }
 101
 102
 103 DECL_THUNK0(Vector<Source>, SourceGroup, getSources, const)
 104 Vector<Source> SourceGroupImpl::getSources() const
 105 {
 106     Vector<Source> ret;
 107     ret.reserve(mSources.size());
 108     for(SourceImpl *src : mSources)
 109         ret.emplace_back(src);
 110     return ret;
 111 }
 112
 113 DECL_THUNK0(Vector<SourceGroup>, SourceGroup, getSubGroups, const)
 114 Vector<SourceGroup> SourceGroupImpl::getSubGroups() const
 115 {
 116     Vector<SourceGroup> ret;
 117     ret.reserve(mSubGroups.size());
 118     for(SourceGroupImpl *grp : mSubGroups)
 119         ret.emplace_back(grp);
 120     return ret;
 121 }
 122
 123
 124 DECL_THUNK1(void, SourceGroup, setGain,, ALfloat)
 125 void SourceGroupImpl::setGain(ALfloat gain)
 126 {
 127     if(!(gain >= 0.0f))
 128         throw std::out_of_range("Gain out of range");
 129     CheckContext(mContext);
 130     mGain = gain;
 131     gain *= mParentProps.mGain;
 132     ALfloat pitch = mPitch * mParentProps.mPitch;
 133     Batcher batcher = mContext.getBatcher();
 134     for(SourceImpl *alsrc : mSources)
 135         alsrc->groupPropUpdate(gain, pitch);
 136     for(SourceGroupImpl *group : mSubGroups)
 137         group->update(gain, pitch);
 138 }
 139
 140 DECL_THUNK1(void, SourceGroup, setPitch,, ALfloat)
 141 void SourceGroupImpl::setPitch(ALfloat pitch)
 142 {
 143     if(!(pitch > 0.0f))
 144         throw std::out_of_range("Pitch out of range");
 145     CheckContext(mContext);
 146     mPitch = pitch;
 147     ALfloat gain = mGain * mParentProps.mGain;
 148     pitch *= mParentProps.mPitch;
 149     Batcher batcher = mContext.getBatcher();
 150     for(SourceImpl *alsrc : mSources)
 151         alsrc->groupPropUpdate(gain, pitch);
 152     for(SourceGroupImpl *group : mSubGroups)
 153         group->update(gain, pitch);
 154 }
 155
 156
 157 void SourceGroupImpl::collectPlayingSourceIds(Vector<ALuint> &sourceids) const
 158 {
 159     for(SourceImpl *alsrc : mSources)
 160     {
 161         if(ALuint id = alsrc->getId())
 162             sourceids.push_back(id);
 163     }
 164     for(SourceGroupImpl *group : mSubGroups)
 165         group->collectPlayingSourceIds(sourceids);
 166 }
 167
 168 void SourceGroupImpl::updatePausedStatus() const
 169 {
 170     for(SourceImpl *alsrc : mSources)
 171         alsrc->checkPaused();
 172     for(SourceGroupImpl *group : mSubGroups)
 173         group->updatePausedStatus();
 174 }
 175
 176 DECL_THUNK0(void, SourceGroup, pauseAll, const)
 177 void SourceGroupImpl::pauseAll() const
 178 {
 179     CheckContext(mContext);
 180     auto lock = mContext.getSourceStreamLock();
 181
 182     Vector<ALuint> sourceids;
 183     sourceids.reserve(16);
 184     collectPlayingSourceIds(sourceids);
 185     if(!sourceids.empty())
 186     {
 187         alSourcePausev(static_cast<ALsizei>(sourceids.size()), sourceids.data());
 188         updatePausedStatus();
 189     }
 190     lock.unlock();
 191 }
 192
 193
 194 void SourceGroupImpl::collectPausedSourceIds(Vector<ALuint> &sourceids) const
 195 {
 196     for(SourceImpl *alsrc : mSources)
 197     {
 198         if(alsrc->isPaused())
 199             sourceids.push_back(alsrc->getId());
 200     }
 201     for(SourceGroupImpl *group : mSubGroups)
 202         group->collectPausedSourceIds(sourceids);
 203 }
 204
 205 void SourceGroupImpl::updatePlayingStatus() const
 206 {
 207     for(SourceImpl *alsrc : mSources)
 208         alsrc->unsetPaused();
 209     for(SourceGroupImpl *group : mSubGroups)
 210         group->updatePlayingStatus();
 211 }
 212
 213 DECL_THUNK0(void, SourceGroup, resumeAll, const)
 214 void SourceGroupImpl::resumeAll() const
 215 {
 216     CheckContext(mContext);
 217     auto lock = mContext.getSourceStreamLock();
 218
 219     Vector<ALuint> sourceids;
 220     sourceids.reserve(16);
 221     collectPausedSourceIds(sourceids);
 222     if(!sourceids.empty())
 223     {
 224         alSourcePlayv(static_cast<ALsizei>(sourceids.size()), sourceids.data());
 225         updatePlayingStatus();
 226     }
 227     lock.unlock();
 228 }
 229
 230
 231 void SourceGroupImpl::collectSourceIds(Vector<ALuint> &sourceids) const
 232 {
 233     for(SourceImpl *alsrc : mSources)
 234     {
 235         if(ALuint id = alsrc->getId())
 236             sourceids.push_back(id);
 237     }
 238     for(SourceGroupImpl *group : mSubGroups)
 239         group->collectSourceIds(sourceids);
 240 }
 241
 242 void SourceGroupImpl::updateStoppedStatus() const
 243 {
 244     for(SourceImpl *alsrc : mSources)
 245     {
 246         mContext.removePendingSource(alsrc);
 247         mContext.removeFadingSource(alsrc);
 248         mContext.removePlayingSource(alsrc);
 249         alsrc->makeStopped(false);
 250         mContext.send(&MessageHandler::sourceForceStopped, alsrc);
 251     }
 252     for(SourceGroupImpl *group : mSubGroups)
 253         group->updateStoppedStatus();
 254 }
 255
 256 DECL_THUNK0(void, SourceGroup, stopAll, const)
 257 void SourceGroupImpl::stopAll() const
 258 {
 259     CheckContext(mContext);
 260
 261     Vector<ALuint> sourceids;
 262     sourceids.reserve(16);
 263     collectSourceIds(sourceids);
 264     if(!sourceids.empty())
 265     {
 266         auto lock = mContext.getSourceStreamLock();
 267         alSourceRewindv(static_cast<ALsizei>(sourceids.size()), sourceids.data());
 268         updateStoppedStatus();
 269     }
 270 }
 271
 272
 273 void SourceGroup::destroy()
 274 {
 275     SourceGroupImpl *i = pImpl;
 276     pImpl = nullptr;
 277     i->destroy();
 278 }
 279 void SourceGroupImpl::destroy()
 280 {
 281     CheckContext(mContext);
 282     Batcher batcher = mContext.getBatcher();
 283     for(SourceImpl *source : mSources)
 284         source->unsetGroup();
 285     mSources.clear();
 286     for(SourceGroupImpl *group : mSubGroups)
 287         group->unsetParent();
 288     mSubGroups.clear();
 289     if(mParent)
 290         mParent->eraseSubGroup(this);
 291     mParent = nullptr;
 292
 293     mContext.freeSourceGroup(this);
 294 }
 295
 296
 297 DECL_THUNK0(SourceGroup, SourceGroup, getParentGroup, const)
 298 DECL_THUNK0(ALfloat, SourceGroup, getGain, const)
 299 DECL_THUNK0(ALfloat, SourceGroup, getPitch, const)
 300
 301 } // namespace alure