gfxdev
/
caudio
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Activity

Added custom memory manager.

This commit is contained in:
Joshua Jones 2010-03-08 04:56:56 +00:00
parent e2ea295b7c
commit befd5f5821
25 changed files with 163 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Headers/cAudioCapture.h
View File

@ -12,10 +12,12 @@
#include "../Headers/cMutex.h"
#include <string>
#include <list>
#include "../Headers/cMemoryOverride.h"
#include "../Headers/cSTLAllocator.h"
namespace cAudio
{
class cAudioCapture : public IAudioCapture
class cAudioCapture : public IAudioCapture, public cMemoryOverride
{
public:
@ -77,10 +79,10 @@ namespace cAudio
unsigned int InternalBufferSize;
int SampleSize;
std::vector<char> CaptureBuffer;
std::vector<std::string> AvailableDevices;
std::vector<char, cSTLAllocator<char> > CaptureBuffer;
std::vector<std::string, cSTLAllocator<std::string> > AvailableDevices;
std::string DefaultDevice;
std::list<ICaptureEventHandler*> eventHandlerList;
std::list<ICaptureEventHandler*, cSTLAllocator<ICaptureEventHandler*> > eventHandlerList;
bool Supported;
bool Ready;

27
Headers/cAudioEffects.h
View File

@ -9,6 +9,7 @@
#include "../Headers/cMutex.h"
#include "../Headers/cEFXFunctions.h"
#include <map>
#include "../Headers/cSTLAllocator.h"
#ifdef CAUDIO_EFX_ENABLED
@ -69,19 +70,19 @@ namespace cAudio
bool SupportedEffects[EET_COUNT];
bool SupportedFilters[EFT_COUNT];
std::map<std::string, sEAXReverbParameters> EAXReverbPresets;
std::map<std::string, sReverbParameters> ReverbPresets;
std::map<std::string, sChorusParameters> ChorusPresets;
std::map<std::string, sDistortionParameters> DistortionPresets;
std::map<std::string, sEchoParameters> EchoPresets;
std::map<std::string, sFlangerParameters> FlangerPresets;
std::map<std::string, sFrequencyShiftParameters> FrequencyShiftPresets;
std::map<std::string, sVocalMorpherParameters> VocalMorpherPresets;
std::map<std::string, sPitchShifterParameters> PitchShifterPresets;
std::map<std::string, sRingModulatorParameters> RingModulatorPresets;
std::map<std::string, sAutowahParameters> AutowahPresets;
std::map<std::string, sCompressorParameters> CompressorPresets;
std::map<std::string, sEqualizerParameters> EqualizerPresets;
std::map<std::string, sEAXReverbParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sEAXReverbParameters>> > EAXReverbPresets;
std::map<std::string, sReverbParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sReverbParameters>> > ReverbPresets;
std::map<std::string, sChorusParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sChorusParameters>> > ChorusPresets;
std::map<std::string, sDistortionParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sDistortionParameters>> > DistortionPresets;
std::map<std::string, sEchoParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sEchoParameters>> > EchoPresets;
std::map<std::string, sFlangerParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sFlangerParameters>> > FlangerPresets;
std::map<std::string, sFrequencyShiftParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sFrequencyShiftParameters>> > FrequencyShiftPresets;
std::map<std::string, sVocalMorpherParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sVocalMorpherParameters>> > VocalMorpherPresets;
std::map<std::string, sPitchShifterParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sPitchShifterParameters>> > PitchShifterPresets;
std::map<std::string, sRingModulatorParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sRingModulatorParameters>> > RingModulatorPresets;
std::map<std::string, sAutowahParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sAutowahParameters>> > AutowahPresets;
std::map<std::string, sCompressorParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sCompressorParameters>> > CompressorPresets;
std::map<std::string, sEqualizerParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sEqualizerParameters>> > EqualizerPresets;
};
};

21
Headers/cAudioManager.h
View File

@ -15,6 +15,8 @@
#include "../include/IAudioManager.h"
#include "../Headers/cMutex.h"
#include "../Headers/cAudioEffects.h"
#include "../Headers/cMemoryOverride.h"
#include "../Headers/cSTLAllocator.h"
#include <AL/al.h>
#include <AL/alc.h>
@ -27,7 +29,7 @@ namespace cAudio
{
class IAudioSource;
class cAudioManager : public IAudioManager
class cAudioManager : public IAudioManager, public cMemoryOverride
{
public:
enum Events{
@ -98,14 +100,17 @@ namespace cAudio
bool Initialized;
//! Holds an index for fast searching of audio sources by name
std::map<std::string, IAudioSource*> audioIndex;
std::map<std::string, IAudioSource*, std::less<std::string>, cSTLAllocator<std::pair<std::string, IAudioSource*>> > audioIndex;
typedef std::map<std::string, IAudioSource*, std::less<std::string>, cSTLAllocator<std::pair<std::string, IAudioSource*>> >::iterator audioIndexIterator;
//! Holds all managed audio sources
std::vector<IAudioSource*> audioSources;
std::vector<IAudioSource*, cSTLAllocator<IAudioSource*>> audioSources;
//! Decoder map that holds all decoders by file extension
std::map<std::string, IAudioDecoderFactory*> decodermap;
std::map<std::string, IAudioDecoderFactory*, std::less<std::string>, cSTLAllocator<std::pair<std::string, IAudioDecoderFactory*>> > decodermap;
typedef std::map<std::string, IAudioDecoderFactory*, std::less<std::string>, cSTLAllocator<std::pair<std::string, IAudioDecoderFactory*>> >::iterator decodermapIterator;
//! Archive map that holds all datasource types
std::map<std::string, IDataSourceFactory*> datasourcemap;
std::vector< std::pair<int, std::string> > dataSourcePriorityList;
std::map<std::string, IDataSourceFactory*, std::less<std::string>, cSTLAllocator<std::pair<std::string, IDataSourceFactory*>> > datasourcemap;
typedef std::map<std::string, IDataSourceFactory*, std::less<std::string>, cSTLAllocator<std::pair<std::string, IDataSourceFactory*>> >::iterator datasourcemapIterator;
std::vector< std::pair<int, std::string>, cSTLAllocator<std::pair<int, std::string>> > dataSourcePriorityList;
//! The listener object
cListener initlistener;
@ -116,14 +121,14 @@ namespace cAudio
//! Check for OpenAL errors
bool checkError();
std::vector<std::string> AvailableDevices;
std::vector<std::string, cSTLAllocator<std::string>> AvailableDevices;
std::string DefaultDevice;
//! Signals a event to all event handlers
void signalEvent(Events sevent);
//! List of all attached event handlers
std::list<IManagerEventHandler*> eventHandlerList;
std::list<IManagerEventHandler*, cSTLAllocator<IManagerEventHandler*>> eventHandlerList;
};
}

6
Headers/cAudioSource.h
View File

@ -15,11 +15,13 @@
#include "../Headers/cMutex.h"
#include "../include/ILogger.h"
#include "../Headers/cEFXFunctions.h"
#include "../Headers/cMemoryOverride.h"
#include "../Headers/cSTLAllocator.h"
namespace cAudio
{
class cAudioSource : public IAudioSource
class cAudioSource : public IAudioSource, public cMemoryOverride
{
public:
@ -154,7 +156,7 @@ namespace cAudio
bool Valid;
//! List of registered event handlers
std::list<ISourceEventHandler*> eventHandlerList;
std::list<ISourceEventHandler*, cSTLAllocator<ISourceEventHandler*>> eventHandlerList;
#ifdef CAUDIO_EFX_ENABLED
//! Holds pointers to all the EFX related functions

3
Headers/cEffect.h
View File

@ -8,6 +8,7 @@
#include "../include/IEffect.h"
#include "../Headers/cMutex.h"
#include "../Headers/cEFXFunctions.h"
#include "../Headers/cMemoryOverride.h"
#ifdef CAUDIO_EFX_ENABLED
@ -16,7 +17,7 @@
namespace cAudio
{
class cEffect : public IEffect
class cEffect : public IEffect, public cMemoryOverride
{
public:
cEffect(cEFXFunctions* oALFunctions);

3
Headers/cFileSource.h
View File

@ -7,6 +7,7 @@
#include "../include/IDataSource.h"
#include "../include/cAudioDefines.h"
#include "../Headers/cMemoryOverride.h"
#ifdef CAUDIO_COMPILE_WITH_FILE_SOURCE
@ -15,7 +16,7 @@
namespace cAudio
{
class cFileSource : public IDataSource
class cFileSource : public IDataSource, public cMemoryOverride
{
public:
cFileSource(const char* filename);

4
Headers/cFileSourceFactory.h
View File

@ -24,7 +24,7 @@ namespace cAudio
virtual IDataSource* CreateDataSource(const char* filename, bool streamingRequested)
{
cAudioMutexBasicLock lock(Mutex);
IDataSource* source = new cFileSource(filename);
IDataSource* source = CAUDIO_NEW cFileSource(filename);
if(!streamingRequested && source && source->isValid())
{
@ -34,7 +34,7 @@ namespace cAudio
if(tempbuf)
{
source->read(tempbuf, length);
IDataSource* memSource = new cMemorySource(tempbuf, length, true);
IDataSource* memSource = CAUDIO_NEW cMemorySource(tempbuf, length, true);
delete[] tempbuf;
if(memSource && memSource->isValid())

3
Headers/cFilter.h
View File

@ -8,6 +8,7 @@
#include "../include/IFilter.h"
#include "../Headers/cMutex.h"
#include "../Headers/cEFXFunctions.h"
#include "../Headers/cMemoryOverride.h"
#ifdef CAUDIO_EFX_ENABLED
@ -16,7 +17,7 @@
namespace cAudio
{
class cFilter : public IFilter
class cFilter : public IFilter, public cMemoryOverride
{
public:
cFilter(cEFXFunctions* oALFunctions);

4
Headers/cLogger.h
View File

@ -11,6 +11,7 @@
#include "../include/ILogger.h"
#include "../Headers/cMutex.h"
#include "../Headers/cSTLAllocator.h"
namespace cAudio
{
@ -41,7 +42,8 @@ namespace cAudio
unsigned long StartTime;
char TempTextBuf[2048];
LogLevel MinLogLevel;
std::map<std::string, ILogReceiver*> Receivers;
std::map<std::string, ILogReceiver*, std::less<std::string>, cSTLAllocator<std::pair<std::string, ILogReceiver*>>> Receivers;
typedef std::map<std::string, ILogReceiver*, std::less<std::string>, cSTLAllocator<std::pair<std::string, ILogReceiver*>>>::iterator ReceiversIterator;
private:
};
};

3
Headers/cMemorySource.h
View File

@ -6,12 +6,13 @@
#define CMEMORYSOURCE_H
#include "../include/IDataSource.h"
#include "../Headers/cMemoryOverride.h"
namespace cAudio
{
//!Class used to read from a memory buffer.
class cMemorySource : public IDataSource
class cMemorySource : public IDataSource, public cMemoryOverride
{
public:
/** Default Constructor

2
Headers/cOggAudioDecoderFactory.h
View File

@ -23,7 +23,7 @@ class cOggAudioDecoderFactory : public IAudioDecoderFactory
IAudioDecoder* CreateAudioDecoder(IDataSource* stream)
{
Mutex.lock();
IAudioDecoder* decoder = new cOggDecoder(stream);
IAudioDecoder* decoder = CAUDIO_NEW cOggDecoder(stream);
Mutex.unlock();
return decoder;
}

3
Headers/cOggDecoder.h
View File

@ -13,11 +13,12 @@
#include <ogg/ogg.h>
#include <vorbis/codec.h>
#include <vorbis/vorbisfile.h>
#include "../Headers/cMemoryOverride.h"
namespace cAudio
{
class cOggDecoder : public IAudioDecoder
class cOggDecoder : public IAudioDecoder, public cMemoryOverride
{
public:

7
Headers/cPluginManager.h
View File

@ -8,6 +8,7 @@
#include "../include/IPluginManager.h"
#include "../include/IAudioPlugin.h"
#include "../Headers/cMutex.h"
#include "../Headers/cSTLAllocator.h"
#ifdef CAUDIO_COMPILE_WITH_PLUGIN_SUPPORT
@ -73,9 +74,11 @@ namespace cAudio
void autoLoadPlugins();
#endif
protected:
std::map<std::string, IAudioPlugin*> RegisteredPlugins;
std::map<std::string, IAudioPlugin*, std::less<std::string>, cSTLAllocator<std::pair<std::string, IAudioPlugin*>>> RegisteredPlugins;
typedef std::map<std::string, IAudioPlugin*, std::less<std::string>, cSTLAllocator<std::pair<std::string, IAudioPlugin*>>>::iterator RegisteredPluginsIterator;
#ifdef CAUDIO_COMPILE_WITH_DYNAMIC_PLUGIN_SUPPORT
std::map<IAudioPlugin*, DYNLIB_HANDLE> DynamicallyLoadedPlugins;
std::map<IAudioPlugin*, DYNLIB_HANDLE, std::less<IAudioPlugin*>, cSTLAllocator<std::pair<IAudioPlugin*, DYNLIB_HANDLE>>> DynamicallyLoadedPlugins;
typedef std::map<IAudioPlugin*, DYNLIB_HANDLE, std::less<IAudioPlugin*>, cSTLAllocator<std::pair<IAudioPlugin*, DYNLIB_HANDLE>>>::iterator DynamicallyLoadedPluginsIterator;
#endif
};
};

4
Headers/cRawAudioDecoderFactory.h
View File

@ -21,7 +21,7 @@ class cRawAudioDecoderFactory : public IAudioDecoderFactory
IAudioDecoder* CreateAudioDecoder(IDataSource* stream)
{
Mutex.lock();
IAudioDecoder* decoder = new cRawDecoder(stream, 22050, EAF_16BIT_MONO);
IAudioDecoder* decoder = CAUDIO_NEW cRawDecoder(stream, 22050, EAF_16BIT_MONO);
Mutex.unlock();
return decoder;
}
@ -29,7 +29,7 @@ class cRawAudioDecoderFactory : public IAudioDecoderFactory
IAudioDecoder* CreateAudioDecoder(IDataSource* stream, unsigned int frequency = 22050, AudioFormats format = EAF_16BIT_MONO)
{
Mutex.lock();
IAudioDecoder* decoder = new cRawDecoder(stream, frequency, format);
IAudioDecoder* decoder = CAUDIO_NEW cRawDecoder(stream, frequency, format);
Mutex.unlock();
return decoder;
}

3
Headers/cRawDecoder.h
View File

@ -6,10 +6,11 @@
#define CRAWDECODER_H_INCLUDED
#include "../include/IAudioDecoder.h"
#include "../Headers/cMemoryOverride.h"
namespace cAudio
{
class cRawDecoder : public IAudioDecoder
class cRawDecoder : public IAudioDecoder, public cMemoryOverride
{
public:

2
Headers/cWavAudioDecoderFactory.h
View File

@ -23,7 +23,7 @@ class cWavAudioDecoderFactory : public IAudioDecoderFactory
IAudioDecoder* CreateAudioDecoder(IDataSource* stream)
{
Mutex.lock();
IAudioDecoder* decoder = new cWavDecoder(stream);
IAudioDecoder* decoder = CAUDIO_NEW cWavDecoder(stream);
Mutex.unlock();
return decoder;
}

3
Headers/cWavDecoder.h
View File

@ -7,12 +7,13 @@
#include "../include/IAudioDecoder.h"
#include "../include/cAudioDefines.h"
#include "../Headers/cMemoryOverride.h"
#ifdef CAUDIO_COMPILE_WITH_WAV_DECODER
namespace cAudio
{
class cWavDecoder : public IAudioDecoder
class cWavDecoder : public IAudioDecoder, public cMemoryOverride
{
public:

10
Source/cAudioCapture.cpp
View File

@ -19,14 +19,14 @@ namespace cAudio
//Note: OpenAL is threadsafe, so a mutex only needs to protect the class state
#ifdef CAUDIO_USE_INTERNAL_THREAD
static cAudioMutex AudioCaptureObjectsMutex;
static std::set<IAudioCapture*> AudioCaptureObjects;
static std::set<IAudioCapture*, std::less<IAudioCapture*>, cSTLAllocator<IAudioCapture*>> AudioCaptureObjects;
CAUDIO_DECLARE_THREAD_FUNCTION(AudioCaptureUpdateThread)
{
while(RunAudioCaptureThread)
{
AudioCaptureObjectsMutex.lock();
std::set<IAudioCapture*>::iterator it;
std::set<IAudioCapture*, std::less<IAudioCapture*>, cSTLAllocator<IAudioCapture*>>::iterator it;
for ( it=AudioCaptureObjects.begin() ; it != AudioCaptureObjects.end(); it++ )
{
(*it)->updateCaptureBuffer();
@ -340,7 +340,7 @@ namespace cAudio
CAUDIO_API IAudioCapture* createAudioCapture(bool initializeDefault)
{
cAudioCapture* capture = new cAudioCapture;
cAudioCapture* capture = CAUDIO_NEW cAudioCapture;
if(capture)
{
if(initializeDefault)
@ -389,7 +389,7 @@ namespace cAudio
}
#endif
delete capture;
CAUDIO_DELETE capture;
capture = NULL;
}
}
@ -424,7 +424,7 @@ namespace cAudio
void cAudioCapture::signalEvent(Events sevent)
{
cAudioMutexBasicLock lock(Mutex);
std::list<ICaptureEventHandler*>::iterator it = eventHandlerList.begin();
std::list<ICaptureEventHandler*, cSTLAllocator<ICaptureEventHandler*> >::iterator it = eventHandlerList.begin();
if(it != eventHandlerList.end()){

30
Source/cAudioEffects.cpp
View File

@ -32,7 +32,7 @@ cAudioEffects::~cAudioEffects()
IEffect* cAudioEffects::createEffect()
{
cAudioMutexBasicLock lock(Mutex);
IEffect* effect = new cEffect(&EFXInterface);
IEffect* effect = CAUDIO_NEW cEffect(&EFXInterface);
if(effect && effect->isValid())
return effect;
@ -43,7 +43,7 @@ IEffect* cAudioEffects::createEffect()
IFilter* cAudioEffects::createFilter()
{
cAudioMutexBasicLock lock(Mutex);
IFilter* filter = new cFilter(&EFXInterface);
IFilter* filter = CAUDIO_NEW cFilter(&EFXInterface);
if(filter && filter->isValid())
return filter;
@ -174,7 +174,7 @@ sEAXReverbParameters cAudioEffects::getEAXReverbEffectPreset(const char* name)
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sEAXReverbParameters>::iterator it = EAXReverbPresets.find(safeName);
std::map<std::string, sEAXReverbParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sEAXReverbParameters>> >::iterator it = EAXReverbPresets.find(safeName);
if(it != EAXReverbPresets.end())
{
return it->second;
@ -186,7 +186,7 @@ sReverbParameters cAudioEffects::getReverbEffectPreset(const char* name)
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sReverbParameters>::iterator it = ReverbPresets.find(safeName);
std::map<std::string, sReverbParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sReverbParameters>> >::iterator it = ReverbPresets.find(safeName);
if(it != ReverbPresets.end())
{
return it->second;
@ -198,7 +198,7 @@ sChorusParameters cAudioEffects::getChorusEffectPreset(const char* name)
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sChorusParameters>::iterator it = ChorusPresets.find(safeName);
std::map<std::string, sChorusParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sChorusParameters>> >::iterator it = ChorusPresets.find(safeName);
if(it != ChorusPresets.end())
{
return it->second;
@ -210,7 +210,7 @@ sDistortionParameters cAudioEffects::getDistortionEffectPreset(const char* name)
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sDistortionParameters>::iterator it = DistortionPresets.find(safeName);
std::map<std::string, sDistortionParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sDistortionParameters>> >::iterator it = DistortionPresets.find(safeName);
if(it != DistortionPresets.end())
{
return it->second;
@ -222,7 +222,7 @@ sEchoParameters cAudioEffects::getEchoEffectPreset(const char* name)
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sEchoParameters>::iterator it = EchoPresets.find(safeName);
std::map<std::string, sEchoParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sEchoParameters>> >::iterator it = EchoPresets.find(safeName);
if(it != EchoPresets.end())
{
return it->second;
@ -234,7 +234,7 @@ sFlangerParameters cAudioEffects::getFlangerEffectPreset(const char* name)
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sFlangerParameters>::iterator it = FlangerPresets.find(safeName);
std::map<std::string, sFlangerParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sFlangerParameters>> >::iterator it = FlangerPresets.find(safeName);
if(it != FlangerPresets.end())
{
return it->second;
@ -246,7 +246,7 @@ sFrequencyShiftParameters cAudioEffects::getFrequencyShiftEffectPreset(const cha
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sFrequencyShiftParameters>::iterator it = FrequencyShiftPresets.find(safeName);
std::map<std::string, sFrequencyShiftParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sFrequencyShiftParameters>> >::iterator it = FrequencyShiftPresets.find(safeName);
if(it != FrequencyShiftPresets.end())
{
return it->second;
@ -258,7 +258,7 @@ sVocalMorpherParameters cAudioEffects::getVocalMorpherEffectPreset(const char* n
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sVocalMorpherParameters>::iterator it = VocalMorpherPresets.find(safeName);
std::map<std::string, sVocalMorpherParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sVocalMorpherParameters>> >::iterator it = VocalMorpherPresets.find(safeName);
if(it != VocalMorpherPresets.end())
{
return it->second;
@ -270,7 +270,7 @@ sPitchShifterParameters cAudioEffects::getPitchShifterEffectPreset(const char* n
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sPitchShifterParameters>::iterator it = PitchShifterPresets.find(safeName);
std::map<std::string, sPitchShifterParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sPitchShifterParameters>> >::iterator it = PitchShifterPresets.find(safeName);
if(it != PitchShifterPresets.end())
{
return it->second;
@ -282,7 +282,7 @@ sRingModulatorParameters cAudioEffects::getRingModulatorEffectPreset(const char*
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sRingModulatorParameters>::iterator it = RingModulatorPresets.find(safeName);
std::map<std::string, sRingModulatorParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sRingModulatorParameters>> >::iterator it = RingModulatorPresets.find(safeName);
if(it != RingModulatorPresets.end())
{
return it->second;
@ -294,7 +294,7 @@ sAutowahParameters cAudioEffects::getAutowahEffectPreset(const char* name)
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sAutowahParameters>::iterator it = AutowahPresets.find(safeName);
std::map<std::string, sAutowahParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sAutowahParameters>> >::iterator it = AutowahPresets.find(safeName);
if(it != AutowahPresets.end())
{
return it->second;
@ -306,7 +306,7 @@ sCompressorParameters cAudioEffects::getCompressorEffectPreset(const char* name)
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sCompressorParameters>::iterator it = CompressorPresets.find(safeName);
std::map<std::string, sCompressorParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sCompressorParameters>> >::iterator it = CompressorPresets.find(safeName);
if(it != CompressorPresets.end())
{
return it->second;
@ -318,7 +318,7 @@ sEqualizerParameters cAudioEffects::getEqualizerEffectPreset(const char* name)
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, sEqualizerParameters>::iterator it = EqualizerPresets.find(safeName);
std::map<std::string, sEqualizerParameters, std::less<std::string>, cSTLAllocator<std::pair<std::string, sEqualizerParameters>> >::iterator it = EqualizerPresets.find(safeName);
if(it != EqualizerPresets.end())
{
return it->second;

42
Source/cAudioManager.cpp
View File

@ -54,14 +54,14 @@ namespace cAudio
//Note: OpenAL is threadsafe, so a mutex only needs to protect the class state
#ifdef CAUDIO_USE_INTERNAL_THREAD
static cAudioMutex AudioManagerObjectsMutex;
static std::set<IAudioManager*> AudioManagerObjects;
static std::set<IAudioManager*, std::less<IAudioManager*>, cSTLAllocator<IAudioManager*>> AudioManagerObjects;
CAUDIO_DECLARE_THREAD_FUNCTION(AudioManagerUpdateThread)
{
while(RunAudioManagerThread)
{
AudioManagerObjectsMutex.lock();
std::set<IAudioManager*>::iterator it;
std::set<IAudioManager*, std::less<IAudioManager*>, cSTLAllocator<IAudioManager*>>::iterator it;
for ( it=AudioManagerObjects.begin() ; it != AudioManagerObjects.end(); it++ )
{
(*it)->update();
@ -184,9 +184,9 @@ namespace cAudio
if(decoder && decoder->isValid())
{
#ifdef CAUDIO_EFX_ENABLED
IAudioSource* audio = new cAudioSource(decoder, Context, initEffects.getEFXInterface());
IAudioSource* audio = CAUDIO_NEW cAudioSource(decoder, Context, initEffects.getEFXInterface());
#else
IAudioSource* audio = new cAudioSource(decoder, Context);
IAudioSource* audio = CAUDIO_NEW cAudioSource(decoder, Context);
#endif
decoder->drop();
@ -229,7 +229,7 @@ namespace cAudio
IAudioDecoderFactory* factory = getAudioDecoderFactory(ext.c_str());
if(factory)
{
cMemorySource* source = new cMemorySource(data, length, true);
cMemorySource* source = CAUDIO_NEW cMemorySource(data, length, true);
if(source)
{
if(source->isValid())
@ -241,9 +241,9 @@ namespace cAudio
if(decoder->isValid())
{
#ifdef CAUDIO_EFX_ENABLED
IAudioSource* audio = new cAudioSource(decoder, Context, initEffects.getEFXInterface());
IAudioSource* audio = CAUDIO_NEW cAudioSource(decoder, Context, initEffects.getEFXInterface());
#else
IAudioSource* audio = new cAudioSource(decoder, Context);
IAudioSource* audio = CAUDIO_NEW cAudioSource(decoder, Context);
#endif
decoder->drop();
@ -293,7 +293,7 @@ namespace cAudio
IAudioDecoderFactory* factory = getAudioDecoderFactory("raw");
if(factory)
{
cMemorySource* source = new cMemorySource(data, length, true);
cMemorySource* source = CAUDIO_NEW cMemorySource(data, length, true);
if(source)
{
if(source->isValid())
@ -305,9 +305,9 @@ namespace cAudio
if(decoder->isValid())
{
#ifdef CAUDIO_EFX_ENABLED
IAudioSource* audio = new cAudioSource(decoder, Context, initEffects.getEFXInterface());
IAudioSource* audio = CAUDIO_NEW cAudioSource(decoder, Context, initEffects.getEFXInterface());
#else
IAudioSource* audio = new cAudioSource(decoder, Context);
IAudioSource* audio = CAUDIO_NEW cAudioSource(decoder, Context);
#endif
decoder->drop();
@ -362,7 +362,7 @@ namespace cAudio
{
cAudioMutexBasicLock lock(Mutex);
std::string ext = safeCStr(extension);
std::map<std::string, IAudioDecoderFactory*>::iterator it = decodermap.find(ext);
decodermapIterator it = decodermap.find(ext);
if(it != decodermap.end())
{
decodermap.erase(it);
@ -374,7 +374,7 @@ namespace cAudio
{
cAudioMutexBasicLock lock(Mutex);
std::string ext = safeCStr(extension);
std::map<std::string, IAudioDecoderFactory*>::iterator it = decodermap.find(ext);
decodermapIterator it = decodermap.find(ext);
return (it != decodermap.end());
}
@ -382,7 +382,7 @@ namespace cAudio
{
cAudioMutexBasicLock lock(Mutex);
std::string ext = safeCStr(extension);
std::map<std::string, IAudioDecoderFactory*>::iterator it = decodermap.find(ext);
decodermapIterator it = decodermap.find(ext);
if(it != decodermap.end())
{
return it->second;
@ -417,7 +417,7 @@ namespace cAudio
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, IDataSourceFactory*>::iterator it = datasourcemap.find(safeName);
datasourcemapIterator it = datasourcemap.find(safeName);
if(it != datasourcemap.end())
{
datasourcemap.erase(it);
@ -440,7 +440,7 @@ namespace cAudio
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, IDataSourceFactory*>::iterator it = datasourcemap.find(safeName);
datasourcemapIterator it = datasourcemap.find(safeName);
return (it != datasourcemap.end());
}
@ -448,7 +448,7 @@ namespace cAudio
{
cAudioMutexBasicLock lock(Mutex);
std::string safeName = safeCStr(name);
std::map<std::string, IDataSourceFactory*>::iterator it = datasourcemap.find(safeName);
datasourcemapIterator it = datasourcemap.find(safeName);
if(it != datasourcemap.end())
{
return it->second;
@ -487,7 +487,7 @@ namespace cAudio
void cAudioManager::signalEvent(Events sevent)
{
cAudioMutexBasicLock lock(Mutex);
std::list<IManagerEventHandler*>::iterator it = eventHandlerList.begin();
std::list<IManagerEventHandler*, cSTLAllocator<IManagerEventHandler*>>::iterator it = eventHandlerList.begin();
if(it != eventHandlerList.end())
{
@ -554,7 +554,7 @@ namespace cAudio
{
cAudioMutexBasicLock lock(Mutex);
std::string audioName = safeCStr(name);
std::map<std::string,IAudioSource*>::iterator i = audioIndex.find(audioName);
audioIndexIterator i = audioIndex.find(audioName);
if (i == audioIndex.end())
{
return NULL;
@ -580,7 +580,7 @@ namespace cAudio
if(source)
{
cAudioMutexBasicLock lock(Mutex);
std::map<std::string,IAudioSource*>::iterator it = audioIndex.begin();
audioIndexIterator it = audioIndex.begin();
for ( it=audioIndex.begin(); it != audioIndex.end(); it++ )
{
if( it->second == source )
@ -726,7 +726,7 @@ namespace cAudio
CAUDIO_API IAudioManager* createAudioManager(bool initializeDefault)
{
cAudioManager* manager = new cAudioManager;
cAudioManager* manager = CAUDIO_NEW cAudioManager;
if(manager)
{
if(initializeDefault)
@ -795,7 +795,7 @@ namespace cAudio
manager->unRegisterAllEventHandlers();
manager->shutDown();
delete manager;
CAUDIO_DELETE manager;
manager = NULL;
}
}

2
Source/cAudioSource.cpp
View File

@ -792,7 +792,7 @@ namespace cAudio
void cAudioSource::signalEvent(Events sevent)
{
cAudioMutexBasicLock lock(Mutex);
std::list<ISourceEventHandler*>::iterator it = eventHandlerList.begin();
std::list<ISourceEventHandler*, cSTLAllocator<ISourceEventHandler*>>::iterator it = eventHandlerList.begin();
if(it != eventHandlerList.end()){

8
Source/cLogger.cpp
View File

@ -97,7 +97,7 @@ namespace cAudio
float messageTime = (clock() - StartTime) / (float)CLOCKS_PER_SEC;
vsnprintf( TempTextBuf, 2048, msg, args );
std::map<std::string,ILogReceiver*>::iterator it = Receivers.begin();
ReceiversIterator it = Receivers.begin();
for (it = Receivers.begin(); it != Receivers.end(); it++)
{
it->second->OnLogMessage(sender, TempTextBuf, level, messageTime);
@ -116,7 +116,7 @@ namespace cAudio
{
Mutex.lock();
std::string logName = safeCStr(name);
std::map<std::string, ILogReceiver*>::iterator it = Receivers.find(logName);
ReceiversIterator it = Receivers.find(logName);
if(it != Receivers.end())
{
Receivers.erase(it);
@ -128,7 +128,7 @@ namespace cAudio
{
Mutex.lock();
std::string logName = safeCStr(name);
std::map<std::string, ILogReceiver*>::iterator it = Receivers.find(logName);
ReceiversIterator it = Receivers.find(logName);
bool result = (it != Receivers.end());
Mutex.unlock();
return result;
@ -138,7 +138,7 @@ namespace cAudio
{
Mutex.lock();
std::string logName = safeCStr(name);
std::map<std::string, ILogReceiver*>::iterator it = Receivers.find(logName);
ReceiversIterator it = Receivers.find(logName);
if(it != Receivers.end())
{
Mutex.unlock();

8
Source/cPluginManager.cpp
View File

@ -23,7 +23,7 @@ cPluginManager::cPluginManager()
cPluginManager::~cPluginManager()
{
#ifdef CAUDIO_COMPILE_WITH_DYNAMIC_PLUGIN_SUPPORT
std::map<IAudioPlugin*, DYNLIB_HANDLE>::iterator it;
DynamicallyLoadedPluginsIterator it;
for(it = DynamicallyLoadedPlugins.begin(); it != DynamicallyLoadedPlugins.end(); it++)
{
//Found a plugin we loaded from the filesystem, unload it and delete the plugin
@ -99,7 +99,7 @@ unsigned int cPluginManager::getPluginCount()
std::vector<IAudioPlugin*> cPluginManager::getPluginList()
{
std::vector<IAudioPlugin*> list;
std::map<std::string, IAudioPlugin*>::iterator it;
RegisteredPluginsIterator it;
for(it = RegisteredPlugins.begin(); it != RegisteredPlugins.end(); it++)
{
list.push_back(it->second);
@ -111,7 +111,7 @@ void cPluginManager::uninstallPlugin(IAudioPlugin* plugin)
{
if(plugin)
{
std::map<std::string, IAudioPlugin*>::iterator it;
RegisteredPluginsIterator it;
for(it = RegisteredPlugins.begin(); it != RegisteredPlugins.end(); it++)
{
if(it->second == plugin)
@ -122,7 +122,7 @@ void cPluginManager::uninstallPlugin(IAudioPlugin* plugin)
}
#ifdef CAUDIO_COMPILE_WITH_DYNAMIC_PLUGIN_SUPPORT
std::map<IAudioPlugin*, DYNLIB_HANDLE>::iterator it2 = DynamicallyLoadedPlugins.find(plugin);
DynamicallyLoadedPluginsIterator it2 = DynamicallyLoadedPlugins.find(plugin);
if(it2 != DynamicallyLoadedPlugins.end())
{
//Found a plugin we loaded from the filesystem, unload it and delete the plugin

32
cAudio.vcproj
View File

@ -120,7 +120,7 @@
Name="VCCLCompilerTool"
Optimization="3"
AdditionalIncludeDirectories=".\dependencies\Headers;.\dependencies\Headers\al"
PreprocessorDefinitions="WIN32;_WINDOWS;_USRDLL;CAUDIO_EXPORTS"
PreprocessorDefinitions="WIN32;_WINDOWS;_USRDLL;"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"
@ -138,7 +138,7 @@
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="OpenAL32.lib ogg_static.lib vorbis_static.lib vorbisenc_static.lib vorbisfile_static.lib"
AdditionalDependencies="OpenAL32.lib ogg_static.lib vorbis_static.lib vorbisfile_static.lib"
LinkIncremental="2"
AdditionalLibraryDirectories=".\dependencies\Libs\windows"
GenerateManifest="false"
@ -232,6 +232,10 @@
RelativePath=".\Headers\cLogger.h"
>
</File>
<File
RelativePath=".\Headers\cMemoryOverride.h"
>
</File>
<File
RelativePath=".\Headers\cMemorySource.h"
>
@ -260,6 +264,14 @@
RelativePath=".\Headers\cRawDecoder.h"
>
</File>
<File
RelativePath=".\Headers\cStandardMemoryProvider.h"
>
</File>
<File
RelativePath=".\Headers\cSTLAllocator.h"
>
</File>
<File
RelativePath=".\Headers\cThread.h"
>
@ -296,6 +308,10 @@
RelativePath=".\Source\cAudioManager.cpp"
>
</File>
<File
RelativePath=".\Source\cAudioMemory.cpp"
>
</File>
<File
RelativePath=".\Source\cAudioSleep.cpp"
>
@ -356,6 +372,10 @@
RelativePath=".\Source\cRawDecoder.cpp"
>
</File>
<File
RelativePath=".\Source\cStandardMemoryProvider.cpp"
>
</File>
<File
RelativePath=".\Source\cThread.cpp"
>
@ -380,6 +400,10 @@
RelativePath=".\include\cAudioDefines.h"
>
</File>
<File
RelativePath=".\include\cAudioMemory.h"
>
</File>
<File
RelativePath=".\include\cAudioPlatform.h"
>
@ -460,6 +484,10 @@
RelativePath=".\include\IManagerEventHandler.h"
>
</File>
<File
RelativePath=".\include\IMemoryProvider.h"
>
</File>
<File
RelativePath=".\include\IPluginManager.h"
>

18
include/cAudioDefines.h
View File

@ -7,6 +7,12 @@
//! This is used primarily by plugins to make sure they are linking to the right library.
#define CAUDIO_VERSION "2.0.0"
#if !defined( CAUDIO_DEBUG )
#if defined( DEBUG ) || defined( _DEBUG )
#define CAUDIO_DEBUG
#endif
#endif
//////////////////////
// Windows Settings //
//////////////////////
@ -56,6 +62,9 @@
//! Max number of effects that can be attached to a single sound source
#define CAUDIO_SOURCE_MAX_EFFECT_SLOTS 4
//! Tells cAudio to use the C standard memory functions for allocations (memalloc and free)
#define CAUDIO_MEMORY_USE_STD
#endif //CAUDIO_PLATFORM_WIN
///////////////////////
@ -100,6 +109,9 @@
//! Max number of effects that can be attached to a single sound source
#define CAUDIO_SOURCE_MAX_EFFECT_SLOTS 4
//! Tells cAudio to use the C standard memory functions for allocations (memalloc and free)
#define CAUDIO_MEMORY_USE_STD
#endif //CAUDIO_PLATFORM_MAC
/////////////////////
@ -133,6 +145,9 @@
//! Number of internal buffers to cycle through per source (Note: using only 1 leads to choppy sound or premature ending of sources)
#define CAUDIO_SOURCE_NUM_BUFFERS 3
//! Tells cAudio to use the C standard memory functions for allocations (memalloc and free)
#define CAUDIO_MEMORY_USE_STD
#endif //CAUDIO_PLATFORM_IPHONE
////////////////////
@ -180,6 +195,9 @@
//! Max number of effects that can be attached to a single sound source
//#define CAUDIO_SOURCE_MAX_EFFECT_SLOTS 4
//! Tells cAudio to use the C standard memory functions for allocations (memalloc and free)
#define CAUDIO_MEMORY_USE_STD
#endif //CAUDIO_PLATFORM_LINUX
#endif //CAUDIODEFINES_H