X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Faudio%2Fsound_manager.cpp;h=0576fe6ba9cd6d1fbcd9a6cba820250512317fa0;hb=d99e2443318865c0f379170b4ef2aa30f515b235;hp=c7e624aee92d5e0ecc871a7ea306a0ab81821de2;hpb=9e89407a97c5dfb035192387121e6102bc45a8fc;p=supertux.git

diff --git a/src/audio/sound_manager.cpp b/src/audio/sound_manager.cpp
index c7e624aee..0576fe6ba 100644
--- a/src/audio/sound_manager.cpp
+++ b/src/audio/sound_manager.cpp
@@ -1,7 +1,7 @@
-//  $Id: sound_manager.cpp 2334 2005-04-04 16:26:14Z grumbel $
+//  $Id$
 //
-//  SuperTux -  A Jump'n Run
-//  Copyright (C) 2004 Matthias Braun <matze@braunis.de
+//  SuperTux
+//  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
 //
 //  This program is free software; you can redistribute it and/or
 //  modify it under the terms of the GNU General Public License
@@ -16,230 +16,337 @@
 //  You should have received a copy of the GNU General Public License
 //  along with this program; if not, write to the Free Software
 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-#include <config.h>
 
-#include <cmath>
-#include <cassert>
+#include "sound_manager.hpp"
+
 #include <stdexcept>
+#include <iostream>
 #include <sstream>
+#include <memory>
 
-#include "audio/sound_manager.h"
-#include "audio/musicref.h"
-#include "app/globals.h"
-#include "app/setup.h"
-#include "moving_object.h"
-#include "resources.h"
+#include "sound_file.hpp"
+#include "sound_source.hpp"
+#include "stream_sound_source.hpp"
+#include "log.hpp"
+#include "timer.hpp"
 
-using namespace SuperTux;
+SoundManager* sound_manager = 0;
 
 SoundManager::SoundManager()
-  : current_music(0), m_music_enabled(true) , m_sound_enabled(true),
-    audio_device(false)
+  : device(0), context(0), sound_enabled(false), music_source(0),
+    music_enabled(true)
 {
+  try {
+    device = alcOpenDevice(0);
+    if (device == NULL) {
+      throw std::runtime_error("Couldn't open audio device.");
+    }
+
+    int attributes[] = { 0 };
+    context = alcCreateContext(device, attributes);
+    check_alc_error("Couldn't create audio context: ");
+    alcMakeContextCurrent(context);
+    check_alc_error("Couldn't select audio context: ");
+
+    check_al_error("Audio error after init: ");
+    sound_enabled = true;
+  } catch(std::exception& e) {
+    if(context != NULL)
+      alcDestroyContext(context);
+    context = NULL;
+    if(device != NULL)
+      alcCloseDevice(device);
+    device = NULL;
+    log_warning << "Couldn't initialize audio device: " << e.what() << std::endl;
+    print_openal_version();
+  }
 }
 
 SoundManager::~SoundManager()
 {
-  for(Sounds::iterator i = sounds.begin(); i != sounds.end(); ++i) {
-    Mix_FreeChunk(i->second);
+  delete music_source;
+
+  for(SoundSources::iterator i = sources.begin(); i != sources.end(); ++i) {
+    delete *i;
+  }
+
+  for(SoundBuffers::iterator i = buffers.begin(); i != buffers.end(); ++i) {
+    ALuint buffer = i->second;
+    alDeleteBuffers(1, &buffer);
+  }
+
+  if(context != NULL) {
+    alcDestroyContext(context);
+  }
+  if(device != NULL) {
+    alcCloseDevice(device);
   }
-  sounds.clear();
 }
 
-void
-SoundManager::play_sound(const std::string& name)
+ALuint
+SoundManager::load_file_into_buffer(SoundFile* file)
 {
-  if(!audio_device || !m_sound_enabled)
-    return;
+  ALenum format = get_sample_format(file);
+  ALuint buffer;
+  alGenBuffers(1, &buffer);
+  check_al_error("Couldn't create audio buffer: ");
+  char* samples = new char[file->size];
+  try {
+    file->read(samples, file->size);
+    alBufferData(buffer, format, samples,
+        static_cast<ALsizei> (file->size),
+        static_cast<ALsizei> (file->rate));
+    check_al_error("Couldn't fill audio buffer: ");
+  } catch(...) {
+    delete[] samples;
+    throw;
+  }
+  delete[] samples;
+
+  return buffer;
+}
+
+SoundSource*
+SoundManager::create_sound_source(const std::string& filename)
+{
+  if(!sound_enabled)
+    return 0;
+
+  ALuint buffer;
   
-  Mix_Chunk* chunk = preload_sound(name);
-  if(chunk == 0) {
-    std::cerr << "Sound '" << name << "' not found.\n";
-    return;
+  // reuse an existing static sound buffer            
+  SoundBuffers::iterator i = buffers.find(filename);
+  if(i != buffers.end()) {
+    buffer = i->second;
+  } else {
+    // Load sound file
+    std::auto_ptr<SoundFile> file (load_sound_file(filename));
+
+    if(file->size < 100000) {
+      buffer = load_file_into_buffer(file.get());
+      buffers.insert(std::make_pair(filename, buffer));
+    } else {
+      StreamSoundSource* source = new StreamSoundSource();
+      source->set_sound_file(file.release());
+      return source;
+    }
   }
-  Mix_PlayChannel(-1, chunk, 0);  
+  
+  SoundSource* source = new SoundSource();
+  alSourcei(source->source, AL_BUFFER, buffer);
+  return source;  
 }
 
 void
-SoundManager::play_sound(const std::string& sound, const MovingObject* object,
-    const Vector& pos)
+SoundManager::play(const std::string& filename, const Vector& pos)
 {
-  // TODO keep track of the object later and move the sound along with the
-  // object.
-  play_sound(sound, object->get_pos(), pos);
+  try {
+    SoundSource* source = create_sound_source(filename);
+    if(source == NULL)
+      return;
+    if(pos == Vector(-1, -1)) {
+      alSourcef(source->source, AL_ROLLOFF_FACTOR, 0);
+    } else {
+      source->set_position(pos);
+    }
+    source->play();
+    sources.push_back(source);
+  } catch(std::exception& e) {
+    log_warning << "Couldn't play sound " << filename << ": " << e.what() << std::endl;
+  }
 }
 
 void
-SoundManager::play_sound(const std::string& sound, const Vector& pos,
-    const Vector& pos2)
+SoundManager::play_and_delete(SoundSource* source)
 {
-  if(!audio_device || !m_sound_enabled)
+  if (!source) {
+    log_debug << "ignoring NULL SoundSource" << std::endl;
     return;
-
-  Mix_Chunk* chunk = preload_sound(sound);
-  if(chunk == 0) {
-    std::cerr << "Sound '" << sound << "' not found.\n";
-    return;                                              
   }
+  try {
+    source->play();
+    sources.push_back(source);
+  } catch(std::exception& e) {
+    log_warning << "Couldn't play SoundSource: " << e.what() << std::endl;
+  }
+}
 
-  // TODO make sure this formula is good
-  float distance 
-    = pos2.x- pos.x;
-  int loud = int(255.0/float(SCREEN_WIDTH*2) * fabsf(distance));
-  if(loud > 255)
+void
+SoundManager::enable_sound(bool enable)
+{
+  if(device == NULL)
     return;
 
-  int chan = Mix_PlayChannel(-1, chunk, 0);
-  if(chan < 0)
-    return;                                  
-  Mix_SetDistance(chan, loud);
-
-  // very bad way to do this...
-  if(distance > 100)
-    Mix_SetPanning(chan, 230, 24);
-  else if(distance < -100)
-    Mix_SetPanning(chan, 24, 230);
+  sound_enabled = enable;
 }
 
-MusicRef
-SoundManager::load_music(const std::string& file)
+void
+SoundManager::enable_music(bool enable)
 {
-  if(!audio_device)
-    return MusicRef(0);
+  if(device == NULL)
+    return;
 
-  if(!exists_music(file)) {
-    std::stringstream msg;
-    msg << "Couldn't load musicfile '" << file << "': " << SDL_GetError();
-    throw std::runtime_error(msg.str());
+  music_enabled = enable;
+  if(music_enabled) {
+    play_music(current_music);
+  } else {
+    if(music_source) {
+      delete music_source;
+      music_source = 0;
+    }
   }
-
-  std::map<std::string, MusicResource>::iterator i = musics.find(file);
-  assert(i != musics.end());
-  return MusicRef(& (i->second));
 }
 
-bool
-SoundManager::exists_music(const std::string& file)
+void
+SoundManager::stop_music(float fadetime)
 {
-  if(!audio_device)
-    return true;
-  
-  // song already loaded?
-  std::map<std::string, MusicResource>::iterator i = musics.find(file);
-  if(i != musics.end()) {
-    return true;                                      
+  if(fadetime > 0) {
+    if(music_source
+        && music_source->get_fade_state() != StreamSoundSource::FadingOff)
+      music_source->set_fading(StreamSoundSource::FadingOff, fadetime);
+  } else {
+    delete music_source;
+    music_source = NULL;
   }
-  
-  Mix_Music* song = Mix_LoadMUS(file.c_str());
-  if(song == 0)
-    return false;
-
-  // insert into music list
-  std::pair<std::map<std::string, MusicResource>::iterator, bool> result = 
-    musics.insert(
-        std::make_pair<std::string, MusicResource> (file, MusicResource()));
-  MusicResource& resource = result.first->second;
-  resource.manager = this;
-  resource.music = song;
-
-  return true;
+  current_music = "";
 }
 
 void
-SoundManager::free_music(MusicResource* )
+SoundManager::play_music(const std::string& filename, bool fade)
 {
-  // TODO free music, currently we can't do this since SDL_mixer seems to have
-  // some bugs if you load/free alot of mod files.  
+  if(filename == current_music && music_source != NULL)
+    return;
+  current_music = filename;
+  if(!music_enabled)
+    return;
+
+  if(filename == "") {
+    delete music_source;
+    music_source = NULL;
+    return;
+  }
+
+  try {
+    std::auto_ptr<StreamSoundSource> newmusic (new StreamSoundSource());
+    alSourcef(newmusic->source, AL_ROLLOFF_FACTOR, 0);
+    newmusic->set_sound_file(load_sound_file(filename));
+    newmusic->set_looping(true);
+    if(fade)
+      newmusic->set_fading(StreamSoundSource::FadingOn, .5f);
+    newmusic->play();
+
+    delete music_source;
+    music_source = newmusic.release();
+  } catch(std::exception& e) {
+    log_warning << "Couldn't play music file '" << filename << "': " << e.what() << std::endl;
+  }
 }
 
 void
-SoundManager::play_music(const MusicRef& musicref, int loops)
+SoundManager::set_listener_position(const Vector& pos)
 {
-  if(!audio_device)
-    return;
+  static Uint32 lastticks = 0;
 
-  if(musicref.music == 0 || current_music == musicref.music)
+  Uint32 current_ticks = SDL_GetTicks();
+  if(current_ticks - lastticks < 300)
     return;
+  lastticks = current_ticks;                 
 
-  if(current_music)
-    current_music->refcount--;
-  
-  current_music = musicref.music;
-  current_music->refcount++;
-  
-  if(m_music_enabled)
-    Mix_PlayMusic(current_music->music, loops);
+  alListener3f(AL_POSITION, pos.x, pos.y, 0);
 }
 
 void
-SoundManager::halt_music()
+SoundManager::set_listener_velocity(const Vector& vel)
 {
-  if(!audio_device)
-    return;
-  
-  Mix_HaltMusic();
-  
-  if(current_music) {
-    current_music->refcount--;
-    if(current_music->refcount == 0)
-      free_music(current_music);
-    current_music = 0;
-  }
+  alListener3f(AL_VELOCITY, vel.x, vel.y, 0);
 }
 
 void
-SoundManager::enable_music(bool enable)
+SoundManager::update()
 {
-  if(!audio_device)
-    return;
+  static float lasttime = real_time;
 
-  if(enable == m_music_enabled)
+  if(real_time - lasttime < 0.3)
     return;
-  
-  m_music_enabled = enable;
-  if(m_music_enabled == false) {
-    Mix_HaltMusic();
-  } else {
-    if(current_music)
-      Mix_PlayMusic(current_music->music, -1);
+  lasttime = real_time;
+
+  // update and check for finished sound sources
+  for(SoundSources::iterator i = sources.begin(); i != sources.end(); ) {
+    SoundSource* source = *i;
+
+    source->update();
+    
+    if(!source->playing()) {
+      delete source;
+      i = sources.erase(i);
+    } else {
+      ++i;
+    }
+  }
+  // check streaming sounds
+  if(music_source) {
+    music_source->update();
+  }
+
+  if (context)
+  {
+    alcProcessContext(context);
+    check_alc_error("Error while processing audio context: ");
   }
 }
 
-void
-SoundManager::enable_sound(bool enable)
+ALenum
+SoundManager::get_sample_format(SoundFile* file)
 {
-  if(!audio_device)
-    return;
+  if(file->channels == 2) {
+    if(file->bits_per_sample == 16) {
+      return AL_FORMAT_STEREO16;
+    } else if(file->bits_per_sample == 8) {
+      return AL_FORMAT_STEREO8;
+    } else {
+      throw std::runtime_error("Only 16 and 8 bit samples supported");
+    }
+  } else if(file->channels == 1) {
+    if(file->bits_per_sample == 16) {
+      return AL_FORMAT_MONO16;
+    } else if(file->bits_per_sample == 8) {
+      return AL_FORMAT_MONO8;
+    } else {
+      throw std::runtime_error("Only 16 and 8 bit samples supported");
+    }
+  }
   
-  m_sound_enabled = enable;
+  throw std::runtime_error("Only 1 and 2 channel samples supported");
 }
 
-SoundManager::MusicResource::~MusicResource()
+void
+SoundManager::print_openal_version()
 {
-  // don't free music buggy SDL_Mixer crashs for some mod files
-  // Mix_FreeMusic(music);
+  log_info << "OpenAL Vendor: " << alGetString(AL_VENDOR) << std::endl;
+  log_info << "OpenAL Version: " << alGetString(AL_VERSION) << std::endl;
+  log_info << "OpenAL Renderer: " << alGetString(AL_RENDERER) << std::endl;
+  log_info << "OpenAl Extensions: " << alGetString(AL_EXTENSIONS) << std::endl;
 }
 
-Mix_Chunk* SoundManager::preload_sound(const std::string& name)
+void
+SoundManager::check_alc_error(const char* message)
 {
-  if(!audio_device)
-    return 0;
-
-  Sounds::iterator i = sounds.find(name);
-  if(i != sounds.end()) {
-    return i->second;
-  }
-
-  std::string filename = "sounds/";
-  filename += name;
-  filename += ".wav";
-  filename = get_resource_filename(filename);
-  
-  Mix_Chunk* chunk = Mix_LoadWAV(filename.c_str());
-  if(chunk != 0) {
-    sounds.insert(std::make_pair(name, chunk));
-  }
+  int err = alcGetError(device);
+  if(err != ALC_NO_ERROR) {
+    std::stringstream msg;
+    msg << message << alcGetString(device, err);
+    throw std::runtime_error(msg.str());
+  }                
+}
 
-  return chunk;
+void
+SoundManager::check_al_error(const char* message)
+{
+  int err = alGetError();
+  if(err != AL_NO_ERROR) {
+    std::stringstream msg;
+    msg << message << alGetString(err);
+    throw std::runtime_error(msg.str());
+  }  
 }