mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-27 14:42:23 +00:00
736ec20d4d
Don't include the lazy precompiled.h everywhere, only what's required for the compilation unit. platform.h needs to be included instead to provide all essential defines and types. All includes use the relative path to the neo or the game specific root. Move all idlib related includes from idlib/Lib.h to precompiled.h. precompiled.h still exists for the MFC stuff in tools/. Add some missing header guards.
703 lines
18 KiB
C++
703 lines
18 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "sys/platform.h"
|
|
#include "framework/FileSystem.h"
|
|
|
|
#include "sound/snd_local.h"
|
|
|
|
#define USE_SOUND_CACHE_ALLOCATOR
|
|
|
|
#ifdef USE_SOUND_CACHE_ALLOCATOR
|
|
static idDynamicBlockAlloc<byte, 1<<20, 1<<10> soundCacheAllocator;
|
|
#else
|
|
static idDynamicAlloc<byte, 1<<20, 1<<10> soundCacheAllocator;
|
|
#endif
|
|
|
|
/*
|
|
===================
|
|
idSoundCache::idSoundCache()
|
|
===================
|
|
*/
|
|
idSoundCache::idSoundCache() {
|
|
soundCacheAllocator.Init();
|
|
soundCacheAllocator.SetLockMemory( true );
|
|
listCache.AssureSize( 1024, NULL );
|
|
listCache.SetGranularity( 256 );
|
|
insideLevelLoad = false;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundCache::~idSoundCache()
|
|
===================
|
|
*/
|
|
idSoundCache::~idSoundCache() {
|
|
listCache.DeleteContents( true );
|
|
soundCacheAllocator.Shutdown();
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundCache::::GetObject
|
|
|
|
returns a single cached object pointer
|
|
===================
|
|
*/
|
|
const idSoundSample* idSoundCache::GetObject( const int index ) const {
|
|
if (index<0 || index>listCache.Num()) {
|
|
return NULL;
|
|
}
|
|
return listCache[index];
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundCache::FindSound
|
|
|
|
Adds a sound object to the cache and returns a handle for it.
|
|
===================
|
|
*/
|
|
idSoundSample *idSoundCache::FindSound( const idStr& filename, bool loadOnDemandOnly ) {
|
|
idStr fname;
|
|
|
|
fname = filename;
|
|
fname.BackSlashesToSlashes();
|
|
fname.ToLower();
|
|
|
|
declManager->MediaPrint( "%s\n", fname.c_str() );
|
|
|
|
// check to see if object is already in cache
|
|
for( int i = 0; i < listCache.Num(); i++ ) {
|
|
idSoundSample *def = listCache[i];
|
|
if ( def && def->name == fname ) {
|
|
def->levelLoadReferenced = true;
|
|
if ( def->purged && !loadOnDemandOnly ) {
|
|
def->Load();
|
|
}
|
|
return def;
|
|
}
|
|
}
|
|
|
|
// create a new entry
|
|
idSoundSample *def = new idSoundSample;
|
|
|
|
int shandle = listCache.FindNull();
|
|
if ( shandle != -1 ) {
|
|
listCache[shandle] = def;
|
|
} else {
|
|
shandle = listCache.Append( def );
|
|
}
|
|
|
|
def->name = fname;
|
|
def->levelLoadReferenced = true;
|
|
def->onDemand = loadOnDemandOnly;
|
|
def->purged = true;
|
|
|
|
if ( !loadOnDemandOnly ) {
|
|
// this may make it a default sound if it can't be loaded
|
|
def->Load();
|
|
}
|
|
|
|
return def;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundCache::ReloadSounds
|
|
|
|
Completely nukes the current cache
|
|
===================
|
|
*/
|
|
void idSoundCache::ReloadSounds( bool force ) {
|
|
int i;
|
|
|
|
for( i = 0; i < listCache.Num(); i++ ) {
|
|
idSoundSample *def = listCache[i];
|
|
if ( def ) {
|
|
def->Reload( force );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
====================
|
|
BeginLevelLoad
|
|
|
|
Mark all file based images as currently unused,
|
|
but don't free anything. Calls to ImageFromFile() will
|
|
either mark the image as used, or create a new image without
|
|
loading the actual data.
|
|
====================
|
|
*/
|
|
void idSoundCache::BeginLevelLoad() {
|
|
insideLevelLoad = true;
|
|
|
|
for ( int i = 0 ; i < listCache.Num() ; i++ ) {
|
|
idSoundSample *sample = listCache[ i ];
|
|
if ( !sample ) {
|
|
continue;
|
|
}
|
|
|
|
if ( com_purgeAll.GetBool() ) {
|
|
sample->PurgeSoundSample();
|
|
}
|
|
|
|
sample->levelLoadReferenced = false;
|
|
}
|
|
|
|
soundCacheAllocator.FreeEmptyBaseBlocks();
|
|
}
|
|
|
|
/*
|
|
====================
|
|
EndLevelLoad
|
|
|
|
Free all samples marked as unused
|
|
====================
|
|
*/
|
|
void idSoundCache::EndLevelLoad() {
|
|
int useCount, purgeCount;
|
|
common->Printf( "----- idSoundCache::EndLevelLoad -----\n" );
|
|
|
|
insideLevelLoad = false;
|
|
|
|
// purge the ones we don't need
|
|
useCount = 0;
|
|
purgeCount = 0;
|
|
for ( int i = 0 ; i < listCache.Num() ; i++ ) {
|
|
idSoundSample *sample = listCache[ i ];
|
|
if ( !sample ) {
|
|
continue;
|
|
}
|
|
if ( sample->purged ) {
|
|
continue;
|
|
}
|
|
if ( !sample->levelLoadReferenced ) {
|
|
// common->Printf( "Purging %s\n", sample->name.c_str() );
|
|
purgeCount += sample->objectMemSize;
|
|
sample->PurgeSoundSample();
|
|
} else {
|
|
useCount += sample->objectMemSize;
|
|
}
|
|
}
|
|
|
|
soundCacheAllocator.FreeEmptyBaseBlocks();
|
|
|
|
common->Printf( "%5ik referenced\n", useCount / 1024 );
|
|
common->Printf( "%5ik purged\n", purgeCount / 1024 );
|
|
common->Printf( "----------------------------------------\n" );
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundCache::PrintMemInfo
|
|
===================
|
|
*/
|
|
void idSoundCache::PrintMemInfo( MemInfo_t *mi ) {
|
|
int i, j, num = 0, total = 0;
|
|
int *sortIndex;
|
|
idFile *f;
|
|
|
|
f = fileSystem->OpenFileWrite( mi->filebase + "_sounds.txt" );
|
|
if ( !f ) {
|
|
return;
|
|
}
|
|
|
|
// count
|
|
for ( i = 0; i < listCache.Num(); i++, num++ ) {
|
|
if ( !listCache[i] ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// sort first
|
|
sortIndex = new int[num];
|
|
|
|
for ( i = 0; i < num; i++ ) {
|
|
sortIndex[i] = i;
|
|
}
|
|
|
|
for ( i = 0; i < num - 1; i++ ) {
|
|
for ( j = i + 1; j < num; j++ ) {
|
|
if ( listCache[sortIndex[i]]->objectMemSize < listCache[sortIndex[j]]->objectMemSize ) {
|
|
int temp = sortIndex[i];
|
|
sortIndex[i] = sortIndex[j];
|
|
sortIndex[j] = temp;
|
|
}
|
|
}
|
|
}
|
|
|
|
// print next
|
|
for ( i = 0; i < num; i++ ) {
|
|
idSoundSample *sample = listCache[sortIndex[i]];
|
|
|
|
// this is strange
|
|
if ( !sample ) {
|
|
continue;
|
|
}
|
|
|
|
total += sample->objectMemSize;
|
|
f->Printf( "%s %s\n", idStr::FormatNumber( sample->objectMemSize ).c_str(), sample->name.c_str() );
|
|
}
|
|
|
|
mi->soundAssetsTotal = total;
|
|
|
|
f->Printf( "\nTotal sound bytes allocated: %s\n", idStr::FormatNumber( total ).c_str() );
|
|
fileSystem->CloseFile( f );
|
|
}
|
|
|
|
|
|
/*
|
|
==========================================================================
|
|
|
|
idSoundSample
|
|
|
|
==========================================================================
|
|
*/
|
|
|
|
/*
|
|
===================
|
|
idSoundSample::idSoundSample
|
|
===================
|
|
*/
|
|
idSoundSample::idSoundSample() {
|
|
memset( &objectInfo, 0, sizeof(waveformatex_t) );
|
|
objectSize = 0;
|
|
objectMemSize = 0;
|
|
nonCacheData = NULL;
|
|
amplitudeData = NULL;
|
|
openalBuffer = 0;
|
|
hardwareBuffer = false;
|
|
defaultSound = false;
|
|
onDemand = false;
|
|
purged = false;
|
|
levelLoadReferenced = false;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundSample::~idSoundSample
|
|
===================
|
|
*/
|
|
idSoundSample::~idSoundSample() {
|
|
PurgeSoundSample();
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundSample::LengthIn44kHzSamples
|
|
===================
|
|
*/
|
|
int idSoundSample::LengthIn44kHzSamples( void ) const {
|
|
// objectSize is samples
|
|
if ( objectInfo.nSamplesPerSec == 11025 ) {
|
|
return objectSize << 2;
|
|
} else if ( objectInfo.nSamplesPerSec == 22050 ) {
|
|
return objectSize << 1;
|
|
} else {
|
|
return objectSize << 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundSample::MakeDefault
|
|
===================
|
|
*/
|
|
void idSoundSample::MakeDefault( void ) {
|
|
int i;
|
|
float v;
|
|
int sample;
|
|
|
|
memset( &objectInfo, 0, sizeof( objectInfo ) );
|
|
|
|
objectInfo.nChannels = 1;
|
|
objectInfo.wBitsPerSample = 16;
|
|
objectInfo.nSamplesPerSec = 44100;
|
|
|
|
objectSize = MIXBUFFER_SAMPLES * 2;
|
|
objectMemSize = objectSize * sizeof( short );
|
|
|
|
nonCacheData = (byte *)soundCacheAllocator.Alloc( objectMemSize );
|
|
|
|
short *ncd = (short *)nonCacheData;
|
|
|
|
for ( i = 0; i < MIXBUFFER_SAMPLES; i ++ ) {
|
|
v = sin( idMath::PI * 2 * i / 64 );
|
|
sample = v * 0x4000;
|
|
ncd[i*2+0] = sample;
|
|
ncd[i*2+1] = sample;
|
|
}
|
|
|
|
alGetError();
|
|
alGenBuffers( 1, &openalBuffer );
|
|
if ( alGetError() != AL_NO_ERROR ) {
|
|
common->Error( "idSoundCache: error generating OpenAL hardware buffer" );
|
|
}
|
|
|
|
alGetError();
|
|
alBufferData( openalBuffer, objectInfo.nChannels==1?AL_FORMAT_MONO16:AL_FORMAT_STEREO16, nonCacheData, objectMemSize, objectInfo.nSamplesPerSec );
|
|
if ( alGetError() != AL_NO_ERROR ) {
|
|
common->Error( "idSoundCache: error loading data into OpenAL hardware buffer" );
|
|
} else {
|
|
hardwareBuffer = true;
|
|
}
|
|
|
|
defaultSound = true;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundSample::CheckForDownSample
|
|
===================
|
|
*/
|
|
void idSoundSample::CheckForDownSample( void ) {
|
|
if ( !idSoundSystemLocal::s_force22kHz.GetBool() ) {
|
|
return;
|
|
}
|
|
if ( objectInfo.wFormatTag != WAVE_FORMAT_TAG_PCM || objectInfo.nSamplesPerSec != 44100 ) {
|
|
return;
|
|
}
|
|
int shortSamples = objectSize >> 1;
|
|
short *converted = (short *)soundCacheAllocator.Alloc( shortSamples * sizeof( short ) );
|
|
|
|
if ( objectInfo.nChannels == 1 ) {
|
|
for ( int i = 0; i < shortSamples; i++ ) {
|
|
converted[i] = ((short *)nonCacheData)[i*2];
|
|
}
|
|
} else {
|
|
for ( int i = 0; i < shortSamples; i += 2 ) {
|
|
converted[i+0] = ((short *)nonCacheData)[i*2+0];
|
|
converted[i+1] = ((short *)nonCacheData)[i*2+1];
|
|
}
|
|
}
|
|
soundCacheAllocator.Free( nonCacheData );
|
|
nonCacheData = (byte *)converted;
|
|
objectSize >>= 1;
|
|
objectMemSize >>= 1;
|
|
objectInfo.nAvgBytesPerSec >>= 1;
|
|
objectInfo.nSamplesPerSec >>= 1;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundSample::GetNewTimeStamp
|
|
===================
|
|
*/
|
|
ID_TIME_T idSoundSample::GetNewTimeStamp( void ) const {
|
|
ID_TIME_T timestamp;
|
|
|
|
fileSystem->ReadFile( name, NULL, ×tamp );
|
|
if ( timestamp == FILE_NOT_FOUND_TIMESTAMP ) {
|
|
idStr oggName = name;
|
|
oggName.SetFileExtension( ".ogg" );
|
|
fileSystem->ReadFile( oggName, NULL, ×tamp );
|
|
}
|
|
return timestamp;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundSample::Load
|
|
|
|
Loads based on name, possibly doing a MakeDefault if necessary
|
|
===================
|
|
*/
|
|
void idSoundSample::Load( void ) {
|
|
defaultSound = false;
|
|
purged = false;
|
|
hardwareBuffer = false;
|
|
|
|
timestamp = GetNewTimeStamp();
|
|
|
|
if ( timestamp == FILE_NOT_FOUND_TIMESTAMP ) {
|
|
common->Warning( "Couldn't load sound '%s' using default", name.c_str() );
|
|
MakeDefault();
|
|
return;
|
|
}
|
|
|
|
// load it
|
|
idWaveFile fh;
|
|
waveformatex_t info;
|
|
|
|
if ( fh.Open( name, &info ) == -1 ) {
|
|
common->Warning( "Couldn't load sound '%s' using default", name.c_str() );
|
|
MakeDefault();
|
|
return;
|
|
}
|
|
|
|
if ( info.nChannels != 1 && info.nChannels != 2 ) {
|
|
common->Warning( "idSoundSample: %s has %i channels, using default", name.c_str(), info.nChannels );
|
|
fh.Close();
|
|
MakeDefault();
|
|
return;
|
|
}
|
|
|
|
if ( info.wBitsPerSample != 16 ) {
|
|
common->Warning( "idSoundSample: %s is %dbits, expected 16bits using default", name.c_str(), info.wBitsPerSample );
|
|
fh.Close();
|
|
MakeDefault();
|
|
return;
|
|
}
|
|
|
|
if ( info.nSamplesPerSec != 44100 && info.nSamplesPerSec != 22050 && info.nSamplesPerSec != 11025 ) {
|
|
common->Warning( "idSoundCache: %s is %dHz, expected 11025, 22050 or 44100 Hz. Using default", name.c_str(), info.nSamplesPerSec );
|
|
fh.Close();
|
|
MakeDefault();
|
|
return;
|
|
}
|
|
|
|
objectInfo = info;
|
|
objectSize = fh.GetOutputSize();
|
|
objectMemSize = fh.GetMemorySize();
|
|
|
|
nonCacheData = (byte *)soundCacheAllocator.Alloc( objectMemSize );
|
|
fh.Read( nonCacheData, objectMemSize, NULL );
|
|
|
|
// optionally convert it to 22kHz to save memory
|
|
CheckForDownSample();
|
|
|
|
// create hardware audio buffers
|
|
// PCM loads directly
|
|
if ( objectInfo.wFormatTag == WAVE_FORMAT_TAG_PCM ) {
|
|
alGetError();
|
|
alGenBuffers( 1, &openalBuffer );
|
|
if ( alGetError() != AL_NO_ERROR )
|
|
common->Error( "idSoundCache: error generating OpenAL hardware buffer" );
|
|
if ( alIsBuffer( openalBuffer ) ) {
|
|
alGetError();
|
|
alBufferData( openalBuffer, objectInfo.nChannels==1?AL_FORMAT_MONO16:AL_FORMAT_STEREO16, nonCacheData, objectMemSize, objectInfo.nSamplesPerSec );
|
|
if ( alGetError() != AL_NO_ERROR ) {
|
|
common->Error( "idSoundCache: error loading data into OpenAL hardware buffer" );
|
|
} else {
|
|
// Compute amplitude block size
|
|
int blockSize = 512 * objectInfo.nSamplesPerSec / 44100 ;
|
|
|
|
// Allocate amplitude data array
|
|
amplitudeData = (byte *)soundCacheAllocator.Alloc( ( objectSize / blockSize + 1 ) * 2 * sizeof( short) );
|
|
|
|
// Creating array of min/max amplitude pairs per blockSize samples
|
|
int i;
|
|
for ( i = 0; i < objectSize; i+=blockSize ) {
|
|
short min = 32767;
|
|
short max = -32768;
|
|
|
|
int j;
|
|
for ( j = 0; j < Min( objectSize - i, blockSize ); j++ ) {
|
|
min = ((short *)nonCacheData)[ i + j ] < min ? ((short *)nonCacheData)[ i + j ] : min;
|
|
max = ((short *)nonCacheData)[ i + j ] > max ? ((short *)nonCacheData)[ i + j ] : max;
|
|
}
|
|
|
|
((short *)amplitudeData)[ ( i / blockSize ) * 2 ] = min;
|
|
((short *)amplitudeData)[ ( i / blockSize ) * 2 + 1 ] = max;
|
|
}
|
|
|
|
hardwareBuffer = true;
|
|
}
|
|
}
|
|
|
|
// OGG decompressed at load time (when smaller than s_decompressionLimit seconds, 6 seconds by default)
|
|
if ( objectInfo.wFormatTag == WAVE_FORMAT_TAG_OGG ) {
|
|
#if !ID_OPENAL_EAX
|
|
if ( ( objectSize < ( ( int ) objectInfo.nSamplesPerSec * idSoundSystemLocal::s_decompressionLimit.GetInteger() ) ) ) {
|
|
#else
|
|
if ( ( alIsExtensionPresent( ID_ALCHAR "EAX-RAM" ) == AL_TRUE ) && ( objectSize < ( ( int ) objectInfo.nSamplesPerSec * idSoundSystemLocal::s_decompressionLimit.GetInteger() ) ) ) {
|
|
#endif
|
|
alGetError();
|
|
alGenBuffers( 1, &openalBuffer );
|
|
if ( alGetError() != AL_NO_ERROR )
|
|
common->Error( "idSoundCache: error generating OpenAL hardware buffer" );
|
|
if ( alIsBuffer( openalBuffer ) ) {
|
|
idSampleDecoder *decoder = idSampleDecoder::Alloc();
|
|
float *destData = (float *)soundCacheAllocator.Alloc( ( LengthIn44kHzSamples() + 1 ) * sizeof( float ) );
|
|
|
|
// Decoder *always* outputs 44 kHz data
|
|
decoder->Decode( this, 0, LengthIn44kHzSamples(), destData );
|
|
|
|
// Downsample back to original frequency (save memory)
|
|
if ( objectInfo.nSamplesPerSec == 11025 ) {
|
|
for ( int i = 0; i < objectSize; i++ ) {
|
|
if ( destData[i*4] < -32768.0f )
|
|
((short *)destData)[i] = -32768;
|
|
else if ( destData[i*4] > 32767.0f )
|
|
((short *)destData)[i] = 32767;
|
|
else
|
|
((short *)destData)[i] = idMath::FtoiFast( destData[i*4] );
|
|
}
|
|
} else if ( objectInfo.nSamplesPerSec == 22050 ) {
|
|
for ( int i = 0; i < objectSize; i++ ) {
|
|
if ( destData[i*2] < -32768.0f )
|
|
((short *)destData)[i] = -32768;
|
|
else if ( destData[i*2] > 32767.0f )
|
|
((short *)destData)[i] = 32767;
|
|
else
|
|
((short *)destData)[i] = idMath::FtoiFast( destData[i*2] );
|
|
}
|
|
} else {
|
|
for ( int i = 0; i < objectSize; i++ ) {
|
|
if ( destData[i] < -32768.0f )
|
|
((short *)destData)[i] = -32768;
|
|
else if ( destData[i] > 32767.0f )
|
|
((short *)destData)[i] = 32767;
|
|
else
|
|
((short *)destData)[i] = idMath::FtoiFast( destData[i] );
|
|
}
|
|
}
|
|
|
|
alGetError();
|
|
alBufferData( openalBuffer, objectInfo.nChannels==1?AL_FORMAT_MONO16:AL_FORMAT_STEREO16, destData, objectSize * sizeof( short ), objectInfo.nSamplesPerSec );
|
|
if ( alGetError() != AL_NO_ERROR )
|
|
common->Error( "idSoundCache: error loading data into OpenAL hardware buffer" );
|
|
else {
|
|
// Compute amplitude block size
|
|
int blockSize = 512 * objectInfo.nSamplesPerSec / 44100 ;
|
|
|
|
// Allocate amplitude data array
|
|
amplitudeData = (byte *)soundCacheAllocator.Alloc( ( objectSize / blockSize + 1 ) * 2 * sizeof( short ) );
|
|
|
|
// Creating array of min/max amplitude pairs per blockSize samples
|
|
int i;
|
|
for ( i = 0; i < objectSize; i+=blockSize ) {
|
|
short min = 32767;
|
|
short max = -32768;
|
|
|
|
int j;
|
|
for ( j = 0; j < Min( objectSize - i, blockSize ); j++ ) {
|
|
min = ((short *)destData)[ i + j ] < min ? ((short *)destData)[ i + j ] : min;
|
|
max = ((short *)destData)[ i + j ] > max ? ((short *)destData)[ i + j ] : max;
|
|
}
|
|
|
|
((short *)amplitudeData)[ ( i / blockSize ) * 2 ] = min;
|
|
((short *)amplitudeData)[ ( i / blockSize ) * 2 + 1 ] = max;
|
|
}
|
|
|
|
hardwareBuffer = true;
|
|
}
|
|
|
|
soundCacheAllocator.Free( (byte *)destData );
|
|
idSampleDecoder::Free( decoder );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Free memory if sample was loaded into hardware
|
|
if ( hardwareBuffer ) {
|
|
soundCacheAllocator.Free( nonCacheData );
|
|
nonCacheData = NULL;
|
|
}
|
|
}
|
|
|
|
fh.Close();
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundSample::PurgeSoundSample
|
|
===================
|
|
*/
|
|
void idSoundSample::PurgeSoundSample() {
|
|
purged = true;
|
|
|
|
alGetError();
|
|
alDeleteBuffers( 1, &openalBuffer );
|
|
if ( alGetError() != AL_NO_ERROR ) {
|
|
common->Error( "idSoundCache: error unloading data from OpenAL hardware buffer" );
|
|
} else {
|
|
openalBuffer = 0;
|
|
hardwareBuffer = false;
|
|
}
|
|
|
|
if ( amplitudeData ) {
|
|
soundCacheAllocator.Free( amplitudeData );
|
|
amplitudeData = NULL;
|
|
}
|
|
|
|
if ( nonCacheData ) {
|
|
soundCacheAllocator.Free( nonCacheData );
|
|
nonCacheData = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundSample::Reload
|
|
===================
|
|
*/
|
|
void idSoundSample::Reload( bool force ) {
|
|
if ( !force ) {
|
|
ID_TIME_T newTimestamp;
|
|
|
|
// check the timestamp
|
|
newTimestamp = GetNewTimeStamp();
|
|
|
|
if ( newTimestamp == FILE_NOT_FOUND_TIMESTAMP ) {
|
|
if ( !defaultSound ) {
|
|
common->Warning( "Couldn't load sound '%s' using default", name.c_str() );
|
|
MakeDefault();
|
|
}
|
|
return;
|
|
}
|
|
if ( newTimestamp == timestamp ) {
|
|
return; // don't need to reload it
|
|
}
|
|
}
|
|
|
|
common->Printf( "reloading %s\n", name.c_str() );
|
|
PurgeSoundSample();
|
|
Load();
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idSoundSample::FetchFromCache
|
|
|
|
Returns true on success.
|
|
===================
|
|
*/
|
|
bool idSoundSample::FetchFromCache( int offset, const byte **output, int *position, int *size, const bool allowIO ) {
|
|
offset &= 0xfffffffe;
|
|
|
|
if ( objectSize == 0 || offset < 0 || offset > objectSize * (int)sizeof( short ) || !nonCacheData ) {
|
|
return false;
|
|
}
|
|
|
|
if ( output ) {
|
|
*output = nonCacheData + offset;
|
|
}
|
|
if ( position ) {
|
|
*position = 0;
|
|
}
|
|
if ( size ) {
|
|
*size = objectSize * sizeof( short ) - offset;
|
|
if ( *size > SCACHE_SIZE ) {
|
|
*size = SCACHE_SIZE;
|
|
}
|
|
}
|
|
return true;
|
|
}
|