blendo
/
quadrilateralcowboy
mirror of https://github.com/blendogames/quadrilateralcowboy.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
quadrilateralcowboy/sound/snd_cache.cpp

712 lines
18 KiB
C++
Raw Blame History

/*
===========================================================================
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 "../idlib/precompiled.h"
#pragma hdrstop
#include "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 = NULL;
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;
}
if ( idSoundSystemLocal::useOpenAL ) {
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, &timestamp );
if ( timestamp == FILE_NOT_FOUND_TIMESTAMP ) {
idStr oggName = name;
oggName.SetFileExtension( ".ogg" );
fileSystem->ReadFile( oggName, NULL, &timestamp );
}
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
if ( idSoundSystemLocal::useOpenAL ) {
// 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 defined(MACOS_X)
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;
if ( hardwareBuffer && idSoundSystemLocal::useOpenAL ) {
alGetError();
alDeleteBuffers( 1, &openalBuffer );
if ( alGetError() != AL_NO_ERROR ) {
// TODO: figure out why this gets hit.
//common->Error( "idSoundCache: error unloading data from OpenAL hardware buffer" );
common->Warning( "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;
}
Reference in New Issue View Git Blame Copy Permalink