source: orxonox.OLD/orxonox/branches/sound_engine/src/lib/sound/sound_engine.cc @ 3890

/* 
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   ### File Specific:
   main-programmer: Benjamin Grauer
   co-programmer: ...
   
   Some code was taken from Simon's first implementation of the SoundEngine.
*/

#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_SOUND

#include "sound_engine.h"
#include <SDL_mixer.h>
#include "compiler.h"

using namespace std;


/*----------------
  SOUND AND MUSIC
  ---------------*/

Sound::Sound(const char* fileName, SOUND_TYPE soundType)
{
  // checking if the sound-format is known
  if (soundType == SOUND_NONE)
    {
      if (likely(!strncmp(fileName+(strlen(fileName)-4), ".wav", 4)) ||
          unlikely(!strncmp(fileName+(strlen(fileName)-4), ".voc", 4)) ||
          unlikely(!strncmp(fileName+(strlen(fileName)-5), ".aiff", 5)) ||
          unlikely(!strncmp(fileName+(strlen(fileName)-5), ".riff", 5)))
        this->soundType = SOUND_WAV;
      else if (likely(!strncmp(fileName+(strlen(fileName)-4), ".ogg", 4)))
        this->soundType = SOUND_OGG;
      else if (likely(!strncmp(fileName+(strlen(fileName)-4), ".mp3", 4)))
        this->soundType = SOUND_MP3;
      else if (unlikely(!strncmp(fileName+(strlen(fileName)-4), ".mod", 4)) ||
               unlikely(!strncmp(fileName+(strlen(fileName)-4), ".s3m", 4)) ||
               unlikely(!strncmp(fileName+(strlen(fileName)-3), ".it", 3)) ||
               unlikely(!strncmp(fileName+(strlen(fileName)-3), ".xm", 3)))
        this->soundType = SOUND_MOD;
      else if (likely(!strncmp(fileName+(strlen(fileName)-4), ".mid", 4)))
        this->soundType = SOUND_MID;
    }
}

Sound::~Sound()
{

}

SoundEffect::SoundEffect(const char* fileName, SOUND_TYPE soundType) : Sound(fileName, soundType)
{
  // checking how to load
  this->effect = NULL;
  if (likely(SoundEngine::isInit))
    {
      if (this->soundType == SOUND_WAV ||
          this->soundType == SOUND_MOD ||
          this->soundType == SOUND_OGG)
        this->effect = Mix_LoadWAV(fileName);
      else
        PRINTF(2)("%s cannot be loaded as SoundEffect. Wrong Type\n", fileName);
    }
  else
    PRINTF(2)("SoundEngine not yet started. not loading SoundEffect %s\n", fileName);
}

SoundEffect::~SoundEffect(void)
{
  // deleting the effects-chunk
  Mix_FreeChunk(this->effect);
}

Music::Music(const char* fileName, SOUND_TYPE soundType) : Sound(fileName, soundType)
{
  this->music = NULL;
  if (likely(SoundEngine::isInit))
    {
      if (this->soundType == SOUND_WAV ||
          this->soundType == SOUND_MOD ||
          this->soundType == SOUND_OGG ||
          this->soundType == SOUND_MP3 ||
          this->soundType == SOUND_MID )
        this->music = Mix_LoadMUS(fileName);
      else
        PRINTF(2)("%s cannot be loaded as Music. Wrong Type\n", fileName);
    }
  else
    PRINTF(2)("SoundEngine not yet started. not loading Music %s\n", fileName);
}

Music::~Music()
{
  Mix_FreeMusic(this->music);
}

/*----------------------
 STARTING AND UNLOADING
  ----------------------*/
/**
   \brief standard constructor
*/
SoundEngine::SoundEngine () 
{
   this->setClassName ("SoundEngine");

   // preInit
   this->frequency = SOUND_DEFAULT_FREQUENCY;
   this->format = MIX_DEFAULT_FORMAT;
   this->channels = SOUND_DEFAULT_CHANNELS;
   this->buffers = SOUND_DEFAULT_BUFIZE;

   this->enableSound();
}

/**
   \brief the singleton reference to this class
*/
SoundEngine* SoundEngine::singletonRef = NULL;

/**
   \returns a Pointer to this Class
*/
SoundEngine* SoundEngine::getInstance(void)
{
  if (!SoundEngine::singletonRef)
    SoundEngine::singletonRef = new SoundEngine();
  return SoundEngine::singletonRef;
}

/**
   \brief standard deconstructor

*/
SoundEngine::~SoundEngine () 
{
  SoundEngine::singletonRef = NULL;
  
  this->disableSound();
}

bool SoundEngine::isInit = false;
bool SoundEngine::enabled = false;



/**
   \brief enables the SDL_mixer library
*/
void SoundEngine::enableSound(void)
{
  if (!this->isInit)
    {
      if (SDL_Init(SDL_INIT_AUDIO) == -1)
        {
          PRINTF(1)("SDL-sound could not be initialized\nSDL_Init: %s\n", SDL_GetError());
          return;
        }
      else
        {
          this->isInit = true;
          
          // checking if the mode is supported
          Mix_QuerySpec(&this->frequency, &this->format, &this->channels);
          
          this->bits = this->format & 0xFF;
          PRINTF(3)("Opened audio at %d Hz %d bit %s, %d bytes audio buffer\n",
                    this->frequency, this->bits, this->channels > 1 ? "stereo" : "mono", this->buffers); 
          Mix_VolumeMusic(this->volume);
          
          if(Mix_OpenAudio(this->frequency, this->format, this->channels, this->buffers) == -1)
            PRINTF(1)("Mix_OpenAudio: %s\n", Mix_GetError());
        }
    }
}

/**
   \brief disabled SDL_mixer
*/
void SoundEngine::disableSound(void)
{
  if (this->isInit)
    {
      Mix_CloseAudio();
    }
  else
    PRINTF(4)("SDL_mixer was not initialized.\n");
}

/**
   \brief checks if the compiled version and the local version of SDL_mixer match.
   \returns true if match, false otherwise
*/
bool SoundEngine::checkVersion(void)
{
  SDL_version compile_version;
  SDL_version link_version;
  MIX_VERSION(&compile_version);
  link_version = *Mix_Linked_Version();

  if (compile_version.major == link_version.major &&
      compile_version.minor == link_version.minor &&
      compile_version.patch == link_version.patch)
    {
      return true;
    }
  else
    {
      PRINTF(2)("compiled with SDL_mixer version: %d.%d.%d\n", 
                compile_version.major,
                compile_version.minor,
                compile_version.patch);
      
      PRINTF(2)("running with SDL_mixer version: %d.%d.%d\n", 
                link_version.major,
                link_version.minor,
                link_version.patch);
      return false;
    }
}


/*-------------
  FUNCTIONALITY
  -------------*/

/**
   \param numberOfChannels sets the number of Channels to use.
*/
void SoundEngine::setNumberOfChannels(unsigned int numberOfChannels) 
{
  this->numberOfChannels = numberOfChannels;
  Mix_AllocateChannels(numberOfChannels);
}