al_sound.cpp File Reference

#include "audiolib.h"
#include "hashtable.h"
#include "vsfilesystem.h"
#include <string>
#include "al_globals.h"
#include <stdio.h>
#include <stdlib.h>
#include "cmd/unit_generic.h"
#include "gfx/cockpit_generic.h"
#include <vector>
#include "vs_globals.h"
#include <algorithm>

Go to the source code of this file.

Macros
#define	AL_SEC_OFFSET   0x1024

Functions
bool	AUDLoadSoundFile (const char *s, struct AUDSoundProperties *info, bool use_fileptr)
int	AUDBufferSound (const struct AUDSoundProperties *info, bool music)
int	AUDCreateSoundWAV (const std::string &s, const bool music, const bool LOOP)
int	AUDCreateSoundWAV (const std::string &s, const bool LOOP)
	creates a buffer if one doesn't already exists, and then creates a source More...
int	AUDCreateMusicWAV (const std::string &s, const bool LOOP)
	creates a buffer if one doesn't already exists, and then creates a source More...
int	AUDCreateSoundMP3 (const std::string &s, const bool music, const bool LOOP)
int	AUDCreateSoundMP3 (const std::string &s, const bool LOOP)
	creates a buffer for an mp3 sound if one doesn't already exist, then creates a source More...
int	AUDCreateMusicMP3 (const std::string &s, const bool LOOP)
	creates a buffer for an mp3 sound if one doesn't already exist, then creates a source More...
int	AUDCreateSound (const std::string &s, const bool LOOP)
	guesses the type of sound by extension More...
int	AUDCreateMusic (const std::string &s, const bool LOOP)
	guesses the type of sound by extension More...
int	AUDCreateSound (int sound, const bool LOOP)
	copies other sound loaded through AUDCreateSound More...
void	AUDDeleteSound (int sound, bool music)
	deletes a given sound More...
void	AUDAdjustSound (const int sound, const QVector &pos, const Vector &vel)
	Changes the velocity and/or position of a given sound. More...
void	AUDStreamingSound (const int sound)
	Setup the sound as a streaming source (this means right now only that it doesn't do 3D positional stuff) More...
bool	starSystemOK ()
int	AUDHighestSoundPlaying ()
void	AUDStopAllSounds (int except_this_one)
bool	AUDIsPlaying (const int sound)
	Is a loaded sound still playing. More...
void	AUDStopPlaying (const int sound)
	Stops a loaded sound. More...
static bool	AUDReclaimSource (const int sound, bool high_priority=false)
void	AUDStartPlaying (const int sound)
	Plays a loaded sound. More...
void	AUDPlay (const int sound, const QVector &pos, const Vector &vel, const float gain)
	Queries if the sound should be culled. If not, plays. More...
float	AUDGetCurrentPosition (const int sound)
	Gets the current playback position in seconds (precision is system&driver-dependant) More...
void	AUDPausePlaying (const int sound)
	Pauses a loaded sound. More...

Variables
unsigned int	nil_wavebuf = 0
std::vector< int >	soundstodelete

Macro Definition Documentation

#define AL_SEC_OFFSET   0x1024

Definition at line 895 of file al_sound.cpp.

Referenced by AUDGetCurrentPosition(), Audio::OpenALRenderableSource::getPlayingTimeImpl(), Audio::OpenALRenderableStreamingSource::getPlayingTimeImpl(), and Audio::OpenALRenderableSource::seekImpl().

Function Documentation

void AUDAdjustSound	(	const int	sound,
		const QVector &	pos,
		const Vector &	vel
	)

Changes the velocity and/or position of a given sound.

Definition at line 683 of file al_sound.cpp.

Referenced by AUDPlay(), AUDStartPlaying(), Beam::Draw(), GameUnit< UnitType >::Draw(), Mount::PhysicsAlignedFire(), soundContainer::playsound(), UniverseUtil::playSound(), GameUnit< UnitType >::ResolveForces(), Beam::UpdatePhysics(), and Unit::UpdatePhysics().

{
    static float ref_distance = XMLSupport::parse_float( vs_config->getVariable( "audio", "audio_ref_distance", "4000" ) );
    static float max_distance = XMLSupport::parse_float( vs_config->getVariable( "audio", "audio_max_distance", "1000000" ) );
    
#ifdef HAVE_AL
    if ( sound >= 0 && sound < (int) sounds.size() ) {
        float p[] = {
            scalepos *pos.i, scalepos*pos.j, scalepos*pos.k
        }
        ;
        float v[] = {scalevel *vel.i, scalevel*vel.j, scalevel*vel.k};
        sounds[sound].pos = pos.Cast();
        sounds[sound].vel = vel;
        if (usepositional && sounds[sound].source) {
            alSourcefv( sounds[sound].source, AL_POSITION, p );
            bool relative = (p[0] == 0 && p[1] == 0 && p[2] == 0);
            alSourcei( sounds[sound].source, AL_SOURCE_RELATIVE, relative );
            if (!relative) {
                // Set rolloff factrs
                alSourcef(sounds[sound].source, AL_MAX_DISTANCE, scalepos * max_distance);
                alSourcef(sounds[sound].source, AL_REFERENCE_DISTANCE, scalepos * ref_distance);
                alSourcef(sounds[sound].source, AL_ROLLOFF_FACTOR, 1.f);
            }
        }
        if (usedoppler && sounds[sound].source)
            alSourcefv( sounds[sound].source, AL_VELOCITY, v );
    }
#endif
}

int AUDBufferSound	(	const struct AUDSoundProperties *	info,
		bool	music
	)

Definition at line 477 of file al_sound.cpp.

Referenced by Music::Listen().

{
    ALuint wavbuf = 0;
#ifdef HAVE_AL
    alGenBuffers( 1, &wavbuf );
    if (!wavbuf) printf( "OpenAL Error in alGenBuffers: %d\n", alGetError() );
    alBufferData( wavbuf, info->format, info->wave, info->size, info->freq );
#endif
    return LoadSound( wavbuf, info->looping, music );
}

int AUDCreateMusic	(	const std::string &	s,
		const bool	LOOP
	)

guesses the type of sound by extension

Definition at line 615 of file al_sound.cpp.

References AUDCreateMusicMP3(), and AUDCreateMusicWAV().

{
    if ( s.end()-1 >= s.begin() ) {
        if (*(s.end()-1) == 'v')
            return AUDCreateMusicWAV( s, LOOP );
        else
            return AUDCreateMusicMP3( s, LOOP );
    }
    return -1;
}

int AUDCreateMusicMP3	(	const std::string &	s,
		const bool	LOOP
	)

creates a buffer for an mp3 sound if one doesn't already exist, then creates a source

Definition at line 599 of file al_sound.cpp.

References AUDCreateSoundMP3().

Referenced by AUDCreateMusic().

{
    return AUDCreateSoundMP3( s, true, LOOP );
}

int AUDCreateMusicWAV	(	const std::string &	s,
		const bool	LOOP
	)

creates a buffer if one doesn't already exists, and then creates a source

Definition at line 545 of file al_sound.cpp.

References AUDCreateSoundWAV().

Referenced by AUDCreateMusic().

{
    return AUDCreateSoundWAV( s, true, LOOP );
}

int AUDCreateSound	(	const std::string &	s,
		const bool	LOOP
	)

guesses the type of sound by extension

Definition at line 604 of file al_sound.cpp.

Referenced by AddMounts(), AddSounds(), Beam::Beam(), GameStarSystem::DoJumpingLeaveSightAndSound(), Mount::PhysicsAlignedFire(), Mount::ReplaceSound(), GameUnit< UnitType >::Thrust(), and GameUnit< UnitType >::TransferUnitToSystem().

{
    if ( s.end()-1 >= s.begin() ) {
        if (*(s.end()-1) == '3')
            return AUDCreateSoundMP3( s, LOOP );
        else
            return AUDCreateSoundWAV( s, LOOP );
    }
    return -1;
}

int AUDCreateSound	(	int	sound,
		const bool	LOOP
	)

copies other sound loaded through AUDCreateSound

Definition at line 627 of file al_sound.cpp.

{
#ifdef HAVE_AL
    if ( AUDIsPlaying( sound ) )
        AUDStopPlaying( sound );
    if ( sound >= 0 && sound < (int) sounds.size() )
        return LoadSound( sounds[sound].buffer, LOOP, false );
#endif
    return -1;
}

int AUDCreateSoundMP3	(	const std::string &	s,
		const bool	music,
		const bool	LOOP
	)

Definition at line 550 of file al_sound.cpp.

References VSFileSystem::VSFile::Close(), error, f, g_game, VSFileSystem::GetHashName(), VSFileSystem::GetSharedSoundHashName(), game_data_t::music_enabled, VSFileSystem::Ok, VSFileSystem::VSFile::OpenReadOnly(), VSFileSystem::VSFile::Read(), VSFileSystem::Shared, VSFileSystem::VSFile::Size(), game_data_t::sound_enabled, and VSFileSystem::SoundFile.

Referenced by AUDCreateMusicMP3(), AUDCreateSound(), AUDCreateSoundMP3(), and BeamXML::beginElement().

{
#ifdef HAVE_AL
    assert( 0 );
    if ( (g_game.sound_enabled && !music) || (g_game.music_enabled && music) ) {
        VSFile      f;
        VSError     error  = f.OpenReadOnly( s.c_str(), SoundFile );
        bool        shared = (error == Shared);
        std::string nam( s );
        ALuint     *mp3buf = NULL;
        std::string hashname;
        if (!music) {
            hashname = shared ? VSFileSystem::GetSharedSoundHashName( s ) : VSFileSystem::GetHashName( s );
            mp3buf   = soundHash.Get( hashname );
        }
        if (error > Ok)
            return -1;
#ifdef _WIN32
        return -1;
#endif
        if (mp3buf == NULL) {
            char *data = new char[f.Size()];
            f.Read( data, f.Size() );
            mp3buf = (ALuint*) malloc( sizeof (ALuint) );
            alGenBuffers( 1, mp3buf );
            /*
             *  if ((*alutLoadMP3p)(*mp3buf,data,f.Size())!=AL_TRUE) {
             *     delete []data;
             *         return -1;
             *         }*/
            delete[] data;
            if (!music) {
                soundHash.Put( hashname, mp3buf );
                buffers.push_back( *mp3buf );
            }
        } else {
            f.Close();
        }
        return LoadSound( *mp3buf, LOOP, music );
    }
#endif
    return -1;
}

int AUDCreateSoundMP3	(	const std::string &	s,
		const bool	LOOP
	)

creates a buffer for an mp3 sound if one doesn't already exist, then creates a source

Definition at line 594 of file al_sound.cpp.

{
    return AUDCreateSoundMP3( s, false, LOOP );
}

int AUDCreateSoundWAV	(	const std::string &	s,
		const bool	music,
		const bool	LOOP
	)

Definition at line 495 of file al_sound.cpp.

References AUDLoadSoundFile(), g_game, VSFileSystem::GetHashName(), VSFileSystem::GetSharedSoundHashName(), game_data_t::music_enabled, nil_wavebuf, and game_data_t::sound_enabled.

Referenced by abletodock(), AddSounds(), GameUnit< UnitType >::ArmorDamageSound(), AUDCreateMusicWAV(), AUDCreateSound(), AUDCreateSoundWAV(), BeamXML::beginElement(), BaseInterface::Room::Talk::Click(), Beam::Collide(), createSound(), GameUnit< UnitType >::DealDamageToShield(), GameUnit< UnitType >::HullDamageSound(), soundContainer::loadsound(), UniverseUtil::playSound(), UniverseUtil::playSoundCockpit(), GameCockpit::SetSoundFile(), and Unit::UpdatePhysics().

{
#ifdef HAVE_AL
#ifdef SOUND_DEBUG
    printf( "AUDCreateSoundWAV:: " );
#endif
    if ( (g_game.sound_enabled && !music) || (g_game.music_enabled && music) ) {
        ALuint     *wavbuf = NULL;
        std::string hashname;
        if (!music) {
            hashname = VSFileSystem::GetHashName( s );
            wavbuf   = soundHash.Get( hashname );
            if (!wavbuf) {
                hashname = VSFileSystem::GetSharedSoundHashName( s );
                wavbuf   = soundHash.Get( hashname );
            }
            if (wavbuf == &nil_wavebuf)
                return -1;                  //404
        }
        if (wavbuf) {
#ifdef SOUND_DEBUG
            printf( "Sound %s restored with alBuffer %d\n", s.c_str(), *wavbuf );
#endif
        }
        if (wavbuf == NULL) {
            AUDSoundProperties info;
            if ( !AUDLoadSoundFile( s.c_str(), &info ) ) {
                soundHash.Put( info.hashname, &nil_wavebuf );
                return -1;
            }
            wavbuf = (ALuint*) malloc( sizeof (ALuint) );
            alGenBuffers( 1, wavbuf );
            alBufferData( *wavbuf, info.format, info.wave, info.size, info.freq );
            free( info.wave );             //alutUnloadWAV(format,wave,size,freq);
            if (!music) {
                soundHash.Put( info.hashname, wavbuf );
                buffers.push_back( *wavbuf );
            }
        }
        return LoadSound( *wavbuf, LOOP, music );
    }
#endif
    return -1;
}

int AUDCreateSoundWAV	(	const std::string &	s,
		const bool	LOOP
	)

creates a buffer if one doesn't already exists, and then creates a source

Definition at line 540 of file al_sound.cpp.

{
    return AUDCreateSoundWAV( s, false, LOOP );
}

void AUDDeleteSound	(	int	sound,
		bool	music
	)

deletes a given sound

Definition at line 639 of file al_sound.cpp.

Referenced by AUDDestroy(), AUDRefreshSounds(), Unit::ClearMounts(), BaseInterface::Room::Talk::Click(), Unit::Kill(), Music::Listen(), Mount::PhysicsAlignedFire(), UniverseUtil::playSound(), UniverseUtil::playSoundCockpit(), Beam::~Beam(), and soundContainer::~soundContainer().

{
#ifdef HAVE_AL
    if ( sound >= 0 && sound < (int) sounds.size() ) {
        if ( AUDIsPlaying( sound ) ) {
            if (!music) {
#ifdef SOUND_DEBUG
                printf( "AUDDeleteSound: Sound Playing enqueue soundstodelete %d %d\n",
                        sounds[sound].source,
                        sounds[sound].buffer );
#endif
                soundstodelete.push_back( sound );
                return;
            } else {
                AUDStopPlaying( sound );
            }
        }
#ifdef SOUND_DEBUG
        printf( "AUDDeleteSound: Sound Not Playing push back to unused src %d %d\n", sounds[sound].source, sounds[sound].buffer );
#endif
        if (sounds[sound].source) {
            unusedsrcs.push_back( sounds[sound].source );
            alSourcei( sounds[sound].source, AL_BUFFER, 0 );             //decrement the source refcount
            sounds[sound].source = (ALuint) 0;
        }
#ifdef SOUND_DEBUG
        if ( std::find( dirtysounds.begin(), dirtysounds.end(), sound ) == dirtysounds.end() ) {
#endif
        dirtysounds.push_back( sound );
#ifdef SOUND_DEBUG
    } else {
        VSFileSystem::vs_fprintf( stderr, "double delete of sound %d", sound );
        return;
    }
#endif
        //FIXME??
        //alDeleteSources(1,&sounds[sound].source);
        if (music)
            alDeleteBuffers( 1, &sounds[sound].buffer );
        sounds[sound].buffer = (ALuint) 0;
    }
#endif
}

float AUDGetCurrentPosition

(

const int

sound)

Gets the current playback position in seconds (precision is system&driver-dependant)

Definition at line 898 of file al_sound.cpp.

References AL_SEC_OFFSET, and float.

{
#ifdef HAVE_AL
    ALfloat rv;
    alGetSourcef( sound, AL_SEC_OFFSET, &rv );
    return float(rv);
#else
    return 0;
#endif
}

int AUDHighestSoundPlaying

(

)

Definition at line 738 of file al_sound.cpp.

References AUDIsPlaying().

Referenced by BaseInterface::BaseInterface().

{
    int retval     = -1;
#ifdef HAVE_AL
    unsigned int s = ::sounds.size();
    for (unsigned int i = 0; i < s; ++i)
        if (false == ::sounds[i].music && AUDIsPlaying( i ) && false == ::sounds[i].looping)
            retval = i;
#endif
    return retval;
}

bool AUDIsPlaying

(

const int

sound)

Is a loaded sound still playing.

Definition at line 760 of file al_sound.cpp.

Referenced by GameUnit< UnitType >::ArmorDamageSound(), AUDCreateSound(), AUDDeleteSound(), AUDHighestSoundPlaying(), AUDPlay(), AUDRefreshSounds(), AUDStopAllSounds(), GameUnit< UnitType >::DealDamageToShield(), FireKeyboard::Execute(), GameUnit< UnitType >::HullDamageSound(), Music::Listen(), Mount::PhysicsAlignedFire(), Mount::PhysicsAlignedUnfire(), FireKeyboard::ProcessCommMessage(), FSM::Node::StopSound(), GameUnit< UnitType >::Thrust(), Beam::UpdatePhysics(), Unit::UpdatePhysics(), and UpdateTimeCompressionSounds().

{
#ifdef HAVE_AL
    if ( sound >= 0 && sound < (int) sounds.size() ) {
        if (!sounds[sound].source)
            return false;
        ALint state;
#if defined (_WIN32) || defined (__APPLE__)
        alGetSourcei( sounds[sound].source, AL_SOURCE_STATE, &state );         //Obtiene el estado de la fuente para windows
#else
        alGetSourceiv( sounds[sound].source, AL_SOURCE_STATE, &state );
#endif

        return state == AL_PLAYING;
    }
#endif
    return false;
}

bool AUDLoadSoundFile	(	const char *	s,
		struct AUDSoundProperties *	info,
		bool	use_fileptr
	)

Definition at line 409 of file al_sound.cpp.

References VSFileSystem::VSFile::Close(), error, f, fclose, fopen, VSFileSystem::GetHashName(), VSFileSystem::GetSharedSoundHashName(), VSFileSystem::Ok, VSFileSystem::VSFile::OpenReadOnly(), VSFileSystem::VSFile::Read(), VSFileSystem::Shared, VSFileSystem::VSFile::Size(), VSFileSystem::SoundFile, VSFileSystem::UnknownFile, and VSFileSystem::vs_dprintf().

Referenced by AUDCreateSoundWAV(), and Muzak::readerThread().

{
    VSFileSystem::vs_dprintf(3, "Loading sound file %s\n", s);
    
    info->success = false;
    vector< char >dat;
    if (use_fileptr) {
        FILE *f = fopen( s, "rb" );
        if (!f) {
            std::string path = std::string( "sounds/" )+s;
            f = fopen( path.c_str(), "rb" );
        }
        if (!f) {
            std::string path = std::string( "music/" )+s;
            f = fopen( path.c_str(), "rb" );
        }
        if (f) {
            fseek( f, 0, SEEK_END );
            size_t siz = ftell( f );
            fseek( f, 0, SEEK_SET );
            dat.resize( siz );
            size_t bogus_return_var; //added by chuck_starchaser to get rid of warning
            bogus_return_var = fread( &dat[0], 1, siz, f );
            info->hashname = s;
            info->shared   = false;
            fclose( f );
        } else {
            return false;
        }
    } else {
        VSFile  f;
        VSError error = f.OpenReadOnly( s, SoundFile );
        if (error > Ok)
            error = f.OpenReadOnly( s, UnknownFile );
        info->shared = (error == Shared);
        if (info->shared)
            info->hashname = VSFileSystem::GetSharedSoundHashName( s );
        else
            info->hashname = VSFileSystem::GetHashName( s );
        if (error > Ok)
            return false;
#ifdef SOUND_DEBUG
        printf( "Sound %s created with and alBuffer %d\n", s.c_str(), *wavbuf );
#endif
        dat.resize( f.Size() );
        f.Read( &dat[0], f.Size() );
        f.Close();
    }
    ConvertFormat( dat );
    if (dat.size() == 0)      //conversion messed up
        return false;
    //blutLoadWAVMemory((ALbyte *)&dat[0], &format, &wave, &size, &freq, &looping);

#if 0
    ALint format;
    //MAC OS X
    if (error <= Ok)
        MacFixedLoadWAVFile( &dat[0], &format, &wave, &size, &freq );
#else
    blutLoadWAVMemory( (ALbyte*) &dat[0], &info->format, &info->wave, &info->size, &info->freq, &info->looping );
#endif
    if (!info->wave)
        return false;          //failure.

    info->success = true;
    return true;
}

void AUDPausePlaying

(

const int

sound)

Pauses a loaded sound.

Definition at line 909 of file al_sound.cpp.

{
#ifdef HAVE_AL
    if ( sound >= 0 && sound < (int) sounds.size() ) {
        //alSourcePlay( sounds[sound].source() );
    }
#endif
}

void AUDPlay	(	const int	sound,
		const QVector &	pos,
		const Vector &	vel,
		const float	gain
	)

Queries if the sound should be culled. If not, plays.

Definition at line 862 of file al_sound.cpp.

Referenced by abletodock(), GameUnit< UnitType >::ArmorDamageSound(), Beam::Collide(), GameUnit< UnitType >::DealDamageToShield(), GameStarSystem::DoJumpingLeaveSightAndSound(), FireKeyboard::Execute(), GameUnit< UnitType >::Explode(), GameUnit< UnitType >::HullDamageSound(), Mount::PhysicsAlignedFire(), soundContainer::playsound(), FireKeyboard::ProcessCommMessage(), GameCockpit::ScrollVDU(), GameUnit< UnitType >::Thrust(), GameUnit< UnitType >::TransferUnitToSystem(), and GameCockpit::VDUSwitch().

{
#ifdef HAVE_AL
    char tmp;
    if (sound < 0)
        return;
    if (sounds[sound].buffer == 0)
        return;
    if (!starSystemOK() && !sounds[sound].music)
        return;
    if ( AUDIsPlaying( sound ) )
        AUDStopPlaying( sound );
    if ( ( tmp = AUDQueryAudability( sound, pos.Cast(), vel, gain ) ) != 0 ) {
        if ( AUDReclaimSource( sound, pos == QVector( 0, 0, 0 ) ) ) {
            AUDAdjustSound( sound, pos, vel );
            AUDSoundGain( sound, gain, sounds[sound].music );
            if (tmp != 2) {
                VSFileSystem::vs_dprintf(3, "AUDPlay sound %d %d\n", 
                    sounds[sound].source, sounds[sound].buffer );
                AUDAddWatchedPlayed( sound, pos.Cast() );
            } else {
                VSFileSystem::vs_dprintf(3, "AUDPlay stole sound %d %d\n", 
                    sounds[sound].source, sounds[sound].buffer );
                alSourceStop( sounds[sound].source );
            }
            alSourcePlay( sounds[sound].source );
        }
    }
#endif
}

static bool AUDReclaimSource ( const int  sound, bool  high_priority = false  )

static

Definition at line 796 of file al_sound.cpp.

References AUDDistanceSquared().

Referenced by AUDPlay(), and AUDStartPlaying().

{
#ifdef HAVE_AL
    if (sounds[sound].source == (ALuint) 0) {
        if (!sounds[sound].buffer)
            return false;
        if ( unusedsrcs.empty() ) {
            if (high_priority) {
                unsigned int i;
                unsigned int candidate = 0;
                bool found = false;
                for (i = 0; i < sounds.size(); ++i)
                    if (sounds[i].source != 0)
                        if (sounds[i].pos.i != 0 || sounds[i].pos.j != 0 || sounds[i].pos.k != 0) {
                            if (found) {
                                if ( AUDDistanceSquared( candidate ) < AUDDistanceSquared( i ) )
                                    candidate = i;
                            } else {
                                candidate = i;
                            }
                            found = true;
                        }
                if (!found) {
                    return false;
                } else {
                    alSourceStop( sounds[candidate].source );
                    sounds[sound].source     = sounds[candidate].source;
                    alSourcei( sounds[candidate].source, AL_BUFFER, 0 );                     //reclaim the source
                    sounds[candidate].source = 0;
                }
            } else {
                return false;
            }
        } else {
            sounds[sound].source = unusedsrcs.back();
            unusedsrcs.pop_back();
        }
        alSourcei( sounds[sound].source, AL_BUFFER, sounds[sound].buffer );
        alSourcei( sounds[sound].source, AL_LOOPING, sounds[sound].looping );
    }
    return true;
#endif
    return false;     //silly
}

void AUDStartPlaying

(

const int

sound)

Plays a loaded sound.

Definition at line 841 of file al_sound.cpp.

Referenced by BaseInterface::Room::Talk::Click(), Beam::Init(), Music::Listen(), UniverseUtil::playSound(), UniverseUtil::playSoundCockpit(), and Unit::UpdatePhysics().

{
#ifdef SOUND_DEBUG
    printf( "AUDStartPlaying(%d)", sound );
#endif

#ifdef HAVE_AL
    if ( sound >= 0 && sound < (int) sounds.size() ) {
        if ( sounds[sound].music || starSystemOK() )
            if ( AUDReclaimSource( sound, sounds[sound].pos == QVector( 0, 0, 0 ) ) ) {
#ifdef SOUND_DEBUG
                printf( "AUDStartPlaying sound %d source:%d buffer:%d\n", sound, sounds[sound].source, sounds[sound].buffer );
#endif
                AUDAdjustSound( sound, sounds[sound].pos, sounds[sound].vel );
                AUDSoundGain( sound, sounds[sound].gain, sounds[sound].music );
                alSourcePlay( sounds[sound].source );
            }
    }
#endif
}

void AUDStopAllSounds

(

int

except_this_one)

Definition at line 750 of file al_sound.cpp.

References AUDIsPlaying(), and AUDStopPlaying().

Referenced by BaseComputer::actionDone(), base_main_loop(), UniverseUtil::StopAllSounds(), and GameUnit< UnitType >::TransferUnitToSystem().

{
#ifdef HAVE_AL
    unsigned int s = ::sounds.size();
    for (unsigned int i = 0; i < s; ++i)
        if ( (int) i != except_this_one && false == ::sounds[i].music && AUDIsPlaying( i ) )
            AUDStopPlaying( i );
#endif
}

void AUDStopPlaying

(

const int

sound)

Stops a loaded sound.

Definition at line 779 of file al_sound.cpp.

Referenced by GameUnit< UnitType >::ArmorDamageSound(), AUDCreateSound(), AUDDeleteSound(), AUDDestroy(), AUDPlay(), AUDStopAllSounds(), GameUnit< UnitType >::DealDamageToShield(), DestroyMount(), GameUnit< UnitType >::HullDamageSound(), Unit::Kill(), Mount::PhysicsAlignedFire(), Mount::PhysicsAlignedUnfire(), FSM::Node::StopSound(), GameUnit< UnitType >::Thrust(), Beam::UpdatePhysics(), Unit::UpdatePhysics(), UpdateTimeCompressionSounds(), and soundContainer::~soundContainer().

{
#ifdef HAVE_AL
    if ( sound >= 0 && sound < (int) sounds.size() ) {
#ifdef SOUND_DEBUG
        printf( "AUDStopPlaying sound %d source(releasing): %d buffer:%d\n", sound, sounds[sound].source, sounds[sound].buffer );
#endif
        if (sounds[sound].source != 0) {
            alSourceStop( sounds[sound].source );
            unusedsrcs.push_back( sounds[sound].source );
            alSourcei( sounds[sound].source, AL_BUFFER, 0 );             //decrement refcount
        }
        sounds[sound].source = (ALuint) 0;
    }
#endif
}

void AUDStreamingSound

(

const int

sound)

Setup the sound as a streaming source (this means right now only that it doesn't do 3D positional stuff)

Definition at line 714 of file al_sound.cpp.

References Audio::alSource3f().

Referenced by Music::Listen().

{
#ifdef HAVE_AL
    if (sound >= 0 && sound < (int) sounds.size() && sounds[sound].source) {
        alSource3f( sounds[sound].source, AL_POSITION, 0.0, 0.0, 0.0 );
        alSource3f( sounds[sound].source, AL_VELOCITY, 0.0, 0.0, 0.0 );
        alSource3f( sounds[sound].source, AL_DIRECTION, 0.0, 0.0, 0.0 );
        alSourcef( sounds[sound].source, AL_ROLLOFF_FACTOR, 0.0 );
        alSourcei( sounds[sound].source, AL_SOURCE_RELATIVE, AL_TRUE );
    }
#endif
}

bool starSystemOK

(

)

Definition at line 727 of file al_sound.cpp.

References _Universe, Universe::AccessCockpit(), Universe::activeStarSystem(), Cockpit::GetParent(), and Unit::getStarSystem().

Referenced by AUDPlay(), and AUDStartPlaying().

{
    if ( !_Universe || !_Universe->AccessCockpit( 0 ) )
        return true;          //No Universe yet, so game is loading.

    Unit *playa = _Universe->AccessCockpit( 0 )->GetParent();
    if (!playa)
        return false;
    return playa->getStarSystem() == _Universe->activeStarSystem();
}

Variable Documentation

unsigned int nil_wavebuf = 0

Definition at line 493 of file al_sound.cpp.

Referenced by AUDCreateSoundWAV().

std::vector< int > soundstodelete

Definition at line 172 of file al_listen.cpp.

Referenced by AUDDeleteSound(), and AUDRefreshSounds().