src/audio/sound_manager.cpp

   1 //  $Id: sound_manager.cpp 2334 2005-04-04 16:26:14Z grumbel $
   2 //
   3 //  SuperTux -  A Jump'n Run
   4 //  Copyright (C) 2004 Matthias Braun <matze@braunis.de
   5 //
   6 //  This program is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU General Public License
   8 //  as published by the Free Software Foundation; either version 2
   9 //  of the License, or (at your option) any later version.
  10 //
  11 //  This program is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //  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 #include <config.h>
  20
  21 #include <cmath>
  22 #include <cassert>
  23 #include <iostream>
  24 #include <stdexcept>
  25 #include <sstream>
  26
  27 #include "audio/sound_manager.h"
  28
  29 #include "audio/musicref.h"
  30 #include "moving_object.h"
  31 #include "resources.h"
  32
  33 SoundManager::SoundManager()
  34   : current_music(0), m_music_enabled(true) , m_sound_enabled(true),
  35     audio_device(false)
  36 {
  37 }
  38
  39 SoundManager::~SoundManager()
  40 {
  41   for(Sounds::iterator i = sounds.begin(); i != sounds.end(); ++i) {
  42     Mix_FreeChunk(i->second);
  43   }
  44   sounds.clear();
  45 }
  46
  47 int
  48 SoundManager::play_sound(const std::string& name,int loops)
  49 {
  50   if(!audio_device || !m_sound_enabled)
  51     return -1;
  52
  53   Mix_Chunk* chunk = preload_sound(name);
  54   if(chunk == 0) {
  55     std::cerr << "Sound '" << name << "' not found.\n";
  56     return -1;
  57   }
  58   return Mix_PlayChannel(-1, chunk, loops);
  59 }
  60
  61
  62 void
  63 SoundManager::play_sound(const std::string& sound, const MovingObject* object,
  64     const Vector& pos)
  65 {
  66   // TODO keep track of the object later and move the sound along with the
  67   // object.
  68   play_sound(sound, object->get_pos(), pos);
  69 }
  70
  71 void
  72 SoundManager::play_sound(const std::string& sound, const Vector& pos,
  73     const Vector& pos2)
  74 {
  75   if(!audio_device || !m_sound_enabled)
  76     return;
  77
  78   Mix_Chunk* chunk = preload_sound(sound);
  79   if(chunk == 0) {
  80     std::cerr << "Sound '" << sound << "' not found.\n";
  81     return;
  82   }
  83
  84   // TODO make sure this formula is good
  85   float distance
  86     = pos2.x- pos.x;
  87   int loud = int(255.0/float(1600) * fabsf(distance));
  88   if(loud > 255)
  89     return;
  90
  91   int chan = Mix_PlayChannel(-1, chunk, 0);
  92   if(chan < 0)
  93     return;
  94   Mix_SetDistance(chan, loud);
  95
  96   // very bad way to do this...
  97   if(distance > 100)
  98     Mix_SetPanning(chan, 230, 24);
  99   else if(distance < -100)
 100     Mix_SetPanning(chan, 24, 230);
 101 }
 102
 103 MusicRef
 104 SoundManager::load_music(const std::string& file)
 105 {
 106   if(!audio_device)
 107     return MusicRef(0);
 108
 109   if(!exists_music(file)) {
 110     std::stringstream msg;
 111     msg << "Couldn't load musicfile '" << file << "': " << SDL_GetError();
 112     throw std::runtime_error(msg.str());
 113   }
 114
 115   std::map<std::string, MusicResource>::iterator i = musics.find(file);
 116   assert(i != musics.end());
 117   return MusicRef(& (i->second));
 118 }
 119
 120 bool
 121 SoundManager::exists_music(const std::string& file)
 122 {
 123   if(!audio_device)
 124     return true;
 125
 126   // song already loaded?
 127   std::map<std::string, MusicResource>::iterator i = musics.find(file);
 128   if(i != musics.end()) {
 129     return true;
 130   }
 131
 132   Mix_Music* song = Mix_LoadMUS(file.c_str());
 133   if(song == 0)
 134     return false;
 135
 136   // insert into music list
 137   std::pair<std::map<std::string, MusicResource>::iterator, bool> result =
 138     musics.insert(
 139         std::make_pair<std::string, MusicResource> (file, MusicResource()));
 140   MusicResource& resource = result.first->second;
 141   resource.manager = this;
 142   resource.music = song;
 143
 144   return true;
 145 }
 146
 147 void
 148 SoundManager::free_music(MusicResource* )
 149 {
 150   // TODO free music, currently we can't do this since SDL_mixer seems to have
 151   // some bugs if you load/free alot of mod files.
 152 }
 153
 154 void
 155 SoundManager::play_music(const MusicRef& musicref, int loops)
 156 {
 157   if(!audio_device)
 158     return;
 159
 160   if(musicref.music == 0 || current_music == musicref.music)
 161     return;
 162
 163   if(current_music)
 164     current_music->refcount--;
 165
 166   current_music = musicref.music;
 167   current_music->refcount++;
 168
 169   if(m_music_enabled)
 170     Mix_PlayMusic(current_music->music, loops);
 171 }
 172
 173 void
 174 SoundManager::halt_music()
 175 {
 176   if(!audio_device)
 177     return;
 178
 179   Mix_HaltMusic();
 180
 181   if(current_music) {
 182     current_music->refcount--;
 183     if(current_music->refcount == 0)
 184       free_music(current_music);
 185     current_music = 0;
 186   }
 187 }
 188
 189 void
 190 SoundManager::enable_music(bool enable)
 191 {
 192   if(!audio_device)
 193     return;
 194
 195   if(enable == m_music_enabled)
 196     return;
 197
 198   m_music_enabled = enable;
 199   if(m_music_enabled == false) {
 200     Mix_HaltMusic();
 201   } else {
 202     if(current_music)
 203       Mix_PlayMusic(current_music->music, -1);
 204   }
 205 }
 206
 207 void
 208 SoundManager::enable_sound(bool enable)
 209 {
 210   if(!audio_device)
 211     return;
 212
 213   m_sound_enabled = enable;
 214 }
 215
 216 SoundManager::MusicResource::~MusicResource()
 217 {
 218   // don't free music buggy SDL_Mixer crashs for some mod files
 219   // Mix_FreeMusic(music);
 220 }
 221
 222 Mix_Chunk* SoundManager::preload_sound(const std::string& name)
 223 {
 224   if(!audio_device)
 225     return 0;
 226
 227   Sounds::iterator i = sounds.find(name);
 228   if(i != sounds.end()) {
 229     return i->second;
 230   }
 231
 232   std::string filename = "sounds/";
 233   filename += name;
 234   filename += ".wav";
 235   filename = get_resource_filename(filename);
 236
 237   Mix_Chunk* chunk = Mix_LoadWAV(filename.c_str());
 238   if(chunk != 0) {
 239     sounds.insert(std::make_pair(name, chunk));
 240   }
 241
 242   return chunk;
 243 }
 244