gemrb/plugins/OpenALAudio/AmbientMgrAL.cpp

   1 /* GemRB - Infinity Engine Emulator
   2  * Copyright (C) 2004 The GemRB Project
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12  * GNU General Public License for more details.
  13
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  *
  19  */
  20
  21 #include "AmbientMgrAL.h"
  22
  23 #include "OpenALAudio.h"
  24
  25 #include "Ambient.h"
  26 #include "Game.h"
  27 #include "Interface.h"
  28
  29 #include <cassert>
  30 #include <climits>
  31 #include <cmath>
  32 #include <cstdio>
  33
  34 #include <SDL.h>
  35
  36 // TODO: remove last dependencies on OpenAL, and then rename and move it?
  37
  38 // legal nop if already reset
  39 void AmbientMgrAL::reset()
  40 {
  41         if (NULL != player){
  42                 SDL_mutexP(mutex);
  43         }
  44         for (std::vector<AmbientSource *>::iterator it = ambientSources.begin(); it != ambientSources.end(); ++it) {
  45                 delete (*it);
  46         }
  47         ambientSources.clear();
  48         AmbientMgr::reset();
  49         if (NULL != player) {
  50                 SDL_CondSignal(cond);
  51                 SDL_mutexV(mutex);
  52                 SDL_WaitThread(player, NULL);
  53                 player = NULL;
  54         }
  55 }
  56
  57 void AmbientMgrAL::setAmbients(const std::vector<Ambient *> &a)
  58 {
  59         AmbientMgr::setAmbients(a);
  60         assert(NULL == player);
  61
  62         ambientSources.reserve(a.size());
  63         for (std::vector<Ambient *>::const_iterator it = a.begin(); it != a.end(); ++it) {
  64                 ambientSources.push_back(new AmbientSource(*it));
  65         }
  66         core->GetAudioDrv()->UpdateVolume( GEM_SND_VOL_AMBIENTS );
  67
  68         player = SDL_CreateThread(&play, (void *) this);
  69 }
  70
  71 void AmbientMgrAL::activate(const std::string &name)
  72 {
  73         if (NULL != player)
  74                 SDL_mutexP(mutex);
  75         AmbientMgr::activate(name);
  76         if (NULL != player) {
  77                 SDL_CondSignal(cond);
  78                 SDL_mutexV(mutex);
  79         }
  80 }
  81
  82 void AmbientMgrAL::activate()
  83 {
  84         if (NULL != player)
  85                 SDL_mutexP(mutex);
  86         AmbientMgr::activate();
  87         if (NULL != player) {
  88                 SDL_CondSignal(cond);
  89                 SDL_mutexV(mutex);
  90         }
  91 }
  92
  93 void AmbientMgrAL::deactivate(const std::string &name)
  94 {
  95         if (NULL != player)
  96                 SDL_mutexP(mutex);
  97         AmbientMgr::deactivate(name);
  98         if (NULL != player) {
  99                 SDL_CondSignal(cond);
 100                 SDL_mutexV(mutex);
 101         }
 102 }
 103
 104 void AmbientMgrAL::deactivate()
 105 {
 106         if (NULL != player)
 107                 SDL_mutexP(mutex);
 108         AmbientMgr::deactivate();
 109         hardStop();
 110         if (NULL != player)
 111                 SDL_mutexV(mutex);
 112 }
 113
 114 void AmbientMgrAL::hardStop()
 115 {
 116         for (std::vector<AmbientSource *>::iterator it = ambientSources.begin(); it != ambientSources.end(); ++it) {
 117                 (*it)->hardStop();
 118         }
 119 }
 120
 121 int AmbientMgrAL::play(void *am)
 122 {
 123         AmbientMgrAL * ambim = (AmbientMgrAL *) am;
 124         SDL_mutexP(ambim->mutex);
 125         while (0 != ambim->ambientSources.size()) {
 126                 if (NULL == core->GetGame()) { // we don't have any game, and we need one
 127                         break;
 128                 }
 129                 unsigned int delay = ambim->tick(SDL_GetTicks());
 130                 assert(delay > 0);
 131                 SDL_CondWaitTimeout(ambim->cond, ambim->mutex, delay);
 132         }
 133         SDL_mutexV(ambim->mutex);
 134         return 0;
 135 }
 136
 137 unsigned int AmbientMgrAL::tick(unsigned int ticks)
 138 {
 139         unsigned int delay = 60000; // wait one minute if all sources are off
 140
 141         if (!active)
 142                 return delay;
 143
 144         int xpos, ypos;
 145         core->GetAudioDrv()->GetListenerPos(xpos, ypos);
 146         Point listener;
 147         listener.x = (short) xpos;
 148         listener.y = (short) ypos;
 149
 150         ieDword timeslice = 1<<(((core->GetGame()->GameTime / 60 + 30) / 60 - 1) % 24);
 151
 152         for (std::vector<AmbientSource *>::iterator it = ambientSources.begin(); it != ambientSources.end(); ++it) {
 153                 unsigned int newdelay = (*it)->tick(ticks, listener, timeslice);
 154                 if (newdelay < delay)
 155                         delay = newdelay;
 156         }
 157         return delay;
 158 }
 159
 160 AmbientMgrAL::AmbientSource::AmbientSource(const Ambient *a)
 161 : stream(-1), ambient(a), lastticks(0), enqueued(0), loaded(false)
 162 {
 163         // TODO: wait random amount of time before beginning?
 164 }
 165
 166 void AmbientMgrAL::AmbientSource::ensureLoaded()
 167 {
 168         // TODO: implement this after caching in ACMImp is done
 169         if (loaded) return;
 170
 171         unsigned int i=ambient->sounds.size();
 172         soundrefs.reserve(i);
 173         while(i--) {
 174                 // TODO: cache this sound
 175                 // (and skip it if it turns out to be invalid)
 176                 soundrefs.push_back(ambient->sounds[i]);
 177         }
 178
 179         loaded = true;
 180 }
 181
 182 AmbientMgrAL::AmbientSource::~AmbientSource()
 183 {
 184         if (stream >= 0) {
 185                 core->GetAudioDrv()->ReleaseStream(stream, true);
 186                 stream = -1;
 187         }
 188 }
 189
 190 unsigned int AmbientMgrAL::AmbientSource::tick(unsigned int ticks, Point listener, ieDword timeslice)
 191 {
 192         /* if we are out of sounds do nothing */
 193         if(!ambient->sounds.size()) {
 194                 return UINT_MAX;
 195         }
 196         if (loaded && soundrefs.empty()) return UINT_MAX;
 197
 198         if ((! (ambient->getFlags() & IE_AMBI_ENABLED)) || (! ambient->getAppearance()&timeslice)) {
 199                 // disabled
 200
 201                 if (stream >= 0) {
 202                         // release the stream without immediately stopping it
 203                         core->GetAudioDrv()->ReleaseStream(stream, false);
 204                 }
 205                 return UINT_MAX;
 206         }
 207
 208         int delay = ambient->getInterval() * 1000;
 209         int left = lastticks - ticks + delay;
 210         if (0 < left) // we are still waiting
 211                 return left;
 212         if (enqueued > 0) // we have already played that much
 213                 enqueued += left;
 214         if (enqueued < 0)
 215                 enqueued = 0;
 216
 217         lastticks = ticks;
 218         if (0 == delay) // it's a non-stop ambient, so in any case wait only a sec
 219                 delay = 1000;
 220
 221         if (! (ambient->getFlags() & IE_AMBI_MAIN) && !isHeard( listener )) { // we are out of range
 222                 if (delay > 500) {
 223                         // release stream if we're inactive for a while
 224                         core->GetAudioDrv()->ReleaseStream(stream);
 225                 }
 226                 return delay;
 227         }
 228
 229         ensureLoaded();
 230         if (soundrefs.empty()) return UINT_MAX;
 231
 232         if (stream < 0) {
 233                 // we need to allocate a stream
 234                 stream = core->GetAudioDrv()->SetupNewStream(ambient->getOrigin().x, ambient->getOrigin().y, ambient->getHeight(), ambient->getGain(), (ambient->getFlags() & IE_AMBI_POINT), true);
 235
 236                 if (stream == -1) {
 237                         // no streams available...
 238                         // Try again later
 239                         return delay;
 240                 }
 241         }
 242
 243
 244         /* it seems that the following (commented out) is not the purpose of the perset field, as
 245         it leads to ambients playing non-stop and queues overfilled */
 246 /*      int leftNum = ambient -> getPerset(); */
 247         int leftNum = 1;
 248         int leftMS = 0;
 249         if (0 == ambient->getInterval()) {
 250                 leftNum = 0;
 251                 leftMS = 1000 - enqueued; // let's have at least 1 second worth queue
 252         }
 253
 254
 255         while (0 < leftNum || 0 < leftMS) {
 256                 int len = enqueue();
 257                 if (len < 0) break;
 258                 --leftNum;
 259                 leftMS -= len;
 260                 enqueued += len;
 261         }
 262
 263         return delay;
 264 }
 265
 266 /* enqueues a random sound and returns its length */
 267 int AmbientMgrAL::AmbientSource::enqueue()
 268 {
 269         if (soundrefs.empty()) return -1;
 270         if (stream < 0) return -1;
 271         int index = rand() % soundrefs.size();
 272         //printf("Playing ambient %p, %s, %d/%ld on stream %d\n", (void*)this, soundrefs[index], index, soundrefs.size(), stream);
 273         return core->GetAudioDrv()->QueueAmbient(stream, soundrefs[index]);
 274 }
 275
 276 bool AmbientMgrAL::AmbientSource::isHeard(const Point &listener) const
 277 {
 278         int xdist =listener.x - ambient->getOrigin().x;
 279         int ydist =listener.y - ambient->getOrigin().y;
 280         int dist = (int) sqrt( (double) (xdist * xdist + ydist * ydist) );
 281         return dist < ambient->getRadius();
 282 }
 283
 284 void AmbientMgrAL::AmbientSource::hardStop()
 285 {
 286         if (stream >= 0) {
 287                 core->GetAudioDrv()->ReleaseStream(stream, true);
 288                 stream = -1;
 289         }
 290 }
 291
 292 void AmbientMgrAL::UpdateVolume(unsigned short volume)
 293 {
 294         SDL_mutexP( mutex );
 295         for (std::vector<AmbientSource *>::iterator it = ambientSources.begin(); it != ambientSources.end(); ++it) {
 296                 (*it) -> SetVolume( volume );
 297         }
 298         SDL_mutexV( mutex );
 299 }
 300
 301 /* sets the overall volume (in percent)
 302  * the final volume is affected by the specific ambient gain
 303  */
 304 void AmbientMgrAL::AmbientSource::SetVolume(unsigned short volume)
 305 {
 306         if (stream >= 0) {
 307                 int v = volume;
 308                 v *= ambient->getGain();
 309                 v /= 100;
 310                 core->GetAudioDrv()->SetAmbientStreamVolume(stream, v);
 311         }
 312 }