AudioManager.cpp

Go to the documentation of this file.

/*
 * AudioManager.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003-2004 Chris Wallace
 *
 * Fly! Legacy 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 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * Audio Manager
 *
 * Discrete sound sources must be provided for:
 *   - 2 x COM radios
 *   - 2 x NAV radios
 *   - 2 x XPDR radios
 *   - panels (one source or more?)
 *   - individual engines
 *   - individual hydraulic systems (e.g. flaps, landing gear)
 *   - DLLs
 *
 * Since the audio manager creates the OpenAL context, there can only be
 *   one instance of the CAudioManager class.  The audio manager should
 *   therefore also manage OpenAL sources.  The SDK audio API is not very
 *   well suited to this approach, it implies that source attributes
 *   such as position, velocity etc. should be modified on a per-sound-effect
 *   (WAV file) basis.  This would be difficult to do under OpenAL however.
 *   For the time being, applications must first request an audio source
 *   in which to play their sound effect.  Calling the PlaySfx method
 *   returns a key to the audio buffer.
 */

#include "../Include/AudioManager.h"
#include "../Include/Globals.h"

using namespace std;


//
// CSoundEffect methods
//
// A sound effect consists of:
//   - WAV filename
//   - OpenAL buffer
//   - Two int user data values
//   - Reference to the OpenAL source that the sound effect is bound to (if any)
//

CSoundEffect::CSoundEffect (void)
  : bound (false), name(0), user1(0), user2(0)
{
#ifdef HAVE_OPENAL
  source = buffer = 0;
#endif // HAVE_OPENAL

  strcpy (wavfile, "");
}

CSoundEffect::~CSoundEffect (void)
{

#ifdef HAVE_OPENAL

  if (bound) {
    // Sound effect is bound to a source and may be playing
    alSourceStop (source);
    alSourcei (source, AL_BUFFER, 0);
  }

  // Delete OpenAL buffer
  alDeleteBuffers (1, &buffer);

#endif // HAVE_OPENAL
}


//
// CAudioManager
//


//
// Constructor
//
CAudioManager::CAudioManager (void)
{
}

//
// Destructor
//
CAudioManager::~CAudioManager (void)
{
  // Destroy all cached sound effects
  map<string,CSoundEffect*>::iterator iter;
  for (iter = cache.begin(); iter != cache.end(); iter++) {
    CSoundEffect *sfx = iter->second;
    delete sfx;
  }

#ifdef HAVE_OPENAL
  // Clean up AL context and device
  context = alcGetCurrentContext ();
  device = alcGetContextsDevice (context);
  alcMakeContextCurrent (NULL);
  alcDestroyContext (context);
  alcCloseDevice (device);
#endif // HAVE_OPENAL
}


//
// Initialization
// 
// This method must be called immediately after instantiation of the audio
// manager class
//
void CAudioManager::Init (void)
{
#ifdef HAVE_OPENAL
  ALint error;

  // Open default AL device
  device = alcOpenDevice (NULL);
  if (device == NULL) {
    // Could not open audio device
    gtfo ("CAudioManager::Init : Could not open default audio device");
  }

  // Create context
  context = alcCreateContext (device, NULL);
  if (context == NULL) {
    // Could not create context
    gtfo ("CAudioManager::Init : Could not create context");
  }

  // Set context as the active one
  alcGetError (device);
  alcMakeContextCurrent (context);
  if (alcGetError (device) != ALC_NO_ERROR) {
    gtfo ("CAudioManager::Init : Could not make context current");
  }

  // Clear error code
  alGetError ();
  alcGetError (device);

  // Listener position is always set to the origin of 3D audio space.
  // All sound effects must be position relative to the origin
  ALfloat listenerPos[] = {0.0, 0.0, 0.0};
  alListenerfv (AL_POSITION, listenerPos);
  if ((error = alGetError ()) != AL_NO_ERROR) {
    gtfo ("CAudioManager::Init :  Could not set listener position");
  }

  // Default listener velocity is zero.
  ALfloat listenerVel[] = {0.0, 0.0, 0.0};
  alListenerfv (AL_VELOCITY, listenerVel);
  if ((error = alGetError ()) != AL_NO_ERROR) {
    gtfo ("CAudioManager::Init :  Could not set listener velocity");
  }

  // Listener orientation is facing "into" the screen, towards +z axis
  // with +y axis as the up vector
  ALfloat listenerOrient[] = {0.0, 0.0, 1.0, 0.0, 1.0, 0.0}; // Fwd, up
  alListenerfv (AL_ORIENTATION, listenerOrient);
  if ((error = alGetError ()) != AL_NO_ERROR) {
    gtfo ("CAudioManager::Init :  Could not set listener orientation");
  }
#endif // HAVE_OPENAL
}


//
// SetListenerPosition
//
// This method sets the listener's position in Fly! geodetic coordinates.
// For the purposes of distance attenuation, the listener position is always
// assumed to be at the "origin" of the 3D world.  Setting the listener
// position is only required if SetSfxPosition () method is used to set
// sound effect positions using geodetic coordinates.  If there are no
// position-dependent sound effects to be played (not likely) or if the
// sound effect positions will always be specified using the
// SetSfxPosition (SVector) method, then the application does not need to
// continuously update the listener world position by calling this function.
//
void CAudioManager::SetListenerPosition (SPosition *p)
{
  listenerPos.lat = p->lat;
  listenerPos.lon = p->lon;
  listenerPos.alt = p->alt;
}


//
// CreateSource
//
int CAudioManager::CreateSource (void)
{
#ifdef HAVE_OPENAL

  ALuint source;
  ALint  error;
  alGetError ();
  alGenSources (1, &source);
  if ((error = alGetError ()) != AL_NO_ERROR) {
    gtfo ("CAudioManager::CreateSource : Error 0x%08X", error);
  }

  return source;
#else // HAVE_OPENAL

  return 0;

#endif
}


//
// SetSourcePosition
//


//
// CreateSfx
//
// This method allocates a new sound effect and returns its key value.
//   The specified WAV file must exist in the pod filesystem.
//
// Return Code:
//   int    Unique "name" of the sound effect, used as a key in other methods.
//          Return value is 0 if the sound effect could not be created
//
int CAudioManager::CreateSfx (PFS *pfs, const char* wavfile)
{
  int rc = 0;
  bool cached = false;

  // Search existing sound effects to see if this has already been created
  map<string,CSoundEffect*>::iterator iter = cache.find (wavfile);
  if (iter != cache.end()) {
    CSoundEffect *sfx = iter->second;
    rc = sfx->name;
    cached = true;
  }

  // If sound effect is not already cached then try to load it
  if (!cached) {
    // Open WAV file
    PODFILE *p = popen (pfs, wavfile);
    if (p == NULL) {
      // Try prepending SOUND\ path to wav filename
      char wavfilepath [256];
      strcpy (wavfilepath, "SOUND\\");
      strcat (wavfilepath, wavfile);
      p = popen (pfs, wavfilepath);
      if (p == NULL) {
        // No luck
        gtfo ("CAudioManager::CreateSfx : Cannot open WAV file %s", wavfile);
      }
    }

    // Transfer WAV contents into temporary buffer
    int wavSize = p->size;
    char *wavBuffer = new char[wavSize];
    pread (wavBuffer, 1, wavSize, p);
 
#ifdef HAVE_OPENAL

    // Load the WAV from the memory buffer
    void *data;
    ALenum format;
    ALsizei size;
    ALsizei freq;
    ALboolean loop;
    ALenum error;
    alGetError ();
    alutLoadWAVMemory (wavBuffer, &format, &data, &size, &freq, &loop);
    if ((error = alGetError()) != AL_NO_ERROR) {
      gtfo ("CAudioManager::CreateSfx : Load WAV error 0x%08X", error);
    }

    // Create buffer object and load it with the WAV contents
    ALuint buffer;
    alGetError ();
    alGenBuffers (1, &buffer);
    if ((error = alGetError()) != AL_NO_ERROR) {
      gtfo ("CAudioManager::CreateSfx : Gen buffer error 0x%08X", error);
    }

    // Copy data to AL buffer
    alGetError ();
    alBufferData (buffer, format, data, size, freq);
    if ((error = alGetError()) != AL_NO_ERROR) {
      gtfo ("CAudioManager::CreateSfx : BufferData error 0x%08X", error);
    }

    delete[] data;

#endif // HAVE_OPENAL

    // Deallocate WAV buffer and close pod file
    delete[] wavBuffer;
    pclose (p);
  
    // Allocate new CSoundEffect and add to the cache
    CSoundEffect *sfx = new CSoundEffect;
    sfx->bound = false;

#ifdef HAVE_OPENAL

    sfx->buffer = buffer;
    sfx->source = 0;

#endif // HAVE_OPENAL

    strcpy (sfx->wavfile, wavfile);
  
    // For now, unique "name" for the sound effect is the pointer to the
    // SSoundEffect object...it is redundant to store this here but the
    // unique naming scheme may change in the future
    rc = sfx->name = (int)sfx;

    cache[wavfile] = sfx;
  }

  return rc;
}


//
// GetSoundEffect
//
// Get a pointer to the sound effect with the specified name.  If the name
// is not valid, a NULL pointer is returned
//
CSoundEffect *CAudioManager::GetSoundEffect (int name)
{
  CSoundEffect *rc = NULL;

  map<string,CSoundEffect*>::iterator iter;
  for (iter = cache.begin(); iter != cache.end() && (rc == NULL); iter++) {
    CSoundEffect *sfx = iter->second;
    if (sfx->name == name) {
      rc = sfx;
    }
  }

  return rc;
}

//
//  GetFirstSoundEffectByUserData
// 
//  Returns the first sound effect matching the specified user data.  If
//  no cached sound effects match the user data then a NULL pointer is
//  returned.
//

CSoundEffect *CAudioManager::GetFirstSoundEffectByUserData
                             (int user1, int user2)
{
  CSoundEffect *rc = NULL;

  for (iterUserData = cache.begin();
       iterUserData != cache.end() && (rc == NULL);
       iterUserData++)
  {
    CSoundEffect *sfx = iterUserData->second;
    if ((sfx->user1 == user1) && (sfx->user2 == user2)) {
      rc = sfx;
    }
  }

  return rc;
}

//
//  GetNextSoundEffectByUserData
// 
//  Returns the next sound effect matching the specified user data.
//  The method GetFirstSoundEffectByUserData should have been called
//  previously with the same arguments to ensure accurate search results.
//  A NULL pointer is returned if no additional sound effects are found
//  with the specified user data.
//
CSoundEffect *CAudioManager::GetNextSoundEffectByUserData
                             (int user1, int user2)
{
  CSoundEffect *rc = NULL;

  for (;
       iterUserData != cache.end() && (rc == NULL);
       iterUserData++)
  {
    CSoundEffect *sfx = iterUserData->second;
    if ((sfx->user1 == user1) && (sfx->user2 == user2)) {
      rc = sfx;
    }
  }

  return rc;
}

//
// IsValidSfx
//
// Checks that the supplied name refers to a valid sound effect
//
int CAudioManager::IsValidSfx (int name)
{
  return (GetSoundEffect (name) != NULL);
}


//
// AssignSfx
//
void CAudioManager::AssignSfx (int source, int buffer)
{
#ifdef HAVE_OPENAL

  ALint error;

  alGetError ();
  alSourcei (source, AL_BUFFER, buffer);
  if ((error = alGetError()) != AL_NO_ERROR) {
    globals->logWarning->Write ("CAudioManager::AssignSfx : Error 0x%08X", error);
  }

#endif // HAVE_OPENAL
}


//
// PlaySfx
//
// Plays the specified sound effect immediately in one-shot mode (no looping)
//
int CAudioManager::PlaySfx (int source, int name)
{
  CSoundEffect *sfx = GetSoundEffect (name);
  if (sfx != NULL) {

#ifdef HAVE_OPENAL
    // If already attached to a source, stop and disconnect
    if (sfx->source != 0) {
      alSourceStop (sfx->source);
      alSourcei (source, AL_BUFFER, 0);
    }

    // Assign buffer to the specified source
    AssignSfx (source, sfx->buffer);

    // Play the source
    alGetError ();
    alSourcePlay (source);
    if (ALint error = alGetError () != AL_NO_ERROR) {
      globals->logWarning->Write ("CAudioManager::PlaySfx : Error 0x%08X", error);
    }
#endif // HAVE_OPENAL
  }

  return sfx->name;
}

//
// PlaySfxDelay
//
// Plays the specified sound effect in one-shot mode (no looping) after
// the a delay
//
int CAudioManager::PlaySfxDelay (int source, int name, float delay, float *length)
{
  CSoundEffect *sfx = GetSoundEffect (name);
  if (sfx != NULL) {

#ifdef HAVE_OPENAL

    alGetError ();
    alSourcePlay (sfx->source);
    if (ALint error = alGetError () != AL_NO_ERROR) {
      globals->logWarning->Write ("CAudioManager::PlaySfxDelay : Error 0x%08X", error);
    }

#endif // HAVE_OPENAL

  }

  return sfx->name;
}

//
// StopSfx
//
// Stops the specified sound effect if it is currently playing
//
void CAudioManager::StopSfx (int name)
{
  CSoundEffect *sfx = GetSoundEffect (name);
  if (sfx != NULL) {

#ifdef HAVE_OPENAL

    alGetError ();
    alSourceStop (sfx->source);
    if (ALint error = alGetError () != AL_NO_ERROR) {
      globals->logWarning->Write ("CAudioManager::StopSfx : Error 0x%08X", error);
    }

    // Detach
    alSourcei (sfx->source, AL_BUFFER, 0);

#endif // HAVE_OPENAL

  }
}

//
// StopSfxByUserData
//
// Stop playing a sound effect indentified by its user data.  This may
// result in several sound effects being stopped.
//
void CAudioManager::StopSfxByUserData (int user1, int user2)
{
  CSoundEffect *sfx = GetFirstSoundEffectByUserData (user1, user2);
  while (sfx != NULL) {

#ifdef HAVE_OPENAL

    alGetError ();
    alSourceStop (sfx->source);
    if (ALint error = alGetError () != AL_NO_ERROR) {
      globals->logWarning->Write ("CAudioManager::StopSfx : Error 0x%08X", error);
    }

#endif // HAVE_OPENAL

    sfx = GetNextSoundEffectByUserData (user1, user2);
  }
}

//
// SetSfxVolume
//
// Set the relative volume of the sound effect.  The volume setting is
// clamped to the range [0.0, 1.0] where 0.0 is fully attenuated (mute)
// and 1.0 is full volume (original unattenuated WAV).
//
void CAudioManager::SetSfxVolume (int name, float volume)
{
  // Clamp volume to range [0.0, 1.0]
  if (volume < 0.0f) volume = 0.0f;
  if (volume > 1.0f) volume = 1.0f;

  CSoundEffect *sfx = GetSoundEffect (name);
  if (sfx != NULL) {

#ifdef HAVE_OPENAL

    alGetError ();
    alSourcef (sfx->source, AL_GAIN, volume);
    if (ALint error = alGetError () != AL_NO_ERROR) {
      globals->logWarning->Write ("CAudioManager::SetSfxVolume : Error 0x%08X", error);
    }

#endif // HAVE_OPENAL

  }
}

//
// SetSfxPosition (SPosition)
//
// Sets the 3D position of the specified sound effect in Fly! geodetic
// coordinates (lat/lon/alt AGL).  This method only needs to be called
// if the sound effect requires distance attenuation.  By default, all
// sound effects are assumed to be co-located with the listener position.
//
void CAudioManager::SetSfxPosition (int name, SPosition *p)
{
  // SetSfxPosition (v);
}

//
// SetSfxPosition (SVector)
//
// Sets the 3D position of the specified sound effect in cartesian
// coordinates relative to the listener.  The SVector argument specifies
// the distance in feet of the sound effect relative to the listener.
// X-coordinate is positive to the right of the listener
// Y-coordinate is positive above the listener
// Z-coordinate is positive ahead of the listener
//
void CAudioManager::SetSfxPosition (int name, SVector *v)
{
  CSoundEffect *sfx = GetSoundEffect (name);
  if (sfx != NULL) {

#ifdef HAVE_OPENAL

    alGetError ();
    alSource3f (sfx->source, AL_POSITION, v->x, v->y, v->z);
    if (ALint error = alGetError () != AL_NO_ERROR) {
      globals->logWarning->Write ("CAudioManager::SetSfxPosition : Error 0x%08X", error);
    }

#endif // HAVE_OPENAL

  }
}

//
// SetSfxDirection
//
void CAudioManager::SetSfxDirection (int name, SVector *v)
{
  CSoundEffect *sfx = GetSoundEffect (name);
  if (sfx != NULL) {

#ifdef HAVE_OPENAL

    alGetError ();
    alSource3f (sfx->source, AL_DIRECTION, v->x, v->y, v->z);
    if (ALint error = alGetError () != AL_NO_ERROR) {
      globals->logWarning->Write ("CAudioManager::SetSfxDirection : Error 0x%08X", error);
    }

#endif // HAVE_OPENAL

  }
}

//
// SetSfxVelocity
//
// Sets the sound effect velocity relative to the listener.   This method
// only needs to be called if doppler shift is desired on the sound effect.
// By default, all sound effects are assumed to be co-located with the
// listener and therefore have no doppler effect.
//
void CAudioManager::SetSfxVelocity (int name, SVector *v)
{
}

//
// SetSfxFrequency
//
// Set the relative playback frequency for the sound effect.  The
// frequency scalar (freqScalar) parameter is a multiplier against the
// base sampling rate for the sound effect.  Default is 1.0 (normal
// playback rate), a value of 2.0 would play the sound effect at
// double the rate, 0.5 would play it back at half the rate, etc.
// Frequency rate of less than 0.01 is clamped to 0.01
//
void CAudioManager::SetSfxFrequency (int name, float freqScalar)
{
  // Clamp to lower bound of 0.01
  if (freqScalar < 0.01) freqScalar = 0.01f;

  CSoundEffect *sfx = GetSoundEffect (name);
  if (sfx != NULL) {

#ifdef HAVE_OPENAL

    alGetError ();
    alSourcef (sfx->source, AL_PITCH, freqScalar);
    if (ALint error = alGetError () != AL_NO_ERROR) {
      globals->logWarning->Write ("CAudioManager::SetSfxFrequency : Error 0x%08X", error);
    }

#endif // HAVE_OPENAL

  }
}

//
// SetUserData
//
// Every sound effect can optionally have two pieces of user data associated
// with it (for example, a subsystem unique tag and a unit number).  This
// user data can then be used to control playback of all sound effects
// with the matching tag values.
//
void CAudioManager::SetSfxUserData (int name, int user1, int user2)
{
  CSoundEffect *sfx = GetSoundEffect (name);
  if (sfx != NULL) {
    sfx->user1 = user1;
    sfx->user2 = user2;
  }
}

Documentation generated by