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 /*
 104
 105 ok, i was stupid. We won't need this now.
 106
 107 // Register a sound effect function - basti_
 108
 109 void
 110 SoundManager::register_effect(int channel,Mix_EffectFunc_t f,
 111                               Mix_EffectDone_t d,void * arg) {
 112
 113   if(!audio_device || !m_sound_enabled)
 114     return;
 115   Mix_RegisterEffect(channel,f,d,arg);
 116 }
 117
 118 // Adjust the Volume of a channel "on line". Needs sizeof(float) static data.
 119
 120 void
 121 SoundManager::volume_adjust(int chan, void *stream, int len, void *udata) {
 122
 123   typedef signed short int atype;
 124
 125   ((float *)udata)[1]=((float *)udata)[1]*0.95+
 126     (((float *)udata)[0]-
 127      ((float *)udata)[1])*0.05; // decay towards [0] - declick
 128   float vol=((float*)udata)[1];
 129
 130   for (int i=0;i<len/2;i++)
 131     ((atype *)stream)[i]=
 132       ((atype)(((atype *)stream)[i]*vol));
 133   // FIXME: This should be audio-type dependant - how to do this correctly?
 134
 135   chan=0; // -Werror sucks
 136 }
 137 */
 138
 139
 140 MusicRef
 141 SoundManager::load_music(const std::string& file)
 142 {
 143   if(!audio_device)
 144     return MusicRef(0);
 145
 146   if(!exists_music(file)) {
 147     std::stringstream msg;
 148     msg << "Couldn't load musicfile '" << file << "': " << SDL_GetError();
 149     throw std::runtime_error(msg.str());
 150   }
 151
 152   std::map<std::string, MusicResource>::iterator i = musics.find(file);
 153   assert(i != musics.end());
 154   return MusicRef(& (i->second));
 155 }
 156
 157 bool
 158 SoundManager::exists_music(const std::string& file)
 159 {
 160   if(!audio_device)
 161     return true;
 162
 163   // song already loaded?
 164   std::map<std::string, MusicResource>::iterator i = musics.find(file);
 165   if(i != musics.end()) {
 166     return true;
 167   }
 168
 169   Mix_Music* song = Mix_LoadMUS(file.c_str());
 170   if(song == 0)
 171     return false;
 172
 173   // insert into music list
 174   std::pair<std::map<std::string, MusicResource>::iterator, bool> result =
 175     musics.insert(
 176         std::make_pair<std::string, MusicResource> (file, MusicResource()));
 177   MusicResource& resource = result.first->second;
 178   resource.manager = this;
 179   resource.music = song;
 180
 181   return true;
 182 }
 183
 184 void
 185 SoundManager::free_music(MusicResource* )
 186 {
 187   // TODO free music, currently we can't do this since SDL_mixer seems to have
 188   // some bugs if you load/free alot of mod files.
 189 }
 190
 191 void
 192 SoundManager::play_music(const MusicRef& musicref, int loops)
 193 {
 194   if(!audio_device)
 195     return;
 196
 197   if(musicref.music == 0 || current_music == musicref.music)
 198     return;
 199
 200   if(current_music)
 201     current_music->refcount--;
 202
 203   current_music = musicref.music;
 204   current_music->refcount++;
 205
 206   if(m_music_enabled)
 207     Mix_PlayMusic(current_music->music, loops);
 208 }
 209
 210 void
 211 SoundManager::halt_music()
 212 {
 213   if(!audio_device)
 214     return;
 215
 216   Mix_HaltMusic();
 217
 218   if(current_music) {
 219     current_music->refcount--;
 220     if(current_music->refcount == 0)
 221       free_music(current_music);
 222     current_music = 0;
 223   }
 224 }
 225
 226 void
 227 SoundManager::enable_music(bool enable)
 228 {
 229   if(!audio_device)
 230     return;
 231
 232   if(enable == m_music_enabled)
 233     return;
 234
 235   m_music_enabled = enable;
 236   if(m_music_enabled == false) {
 237     Mix_HaltMusic();
 238   } else {
 239     if(current_music)
 240       Mix_PlayMusic(current_music->music, -1);
 241   }
 242 }
 243
 244 void
 245 SoundManager::enable_sound(bool enable)
 246 {
 247   if(!audio_device)
 248     return;
 249
 250   m_sound_enabled = enable;
 251 }
 252
 253 SoundManager::MusicResource::~MusicResource()
 254 {
 255   // don't free music buggy SDL_Mixer crashs for some mod files
 256   // Mix_FreeMusic(music);
 257 }
 258
 259 Mix_Chunk* SoundManager::preload_sound(const std::string& name)
 260 {
 261   if(!audio_device)
 262     return 0;
 263
 264   Sounds::iterator i = sounds.find(name);
 265   if(i != sounds.end()) {
 266     return i->second;
 267   }
 268
 269   std::string filename = "sounds/";
 270   filename += name;
 271   filename += ".wav";
 272   filename = get_resource_filename(filename);
 273
 274   Mix_Chunk* chunk = Mix_LoadWAV(filename.c_str());
 275   if(chunk != 0) {
 276     sounds.insert(std::make_pair(name, chunk));
 277   }
 278
 279   return chunk;
 280 }
 281