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 "console/console.hpp"
  26 #include "physfs/rwops.hpp"
  27
  28 Audio::Audio()
  29 {
  30         output = 2;
  31         useSound = true;
  32         useMusic = true;
  33
  34         for (int i = 0 ; i < MAX_SOUNDS ; i++)
  35         {
  36                 sound[i] = NULL;
  37         }
  38
  39         music = NULL;
  40         quickSound = NULL;
  41
  42         strcpy(levelMusicName, "");
  43 }
  44
  45 void Audio::setSoundVolume(int soundVolume)
  46 {
  47         this->soundVolume = soundVolume;
  48         if (engine->useAudio)
  49                 Mix_Volume(-1, soundVolume);
  50 }
  51
  52 void Audio::setMusicVolume(int musicVolume)
  53 {
  54         this->musicVolume = musicVolume;
  55         if (engine->useAudio)
  56         {
  57                 Mix_VolumeMusic(musicVolume);
  58         }
  59 }
  60
  61 void Audio::registerEngine(Engine *engine)
  62 {
  63         this->engine = engine;
  64 }
  65
  66 /**
  67  * Loads a sound file
  68  * @param i: the id to load the sound to
  69  * @param filename: the file to load (relative to datadir)
  70  */
  71
  72 bool Audio::loadSound(int i, const char *filename)
  73 {
  74         if (!engine->useAudio)
  75         {
  76                 return true;
  77         }
  78
  79         if (i >= MAX_SOUNDS)
  80         {
  81                 error << "Sound index is higher than maximum allowed (requested " << i << ", maximum is " << MAX_SOUNDS << ")" << std::endl
  82                           << "Ignoring, but this is an internal error, so report it!" << std::endl;
  83                 return false;
  84         }
  85
  86         if (sound[i] != NULL)
  87         {
  88                 Mix_FreeChunk(sound[i]);
  89                 sound[i] = NULL;
  90         }
  91
  92         try
  93         {
  94                 SDL_RWops * buffer = PhysFS::RWops(filename);
  95                 sound[i] = Mix_LoadWAV_RW(buffer, 1);
  96
  97                 if (!sound[i])
  98                 {
  99                         Exception::SdlMixerError e(AT);
 100                         e.AddInfo("Mix_GetError()", Mix_GetError());
 101                         e.AddInfo("File tried to load", filename);
 102                         throw e;
 103                 }
 104         }
 105         catch (const Exception::Base& e)
 106         {
 107                 error << e.GetDesc() << std::endl;
 108                 return false;
 109         }
 110         catch (const std::exception& e)
 111         {
 112                 error << "Failed to load '" << filename << "'" << std::endl << "The error was: " << e.what() << std::endl;
 113                 return false;
 114         }
 115         catch (...)
 116         {
 117                 error << "Failed to load '" << filename << "'" << std::endl << "Unknown error while loading." << std::endl;
 118                 return false;
 119         }
 120
 121         return true;
 122 }
 123
 124 bool Audio::loadMusic(const char *filename, const bool save)
 125 {
 126         if (!engine->useAudio)
 127         {
 128                 return true;
 129         }
 130
 131         if (music != NULL)
 132         {
 133                 Mix_HaltMusic();
 134                 Mix_FreeMusic(music);
 135                 music = NULL;
 136                 SDL_FreeRW(music_rwops);
 137         }
 138
 139
 140         try
 141         {
 142                 music_rwops = PhysFS::RWops(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         if (save)
 170                 strcpy(levelMusicName, filename);
 171
 172         return true;
 173 }
 174
 175 void Audio::playSound(int snd, int channel)
 176 {
 177         if ((!engine->useAudio) || (soundVolume == 0))
 178                 return;
 179
 180         if (!output)
 181         {
 182                 return;
 183         }
 184
 185         Mix_Volume(channel, soundVolume);
 186
 187         Mix_PlayChannel(channel, sound[snd], 0);
 188 }
 189
 190 void Audio::playMusic()
 191 {
 192         if (!engine->useAudio)
 193                 return;
 194
 195         if (!output)
 196         {
 197                 return;
 198         }
 199
 200         Mix_PlayMusic(music, -1);
 201
 202         Mix_VolumeMusic(musicVolume);
 203 }
 204
 205 void Audio::playMusicOnce()
 206 {
 207         if (!engine->useAudio)
 208                 return;
 209
 210         if (!output)
 211         {
 212                 return;
 213         }
 214
 215         Mix_PlayMusic(music, 0);
 216
 217         Mix_VolumeMusic(musicVolume);
 218 }
 219
 220 bool Audio::loadGameOverMusic()
 221 {
 222         #if DEMO
 223                 return true;
 224         #endif
 225
 226                 return loadMusic("music/friendDied.mod", false);
 227 }
 228
 229 bool Audio::reloadLevelMusic()
 230 {
 231         // remove the Game Over music first...
 232
 233         if (music != NULL)
 234         {
 235                 Mix_HaltMusic();
 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                 Mix_FreeMusic(music);
 339         }
 340
 341         music = NULL;
 342
 343         if (quickSound != NULL)
 344                 Mix_FreeChunk(quickSound);
 345
 346         quickSound = NULL;
 347 }
 348
 349 void Audio::destroy()
 350 {
 351         free();
 352
 353         for (int i = MAX_SOUNDS - 3 ; i < MAX_SOUNDS ; i++)
 354         {
 355                 if (sound[i] != NULL)
 356                 {
 357                         Mix_FreeChunk(sound[i]);
 358                         sound[i] = NULL;
 359                 }
 360         }
 361 }