src/CAudio.cpp

   1 /*
   2 Copyright © 2004 Parallel Realities
   3 Copyright © 2007-2008 Kővágó Zoltán <DirtY.iCE.hu@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13
  14 See the GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19
  20 */
  21
  22 #include <stdexcept>
  23
  24 #include "CAudio.h"
  25 #include "physfs/physfs.hpp"
  26
  27 Audio::Audio()
  28 {
  29         output = 2;
  30         useSound = true;
  31         useMusic = true;
  32
  33         for (int i = 0 ; i < MAX_SOUNDS ; i++)
  34         {
  35                 sound[i] = NULL;
  36         }
  37
  38         music = NULL;
  39         quickSound = NULL;
  40
  41         strcpy(levelMusicName, "");
  42 }
  43
  44 void Audio::setSoundVolume(int soundVolume)
  45 {
  46         this->soundVolume = soundVolume;
  47         if (engine->useAudio)
  48                 Mix_Volume(-1, soundVolume);
  49 }
  50
  51 void Audio::setMusicVolume(int musicVolume)
  52 {
  53         this->musicVolume = musicVolume;
  54         if (engine->useAudio)
  55         {
  56                 Mix_VolumeMusic(musicVolume);
  57         }
  58 }
  59
  60 void Audio::registerEngine(Engine *engine)
  61 {
  62         this->engine = engine;
  63 }
  64
  65 /**
  66  * Loads a sound file
  67  * @param i: the id to load the sound to
  68  * @param filename: the file to load (relative to datadir)
  69  */
  70
  71 bool Audio::loadSound(int i, const char *filename)
  72 {
  73         if (!engine->useAudio)
  74         {
  75                 return true;
  76         }
  77
  78         if (i >= MAX_SOUNDS)
  79         {
  80                 error << "Sound index is higher than maximum allowed (requested " << i << ", maximum is " << MAX_SOUNDS << ")" << std::endl
  81                           << "Ignoring, but this is an internal error, so report it!" << std::endl;
  82                 return false;
  83         }
  84
  85         if (sound[i] != NULL)
  86         {
  87                 Mix_FreeChunk(sound[i]);
  88                 sound[i] = NULL;
  89         }
  90
  91         try
  92         {
  93                 SDL_RWops * buffer = PhysFS::instance->RWopsFile(filename);
  94                 sound[i] = Mix_LoadWAV_RW(buffer, 1);
  95
  96                 if (!sound[i])
  97                 {
  98                         Exception::SdlMixerError e(AT);
  99                         e.AddInfo("Mix_GetError()", Mix_GetError());
 100                         e.AddInfo("File tried to load", filename);
 101                         throw e;
 102                 }
 103         }
 104         catch (const Exception::Base& e)
 105         {
 106                 error << e.GetDesc() << std::endl;
 107                 return false;
 108         }
 109         catch (const std::exception& e)
 110         {
 111                 error << "Failed to load '" << filename << "'" << std::endl << "The error was: " << e.what() << std::endl;
 112                 return false;
 113         }
 114         catch (...)
 115         {
 116                 error << "Failed to load '" << filename << "'" << std::endl << "Unknown error while loading." << std::endl;
 117                 return false;
 118         }
 119
 120         return true;
 121 }
 122
 123 bool Audio::loadMusic(const char *filename)
 124 {
 125         if (!engine->useAudio)
 126         {
 127                 return true;
 128         }
 129
 130         if (music != NULL)
 131         {
 132                 Mix_HaltMusic();
 133                 SDL_Delay(5);
 134                 Mix_FreeMusic(music);
 135                 music = NULL;
 136                 SDL_FreeRW(music_rwops);
 137         }
 138
 139
 140         try
 141         {
 142                 music_rwops = PhysFS::instance->RWopsFile(filename);
 143                 music = Mix_LoadMUS_RW(music_rwops);
 144
 145                 if (!music)
 146                 {
 147                         Exception::SdlMixerError e(AT);
 148                         e.AddInfo("Mix_GetError()", Mix_GetError());
 149                         e.AddInfo("File tried to load", filename);
 150                         throw e;
 151                 }
 152         }
 153         catch (const Exception::Base& e)
 154         {
 155                 error << e.GetDesc() << std::endl;
 156                 return false;
 157         }
 158         catch (const std::exception& e)
 159         {
 160                 error << "Failed to load '" << filename << "'" << std::endl << "The error was: " << e.what() << std::endl;
 161                 return false;
 162         }
 163         catch (...)
 164         {
 165                 error << "Failed to load '" << filename << "'" << std::endl << "Unknown error while loading." << std::endl;
 166                 return false;
 167         }
 168
 169         strcpy(levelMusicName, filename);
 170
 171         return true;
 172 }
 173
 174 void Audio::playSound(int snd, int channel)
 175 {
 176         if ((!engine->useAudio) || (soundVolume == 0))
 177                 return;
 178
 179         if (!output)
 180         {
 181                 return;
 182         }
 183
 184         Mix_Volume(channel, soundVolume);
 185
 186         Mix_PlayChannel(channel, sound[snd], 0);
 187 }
 188
 189 void Audio::playMusic()
 190 {
 191         if (!engine->useAudio)
 192                 return;
 193
 194         if (!output)
 195         {
 196                 return;
 197         }
 198
 199         Mix_PlayMusic(music, -1);
 200
 201         Mix_VolumeMusic(musicVolume);
 202 }
 203
 204 void Audio::playMusicOnce()
 205 {
 206         if (!engine->useAudio)
 207                 return;
 208
 209         if (!output)
 210         {
 211                 return;
 212         }
 213
 214         Mix_PlayMusic(music, 0);
 215
 216         Mix_VolumeMusic(musicVolume);
 217 }
 218
 219 bool Audio::loadGameOverMusic()
 220 {
 221         #if DEMO
 222                 return true;
 223         #endif
 224
 225         return loadMusic("music/friendDied.mod");
 226 }
 227
 228 bool Audio::reloadLevelMusic()
 229 {
 230         // remove the Game Over music first...
 231
 232         if (music != NULL)
 233         {
 234                 Mix_HaltMusic();
 235                 SDL_Delay(5);
 236                 Mix_FreeMusic(music);
 237                 music = NULL;
 238         }
 239
 240         return loadMusic(levelMusicName);
 241 }
 242
 243 void Audio::playAmbiance()
 244 {
 245         if ((!engine->useAudio) || (soundVolume == 0))
 246                 return;
 247
 248         if (!output)
 249         {
 250                 return;
 251         }
 252
 253         Mix_PlayChannel(CH_AMBIANCE, sound[SND_AMBIANCE], -1);
 254 }
 255
 256 void Audio::stopAmbiance()
 257 {
 258         if ((!engine->useAudio) || (soundVolume == 0))
 259                 return;
 260
 261         Mix_HaltChannel(CH_AMBIANCE);
 262 }
 263
 264 int Audio::playMenuSound(int sound)
 265 {
 266         if ((!engine->useAudio) || (soundVolume == 0))
 267                 return sound;
 268
 269         if ((sound == 0) || (sound == 3))
 270                 return sound;
 271
 272         if (sound == 1)
 273                 playSound(SND_HIGHLIGHT, CH_ANY);
 274
 275         if (sound == 2)
 276                 playSound(SND_SELECT, CH_ANY);
 277
 278         return sound;
 279 }
 280
 281 void Audio::pause()
 282 {
 283         if (!engine->useAudio)
 284                 return;
 285
 286         for (int i = 0 ; i < 8 ; i++)
 287                 Mix_Pause(i);
 288
 289         Mix_PauseMusic();
 290 }
 291
 292 void Audio::resume()
 293 {
 294         if (!engine->useAudio)
 295                 return;
 296
 297         if (!output)
 298         {
 299                 return;
 300         }
 301
 302         for (int i = 0 ; i < 8 ; i++)
 303                 Mix_Resume(i);
 304
 305         Mix_ResumeMusic();
 306 }
 307
 308 void Audio::stopMusic()
 309 {
 310         if (!engine->useAudio)
 311                 return;
 312
 313         Mix_HaltMusic();
 314 }
 315
 316 void Audio::fadeMusic()
 317 {
 318         if (!engine->useAudio)
 319                 return;
 320
 321         Mix_FadeOutMusic(3500);
 322 }
 323
 324 void Audio::free()
 325 {
 326         for (int i = 0 ; i < MAX_SOUNDS - 3 ; i++)
 327         {
 328                 if (sound[i] != NULL)
 329                 {
 330                         Mix_FreeChunk(sound[i]);
 331                         sound[i] = NULL;
 332                 }
 333         }
 334
 335         if (music != NULL)
 336         {
 337                 Mix_HaltMusic();
 338                 SDL_Delay(5);
 339                 Mix_FreeMusic(music);
 340         }
 341
 342         music = NULL;
 343
 344         if (quickSound != NULL)
 345                 Mix_FreeChunk(quickSound);
 346
 347         quickSound = NULL;
 348 }
 349
 350 void Audio::destroy()
 351 {
 352         free();
 353
 354         for (int i = MAX_SOUNDS - 3 ; i < MAX_SOUNDS ; i++)
 355         {
 356                 if (sound[i] != NULL)
 357                 {
 358                         Mix_FreeChunk(sound[i]);
 359                         sound[i] = NULL;
 360                 }
 361         }
 362 }