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

Fixed the >>> needing to be > > > error with mac as well has fixed the size_t undeclared error.

This commit is contained in:
Raynaldo Rivera 2010-03-13 23:09:59 +00:00
parent 3bae1bc4db
commit dfef14e5f7
10 changed files with 691 additions and 633 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

270
Headers/cAudioManager.h
View File

@ -1,135 +1,135 @@
// Copyright (c) 2008-2010 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h
#ifndef CAUDIOMANAGER_H_INCLUDED
#define CAUDIOMANAGER_H_INCLUDED
#include <map>
#include <string>
#include <vector>
#include "cAudioSource.h"
#include "../include/IAudioDecoderFactory.h"
#include "cListener.h"
#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>
#ifdef CAUDIO_PLATFORM_LINUX
#include <AL/alext.h>
#endif
namespace cAudio
{
class IAudioSource;
class cAudioManager : public IAudioManager, public cMemoryOverride
{
public:
enum Events{
ON_INIT,
ON_UPDATE,
ON_RELEASE,
ON_SOURCECREATE,
ON_DECODERREGISTER,
ON_DATASOURCEREGISTER,
};
cAudioManager() : Device(NULL), Context(NULL), EFXSupported(false), Initialized(false) { }
virtual ~cAudioManager() { }
virtual bool initialize(const char* deviceName = 0x0, int outputFrequency = -1, int eaxEffectSlots = 4);
virtual void shutDown();
virtual void update();
virtual IAudioSource* getSoundByName(const char* name);
virtual void releaseAllSources();
virtual void release(IAudioSource* source);
virtual const char* getAvailableDeviceName(unsigned int index);
virtual unsigned int getAvailableDeviceCount();
virtual const char* getDefaultDeviceName();
virtual IAudioSource* create(const char* name, const char* filename, bool stream = false);
virtual IAudioSource* createFromMemory(const char* name, const char* data, size_t length, const char* extension);
virtual IAudioSource* createFromRaw(const char* name, const char* data, size_t length, unsigned int frequency, AudioFormats format);
virtual bool registerAudioDecoder(IAudioDecoderFactory* factory, const char* extension);
virtual void unRegisterAudioDecoder(const char* extension);
virtual bool isAudioDecoderRegistered(const char* extension);
virtual IAudioDecoderFactory* getAudioDecoderFactory(const char* extension);
virtual void unRegisterAllAudioDecoders();
virtual bool registerDataSource(IDataSourceFactory* factory, const char* name, int priority);
virtual void unRegisterDataSource(const char* name);
virtual bool isDataSourceRegistered(const char* name);
virtual IDataSourceFactory* getDataSourceFactory(const char* name);
virtual void unRegisterAllDataSources();
virtual void registerEventHandler(IManagerEventHandler* handler);
virtual void unRegisterEventHandler(IManagerEventHandler* handler) ;
virtual void unRegisterAllEventHandlers();
//! Grabs a list of available devices, as well as the default system one
void getAvailableDevices();
virtual IListener* getListener() { return &initlistener; }
#ifdef CAUDIO_EFX_ENABLED
virtual IAudioEffects* getEffects() { return &initEffects; }
#endif
private:
//! Mutex for thread syncronization
cAudioMutex Mutex;
//! An OpenAL context pointer
ALCcontext* Context;
//! An OpenAL device pointer
ALCdevice* Device;
//! Holds whether EFX is supported
bool EFXSupported;
//! Whether the manager is currently initialized and ready to go.
bool Initialized;
//! Holds an index for fast searching of audio sources by name
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*, cSTLAllocator<IAudioSource*>> audioSources;
//! Decoder map that holds all decoders by file extension
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*, 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;
#ifdef CAUDIO_EFX_ENABLED
//! Interface for audio effects
cAudioEffects initEffects;
#endif
//! Check for OpenAL errors
bool checkError();
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*, cSTLAllocator<IManagerEventHandler*>> eventHandlerList;
};
}
#endif //! CAUDIOMANAGER_H_INCLUDED
// Copyright (c) 2008-2010 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h
#ifndef CAUDIOMANAGER_H_INCLUDED
#define CAUDIOMANAGER_H_INCLUDED
#include <map>
#include <string>
#include <vector>
#include "cAudioSource.h"
#include "../include/IAudioDecoderFactory.h"
#include "cListener.h"
#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>
#ifdef CAUDIO_PLATFORM_LINUX
#include <AL/alext.h>
#endif
namespace cAudio
{
class IAudioSource;
class cAudioManager : public IAudioManager, public cMemoryOverride
{
public:
enum Events{
ON_INIT,
ON_UPDATE,
ON_RELEASE,
ON_SOURCECREATE,
ON_DECODERREGISTER,
ON_DATASOURCEREGISTER,
};
cAudioManager() : Device(NULL), Context(NULL), EFXSupported(false), Initialized(false) { }
virtual ~cAudioManager() { }
virtual bool initialize(const char* deviceName = 0x0, int outputFrequency = -1, int eaxEffectSlots = 4);
virtual void shutDown();
virtual void update();
virtual IAudioSource* getSoundByName(const char* name);
virtual void releaseAllSources();
virtual void release(IAudioSource* source);
virtual const char* getAvailableDeviceName(unsigned int index);
virtual unsigned int getAvailableDeviceCount();
virtual const char* getDefaultDeviceName();
virtual IAudioSource* create(const char* name, const char* filename, bool stream = false);
virtual IAudioSource* createFromMemory(const char* name, const char* data, size_t length, const char* extension);
virtual IAudioSource* createFromRaw(const char* name, const char* data, size_t length, unsigned int frequency, AudioFormats format);
virtual bool registerAudioDecoder(IAudioDecoderFactory* factory, const char* extension);
virtual void unRegisterAudioDecoder(const char* extension);
virtual bool isAudioDecoderRegistered(const char* extension);
virtual IAudioDecoderFactory* getAudioDecoderFactory(const char* extension);
virtual void unRegisterAllAudioDecoders();
virtual bool registerDataSource(IDataSourceFactory* factory, const char* name, int priority);
virtual void unRegisterDataSource(const char* name);
virtual bool isDataSourceRegistered(const char* name);
virtual IDataSourceFactory* getDataSourceFactory(const char* name);
virtual void unRegisterAllDataSources();
virtual void registerEventHandler(IManagerEventHandler* handler);
virtual void unRegisterEventHandler(IManagerEventHandler* handler) ;
virtual void unRegisterAllEventHandlers();
//! Grabs a list of available devices, as well as the default system one
void getAvailableDevices();
virtual IListener* getListener() { return &initlistener; }
#ifdef CAUDIO_EFX_ENABLED
virtual IAudioEffects* getEffects() { return &initEffects; }
#endif
private:
//! Mutex for thread syncronization
cAudioMutex Mutex;
//! An OpenAL context pointer
ALCcontext* Context;
//! An OpenAL device pointer
ALCdevice* Device;
//! Holds whether EFX is supported
bool EFXSupported;
//! Whether the manager is currently initialized and ready to go.
bool Initialized;
//! Holds an index for fast searching of audio sources by name
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*, cSTLAllocator<IAudioSource*> > audioSources;
//! Decoder map that holds all decoders by file extension
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*, 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;
#ifdef CAUDIO_EFX_ENABLED
//! Interface for audio effects
cAudioEffects initEffects;
#endif
//! Check for OpenAL errors
bool checkError();
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*, cSTLAllocator<IManagerEventHandler*> > eventHandlerList;
};
}
#endif //! CAUDIOMANAGER_H_INCLUDED

2
Headers/cAudioSource.h
View File

@ -156,7 +156,7 @@ namespace cAudio
bool Valid;
//! List of registered event handlers
std::list<ISourceEventHandler*, cSTLAllocator<ISourceEventHandler*>> eventHandlerList;
std::list<ISourceEventHandler*, cSTLAllocator<ISourceEventHandler*> > eventHandlerList;
#ifdef CAUDIO_EFX_ENABLED
//! Holds pointers to all the EFX related functions

4
Headers/cLogger.h
View File

@ -42,8 +42,8 @@ namespace cAudio
unsigned long StartTime;
char TempTextBuf[2048];
LogLevel MinLogLevel;
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;
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:
};
};

8
Headers/cPluginManager.h
View File

@ -74,11 +74,11 @@ namespace cAudio
void autoLoadPlugins();
#endif
protected:
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;
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, 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;
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
};
};

2
Headers/cStandardMemoryProvider.h
View File

@ -2,7 +2,7 @@
#define CSTANDARDMEMORYPROVIDER_H_INCLUDED
#include "../include/IMemoryProvider.h"
#include <cstring>
namespace cAudio
{
class cStandardMemoryProvider : public IMemoryProvider

970
Source/cAudioCapture.cpp
View File

@ -1,485 +1,485 @@
// Copyright (c) 2008-2010 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h
#include "../Headers/cAudioCapture.h"
#include "../Headers/cUtils.h"
#include "../Headers/cThread.h"
#include "../include/cAudioSleep.h"
#include "../Headers/cLogger.h"
#include "../Headers/cPluginManager.h"
#include <string.h>
#include <set>
namespace cAudio
{
static bool RunAudioCaptureThread(false);
//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*, std::less<IAudioCapture*>, cSTLAllocator<IAudioCapture*>> AudioCaptureObjects;
CAUDIO_DECLARE_THREAD_FUNCTION(AudioCaptureUpdateThread)
{
while(RunAudioCaptureThread)
{
AudioCaptureObjectsMutex.lock();
std::set<IAudioCapture*, std::less<IAudioCapture*>, cSTLAllocator<IAudioCapture*>>::iterator it;
for ( it=AudioCaptureObjects.begin() ; it != AudioCaptureObjects.end(); it++ )
{
(*it)->updateCaptureBuffer();
}
AudioCaptureObjectsMutex.unlock();
cAudioSleep(1);
}
return 0;
}
#endif
cAudioCapture::cAudioCapture() : Frequency(22050), Format(EAF_16BIT_MONO), InternalBufferSize(8192),
SampleSize(2), Supported(false), Ready(false), Capturing(false),
CaptureDevice(NULL)
{
checkCaptureExtension();
getAvailableDevices();
}
cAudioCapture::~cAudioCapture()
{
shutdown();
}
bool cAudioCapture::checkCaptureExtension()
{
cAudioMutexBasicLock lock(Mutex);
// Check for Capture Extension support
Supported = ( alcIsExtensionPresent(NULL, "ALC_EXT_CAPTURE") == AL_TRUE );
return Supported;
}
bool cAudioCapture::initOpenALDevice()
{
cAudioMutexBasicLock lock(Mutex);
if(Supported)
{
if(CaptureDevice)
shutdownOpenALDevice();
if(DeviceName.empty())
CaptureDevice = alcCaptureOpenDevice(NULL, Frequency, convertAudioFormatEnum(Format), InternalBufferSize / SampleSize);
else
CaptureDevice = alcCaptureOpenDevice(DeviceName.c_str(), Frequency, convertAudioFormatEnum(Format), InternalBufferSize / SampleSize);
if(CaptureDevice)
{
DeviceName = alcGetString(CaptureDevice, ALC_CAPTURE_DEVICE_SPECIFIER);
Ready = true;
checkError();
getLogger()->logDebug("AudioCapture", "OpenAL Capture Device Opened.");
return true;
}
}
checkError();
return false;
}
void cAudioCapture::shutdownOpenALDevice()
{
cAudioMutexBasicLock lock(Mutex);
if(Supported)
{
if(Capturing)
stopCapture();
if(CaptureDevice)
{
alcCaptureCloseDevice(CaptureDevice);
CaptureDevice = NULL;
Ready = false;
getLogger()->logDebug("AudioCapture", "OpenAL Capture Device Closed.");
signalEvent(ON_RELEASE);
}
checkError();
CaptureBuffer.clear();
}
}
void cAudioCapture::shutdown()
{
cAudioMutexBasicLock lock(Mutex);
shutdownOpenALDevice();
signalEvent(ON_RELEASE);
}
void cAudioCapture::getAvailableDevices()
{
// Get list of available Capture Devices
cAudioMutexBasicLock lock(Mutex);
if( alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE )
{
const char* deviceList = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
if (deviceList)
{
while(*deviceList)
{
std::string device(deviceList);
AvailableDevices.push_back(device);
deviceList += strlen(deviceList) + 1;
}
}
// Get the name of the 'default' capture device
DefaultDevice = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
}
}
const char* cAudioCapture::getAvailableDeviceName(unsigned int index)
{
cAudioMutexBasicLock lock(Mutex);
if(!AvailableDevices.empty())
{
//Bounds check
if( index > (AvailableDevices.size()-1) ) index = (AvailableDevices.size()-1);
const char* deviceName = AvailableDevices[index].c_str();
return deviceName;
}
return "";
}
unsigned int cAudioCapture::getAvailableDeviceCount()
{
cAudioMutexBasicLock lock(Mutex);
return AvailableDevices.size();
}
const char* cAudioCapture::getDefaultDeviceName()
{
cAudioMutexBasicLock lock(Mutex);
return DefaultDevice.empty() ? "" : DefaultDevice.c_str();
}
void cAudioCapture::updateCaptureBuffer(bool force)
{
cAudioMutexBasicLock lock(Mutex);
if(Capturing && CaptureDevice && Ready)
{
int AvailableSamples = 0;
alcGetIntegerv(CaptureDevice, ALC_CAPTURE_SAMPLES, 1, &AvailableSamples);
const unsigned int availbuffersize = AvailableSamples * SampleSize;
//If the samples in the OpenAL buffer are more than half of its max size, grab them
if(availbuffersize > InternalBufferSize / 2 || force)
{
//Fixes a bug with the capture being forced, but no data being available
if(availbuffersize > 0)
{
const unsigned int oldBufferSize = CaptureBuffer.size();
CaptureBuffer.resize(oldBufferSize + availbuffersize, 0);
alcCaptureSamples(CaptureDevice, &CaptureBuffer[oldBufferSize], AvailableSamples);
checkError();
getLogger()->logDebug("AudioCapture", "Captured %i bytes of audio data.", availbuffersize);
signalEvent(ON_UPDATE);
}
}
}
}
bool cAudioCapture::beginCapture()
{
cAudioMutexBasicLock lock(Mutex);
if(!Capturing)
{
CaptureBuffer.clear();
if(CaptureDevice && Ready)
{
alcCaptureStart(CaptureDevice);
Capturing = true;
getLogger()->logDebug("AudioCapture", "OpenAL Capture Started.");
signalEvent(ON_BEGINCAPTURE);
}
checkError();
return Capturing;
}
checkError();
return false;
}
void cAudioCapture::stopCapture()
{
cAudioMutexBasicLock lock(Mutex);
if(CaptureDevice && Ready)
{
alcCaptureStop(CaptureDevice);
updateCaptureBuffer(true);
checkError();
getLogger()->logDebug("AudioCapture", "OpenAL Capture Stopped.");
signalEvent(ON_ENDCAPTURE);
}
Capturing = false;
}
unsigned int cAudioCapture::getCapturedAudio(void* outputBuffer, unsigned int outputBufferSize)
{
cAudioMutexBasicLock lock(Mutex);
unsigned int internalBufferSize = CaptureBuffer.size();
if(outputBuffer && outputBufferSize > 0 && internalBufferSize > 0)
{
int sizeToCopy = (outputBufferSize >= internalBufferSize) ? internalBufferSize : outputBufferSize;
memcpy(outputBuffer, &CaptureBuffer[0], sizeToCopy);
CaptureBuffer.erase(CaptureBuffer.begin(), CaptureBuffer.begin()+sizeToCopy);
getLogger()->logDebug("AudioCapture", "Copied out %i bytes of data out of %i bytes in the buffer at user request.", sizeToCopy, internalBufferSize);
signalEvent(ON_USERREQUESTEDBUFFER);
return sizeToCopy;
}
return 0;
}
unsigned int cAudioCapture::getCurrentCapturedAudioSize()
{
cAudioMutexBasicLock lock(Mutex);
return CaptureBuffer.size();
}
bool cAudioCapture::setFrequency(unsigned int frequency)
{
cAudioMutexBasicLock lock(Mutex);
Frequency = frequency;
shutdownOpenALDevice();
return initOpenALDevice();
}
bool cAudioCapture::setFormat(AudioFormats format)
{
cAudioMutexBasicLock lock(Mutex);
Format = format;
if(Format == EAF_8BIT_MONO)
SampleSize = 1;
else if(Format == EAF_8BIT_STEREO)
SampleSize = 2;
else if(Format == EAF_16BIT_MONO)
SampleSize = 2;
else
SampleSize = 4;
shutdownOpenALDevice();
return initOpenALDevice();
}
bool cAudioCapture::setInternalBufferSize(unsigned int internalBufferSize)
{
cAudioMutexBasicLock lock(Mutex);
InternalBufferSize = internalBufferSize;
shutdownOpenALDevice();
return initOpenALDevice();
}
bool cAudioCapture::setDevice(const char* deviceName)
{
cAudioMutexBasicLock lock(Mutex);
DeviceName = safeCStr(deviceName);
shutdownOpenALDevice();
return initOpenALDevice();
}
bool cAudioCapture::initialize(const char* deviceName, unsigned int frequency, AudioFormats format, unsigned int internalBufferSize)
{
cAudioMutexBasicLock lock(Mutex);
DeviceName = safeCStr(deviceName);
Frequency = frequency;
InternalBufferSize = internalBufferSize;
Format = format;
if(Format == EAF_8BIT_MONO)
SampleSize = 1;
else if(Format == EAF_8BIT_STEREO)
SampleSize = 2;
else if(Format == EAF_16BIT_MONO)
SampleSize = 2;
else
SampleSize = 4;
shutdownOpenALDevice();
signalEvent(ON_INIT);
return initOpenALDevice();
}
bool cAudioCapture::checkError()
{
if(CaptureDevice)
{
int error = alcGetError(CaptureDevice);
if (error != AL_NO_ERROR)
{
const char* errorString = alGetString(error);
getLogger()->logError("AudioCapture", "OpenAL Error: %s.", errorString);
return true;
}
}
return false;
}
ALenum cAudioCapture::convertAudioFormatEnum(AudioFormats format)
{
switch(format)
{
case EAF_8BIT_MONO:
return AL_FORMAT_MONO8;
case EAF_16BIT_MONO:
return AL_FORMAT_MONO16;
case EAF_8BIT_STEREO:
return AL_FORMAT_STEREO8;
case EAF_16BIT_STEREO:
return AL_FORMAT_STEREO16;
default:
return AL_FORMAT_MONO8;
};
}
CAUDIO_API IAudioCapture* createAudioCapture(bool initializeDefault)
{
cAudioCapture* capture = CAUDIO_NEW cAudioCapture;
if(capture)
{
if(initializeDefault)
capture->initialize();
#ifdef CAUDIO_COMPILE_WITH_PLUGIN_SUPPORT
std::vector<IAudioPlugin*> plugins = cPluginManager::Instance()->getPluginList();
for(unsigned int i = 0; i < plugins.size(); ++i)
{
plugins[i]->onCreateAudioCapture(capture);
}
#endif
#ifdef CAUDIO_USE_INTERNAL_THREAD
AudioCaptureObjectsMutex.lock();
AudioCaptureObjects.insert(capture);
//First time launch of thread
if(!RunAudioCaptureThread && AudioCaptureObjects.size() > 0)
RunAudioCaptureThread = (cAudioThread::SpawnThread(AudioCaptureUpdateThread, NULL) == 0);
AudioCaptureObjectsMutex.unlock();
#endif
}
return capture;
}
CAUDIO_API void destroyAudioCapture(IAudioCapture* capture)
{
if(capture)
{
#ifdef CAUDIO_USE_INTERNAL_THREAD
AudioCaptureObjectsMutex.lock();
AudioCaptureObjects.erase(capture);
//Kill the thread if there are no objects to process anymore
if(RunAudioCaptureThread && AudioCaptureObjects.empty())
RunAudioCaptureThread = false;
AudioCaptureObjectsMutex.unlock();
#endif
#ifdef CAUDIO_COMPILE_WITH_PLUGIN_SUPPORT
std::vector<IAudioPlugin*> plugins = cPluginManager::Instance()->getPluginList();
for(unsigned int i = 0; i < plugins.size(); ++i)
{
plugins[i]->onDestoryAudioCapture(capture);
}
#endif
CAUDIO_DELETE capture;
capture = NULL;
}
}
CAUDIO_API bool isAudioCaptureThreadRunning()
{
return RunAudioCaptureThread;
}
void cAudioCapture::registerEventHandler(ICaptureEventHandler* handler)
{
if(handler)
{
eventHandlerList.push_back(handler);
}
}
void cAudioCapture::unRegisterEventHandler(ICaptureEventHandler* handler)
{
if(handler)
{
eventHandlerList.remove(handler);
}
}
void cAudioCapture::unRegisterAllEventHandlers()
{
eventHandlerList.clear();
}
void cAudioCapture::signalEvent(Events sevent)
{
cAudioMutexBasicLock lock(Mutex);
std::list<ICaptureEventHandler*, cSTLAllocator<ICaptureEventHandler*> >::iterator it = eventHandlerList.begin();
if(it != eventHandlerList.end()){
switch(sevent){
case ON_INIT:
for(it; it != eventHandlerList.end(); it++){
(*it)->onInit();
}
break;
case ON_UPDATE:
for(it; it != eventHandlerList.end(); it++){
(*it)->onUpdate();
}
break;
case ON_RELEASE:
for(it; it != eventHandlerList.end(); it++){
(*it)->onRelease();
}
break;
case ON_BEGINCAPTURE:
for(it; it != eventHandlerList.end(); it++){
(*it)->onBeginCapture();
}
break;
case ON_ENDCAPTURE:
for(it; it != eventHandlerList.end(); it++){
(*it)->onEndCapture();
}
break;
case ON_USERREQUESTEDBUFFER:
for(it; it != eventHandlerList.end(); it++){
(*it)->onUserRequestBuffer();
}
break;
}
}
}
};
// Copyright (c) 2008-2010 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h
#include "../Headers/cAudioCapture.h"
#include "../Headers/cUtils.h"
#include "../Headers/cThread.h"
#include "../include/cAudioSleep.h"
#include "../Headers/cLogger.h"
#include "../Headers/cPluginManager.h"
#include <string.h>
#include <set>
namespace cAudio
{
static bool RunAudioCaptureThread(false);
//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*, std::less<IAudioCapture*>, cSTLAllocator<IAudioCapture*> > AudioCaptureObjects;
CAUDIO_DECLARE_THREAD_FUNCTION(AudioCaptureUpdateThread)
{
while(RunAudioCaptureThread)
{
AudioCaptureObjectsMutex.lock();
std::set<IAudioCapture*, std::less<IAudioCapture*>, cSTLAllocator<IAudioCapture*> >::iterator it;
for ( it=AudioCaptureObjects.begin() ; it != AudioCaptureObjects.end(); it++ )
{
(*it)->updateCaptureBuffer();
}
AudioCaptureObjectsMutex.unlock();
cAudioSleep(1);
}
return 0;
}
#endif
cAudioCapture::cAudioCapture() : Frequency(22050), Format(EAF_16BIT_MONO), InternalBufferSize(8192),
SampleSize(2), Supported(false), Ready(false), Capturing(false),
CaptureDevice(NULL)
{
checkCaptureExtension();
getAvailableDevices();
}
cAudioCapture::~cAudioCapture()
{
shutdown();
}
bool cAudioCapture::checkCaptureExtension()
{
cAudioMutexBasicLock lock(Mutex);
// Check for Capture Extension support
Supported = ( alcIsExtensionPresent(NULL, "ALC_EXT_CAPTURE") == AL_TRUE );
return Supported;
}
bool cAudioCapture::initOpenALDevice()
{
cAudioMutexBasicLock lock(Mutex);
if(Supported)
{
if(CaptureDevice)
shutdownOpenALDevice();
if(DeviceName.empty())
CaptureDevice = alcCaptureOpenDevice(NULL, Frequency, convertAudioFormatEnum(Format), InternalBufferSize / SampleSize);
else
CaptureDevice = alcCaptureOpenDevice(DeviceName.c_str(), Frequency, convertAudioFormatEnum(Format), InternalBufferSize / SampleSize);
if(CaptureDevice)
{
DeviceName = alcGetString(CaptureDevice, ALC_CAPTURE_DEVICE_SPECIFIER);
Ready = true;
checkError();
getLogger()->logDebug("AudioCapture", "OpenAL Capture Device Opened.");
return true;
}
}
checkError();
return false;
}
void cAudioCapture::shutdownOpenALDevice()
{
cAudioMutexBasicLock lock(Mutex);
if(Supported)
{
if(Capturing)
stopCapture();
if(CaptureDevice)
{
alcCaptureCloseDevice(CaptureDevice);
CaptureDevice = NULL;
Ready = false;
getLogger()->logDebug("AudioCapture", "OpenAL Capture Device Closed.");
signalEvent(ON_RELEASE);
}
checkError();
CaptureBuffer.clear();
}
}
void cAudioCapture::shutdown()
{
cAudioMutexBasicLock lock(Mutex);
shutdownOpenALDevice();
signalEvent(ON_RELEASE);
}
void cAudioCapture::getAvailableDevices()
{
// Get list of available Capture Devices
cAudioMutexBasicLock lock(Mutex);
if( alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE )
{
const char* deviceList = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
if (deviceList)
{
while(*deviceList)
{
std::string device(deviceList);
AvailableDevices.push_back(device);
deviceList += strlen(deviceList) + 1;
}
}
// Get the name of the 'default' capture device
DefaultDevice = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
}
}
const char* cAudioCapture::getAvailableDeviceName(unsigned int index)
{
cAudioMutexBasicLock lock(Mutex);
if(!AvailableDevices.empty())
{
//Bounds check
if( index > (AvailableDevices.size()-1) ) index = (AvailableDevices.size()-1);
const char* deviceName = AvailableDevices[index].c_str();
return deviceName;
}
return "";
}
unsigned int cAudioCapture::getAvailableDeviceCount()
{
cAudioMutexBasicLock lock(Mutex);
return AvailableDevices.size();
}
const char* cAudioCapture::getDefaultDeviceName()
{
cAudioMutexBasicLock lock(Mutex);
return DefaultDevice.empty() ? "" : DefaultDevice.c_str();
}
void cAudioCapture::updateCaptureBuffer(bool force)
{
cAudioMutexBasicLock lock(Mutex);
if(Capturing && CaptureDevice && Ready)
{
int AvailableSamples = 0;
alcGetIntegerv(CaptureDevice, ALC_CAPTURE_SAMPLES, 1, &AvailableSamples);
const unsigned int availbuffersize = AvailableSamples * SampleSize;
//If the samples in the OpenAL buffer are more than half of its max size, grab them
if(availbuffersize > InternalBufferSize / 2 || force)
{
//Fixes a bug with the capture being forced, but no data being available
if(availbuffersize > 0)
{
const unsigned int oldBufferSize = CaptureBuffer.size();
CaptureBuffer.resize(oldBufferSize + availbuffersize, 0);
alcCaptureSamples(CaptureDevice, &CaptureBuffer[oldBufferSize], AvailableSamples);
checkError();
getLogger()->logDebug("AudioCapture", "Captured %i bytes of audio data.", availbuffersize);
signalEvent(ON_UPDATE);
}
}
}
}
bool cAudioCapture::beginCapture()
{
cAudioMutexBasicLock lock(Mutex);
if(!Capturing)
{
CaptureBuffer.clear();
if(CaptureDevice && Ready)
{
alcCaptureStart(CaptureDevice);
Capturing = true;
getLogger()->logDebug("AudioCapture", "OpenAL Capture Started.");
signalEvent(ON_BEGINCAPTURE);
}
checkError();
return Capturing;
}
checkError();
return false;
}
void cAudioCapture::stopCapture()
{
cAudioMutexBasicLock lock(Mutex);
if(CaptureDevice && Ready)
{
alcCaptureStop(CaptureDevice);
updateCaptureBuffer(true);
checkError();
getLogger()->logDebug("AudioCapture", "OpenAL Capture Stopped.");
signalEvent(ON_ENDCAPTURE);
}
Capturing = false;
}
unsigned int cAudioCapture::getCapturedAudio(void* outputBuffer, unsigned int outputBufferSize)
{
cAudioMutexBasicLock lock(Mutex);
unsigned int internalBufferSize = CaptureBuffer.size();
if(outputBuffer && outputBufferSize > 0 && internalBufferSize > 0)
{
int sizeToCopy = (outputBufferSize >= internalBufferSize) ? internalBufferSize : outputBufferSize;
memcpy(outputBuffer, &CaptureBuffer[0], sizeToCopy);
CaptureBuffer.erase(CaptureBuffer.begin(), CaptureBuffer.begin()+sizeToCopy);
getLogger()->logDebug("AudioCapture", "Copied out %i bytes of data out of %i bytes in the buffer at user request.", sizeToCopy, internalBufferSize);
signalEvent(ON_USERREQUESTEDBUFFER);
return sizeToCopy;
}
return 0;
}
unsigned int cAudioCapture::getCurrentCapturedAudioSize()
{
cAudioMutexBasicLock lock(Mutex);
return CaptureBuffer.size();
}
bool cAudioCapture::setFrequency(unsigned int frequency)
{
cAudioMutexBasicLock lock(Mutex);
Frequency = frequency;
shutdownOpenALDevice();
return initOpenALDevice();
}
bool cAudioCapture::setFormat(AudioFormats format)
{
cAudioMutexBasicLock lock(Mutex);
Format = format;
if(Format == EAF_8BIT_MONO)
SampleSize = 1;
else if(Format == EAF_8BIT_STEREO)
SampleSize = 2;
else if(Format == EAF_16BIT_MONO)
SampleSize = 2;
else
SampleSize = 4;
shutdownOpenALDevice();
return initOpenALDevice();
}
bool cAudioCapture::setInternalBufferSize(unsigned int internalBufferSize)
{
cAudioMutexBasicLock lock(Mutex);
InternalBufferSize = internalBufferSize;
shutdownOpenALDevice();
return initOpenALDevice();
}
bool cAudioCapture::setDevice(const char* deviceName)
{
cAudioMutexBasicLock lock(Mutex);
DeviceName = safeCStr(deviceName);
shutdownOpenALDevice();
return initOpenALDevice();
}
bool cAudioCapture::initialize(const char* deviceName, unsigned int frequency, AudioFormats format, unsigned int internalBufferSize)
{
cAudioMutexBasicLock lock(Mutex);
DeviceName = safeCStr(deviceName);
Frequency = frequency;
InternalBufferSize = internalBufferSize;
Format = format;
if(Format == EAF_8BIT_MONO)
SampleSize = 1;
else if(Format == EAF_8BIT_STEREO)
SampleSize = 2;
else if(Format == EAF_16BIT_MONO)
SampleSize = 2;
else
SampleSize = 4;
shutdownOpenALDevice();
signalEvent(ON_INIT);
return initOpenALDevice();
}
bool cAudioCapture::checkError()
{
if(CaptureDevice)
{
int error = alcGetError(CaptureDevice);
if (error != AL_NO_ERROR)
{
const char* errorString = alGetString(error);
getLogger()->logError("AudioCapture", "OpenAL Error: %s.", errorString);
return true;
}
}
return false;
}
ALenum cAudioCapture::convertAudioFormatEnum(AudioFormats format)
{
switch(format)
{
case EAF_8BIT_MONO:
return AL_FORMAT_MONO8;
case EAF_16BIT_MONO:
return AL_FORMAT_MONO16;
case EAF_8BIT_STEREO:
return AL_FORMAT_STEREO8;
case EAF_16BIT_STEREO:
return AL_FORMAT_STEREO16;
default:
return AL_FORMAT_MONO8;
};
}
CAUDIO_API IAudioCapture* createAudioCapture(bool initializeDefault)
{
cAudioCapture* capture = CAUDIO_NEW cAudioCapture;
if(capture)
{
if(initializeDefault)
capture->initialize();
#ifdef CAUDIO_COMPILE_WITH_PLUGIN_SUPPORT
std::vector<IAudioPlugin*> plugins = cPluginManager::Instance()->getPluginList();
for(unsigned int i = 0; i < plugins.size(); ++i)
{
plugins[i]->onCreateAudioCapture(capture);
}
#endif
#ifdef CAUDIO_USE_INTERNAL_THREAD
AudioCaptureObjectsMutex.lock();
AudioCaptureObjects.insert(capture);
//First time launch of thread
if(!RunAudioCaptureThread && AudioCaptureObjects.size() > 0)
RunAudioCaptureThread = (cAudioThread::SpawnThread(AudioCaptureUpdateThread, NULL) == 0);
AudioCaptureObjectsMutex.unlock();
#endif
}
return capture;
}
CAUDIO_API void destroyAudioCapture(IAudioCapture* capture)
{
if(capture)
{
#ifdef CAUDIO_USE_INTERNAL_THREAD
AudioCaptureObjectsMutex.lock();
AudioCaptureObjects.erase(capture);
//Kill the thread if there are no objects to process anymore
if(RunAudioCaptureThread && AudioCaptureObjects.empty())
RunAudioCaptureThread = false;
AudioCaptureObjectsMutex.unlock();
#endif
#ifdef CAUDIO_COMPILE_WITH_PLUGIN_SUPPORT
std::vector<IAudioPlugin*> plugins = cPluginManager::Instance()->getPluginList();
for(unsigned int i = 0; i < plugins.size(); ++i)
{
plugins[i]->onDestoryAudioCapture(capture);
}
#endif
CAUDIO_DELETE capture;
capture = NULL;
}
}
CAUDIO_API bool isAudioCaptureThreadRunning()
{
return RunAudioCaptureThread;
}
void cAudioCapture::registerEventHandler(ICaptureEventHandler* handler)
{
if(handler)
{
eventHandlerList.push_back(handler);
}
}
void cAudioCapture::unRegisterEventHandler(ICaptureEventHandler* handler)
{
if(handler)
{
eventHandlerList.remove(handler);
}
}
void cAudioCapture::unRegisterAllEventHandlers()
{
eventHandlerList.clear();
}
void cAudioCapture::signalEvent(Events sevent)
{
cAudioMutexBasicLock lock(Mutex);
std::list<ICaptureEventHandler*, cSTLAllocator<ICaptureEventHandler*> >::iterator it = eventHandlerList.begin();
if(it != eventHandlerList.end()){
switch(sevent){
case ON_INIT:
for(it; it != eventHandlerList.end(); it++){
(*it)->onInit();
}
break;
case ON_UPDATE:
for(it; it != eventHandlerList.end(); it++){
(*it)->onUpdate();
}
break;
case ON_RELEASE:
for(it; it != eventHandlerList.end(); it++){
(*it)->onRelease();
}
break;
case ON_BEGINCAPTURE:
for(it; it != eventHandlerList.end(); it++){
(*it)->onBeginCapture();
}
break;
case ON_ENDCAPTURE:
for(it; it != eventHandlerList.end(); it++){
(*it)->onEndCapture();
}
break;
case ON_USERREQUESTEDBUFFER:
for(it; it != eventHandlerList.end(); it++){
(*it)->onUserRequestBuffer();
}
break;
}
}
}
};

6
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*, std::less<IAudioManager*>, cSTLAllocator<IAudioManager*>> AudioManagerObjects;
static std::set<IAudioManager*, std::less<IAudioManager*>, cSTLAllocator<IAudioManager*> > AudioManagerObjects;
CAUDIO_DECLARE_THREAD_FUNCTION(AudioManagerUpdateThread)
{
while(RunAudioManagerThread)
{
AudioManagerObjectsMutex.lock();
std::set<IAudioManager*, std::less<IAudioManager*>, cSTLAllocator<IAudioManager*>>::iterator it;
std::set<IAudioManager*, std::less<IAudioManager*>, cSTLAllocator<IAudioManager*> >::iterator it;
for ( it=AudioManagerObjects.begin() ; it != AudioManagerObjects.end(); it++ )
{
(*it)->update();
@ -487,7 +487,7 @@ namespace cAudio
void cAudioManager::signalEvent(Events sevent)
{
cAudioMutexBasicLock lock(Mutex);
std::list<IManagerEventHandler*, cSTLAllocator<IManagerEventHandler*>>::iterator it = eventHandlerList.begin();
std::list<IManagerEventHandler*, cSTLAllocator<IManagerEventHandler*> >::iterator it = eventHandlerList.begin();
if(it != eventHandlerList.end())
{

2
Source/cAudioSource.cpp
View File

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

58
cAudio-Osx.xcodeproj/project.pbxproj
View File

@ -80,6 +80,24 @@
7B09C638113A17E5008C46C9 /* IRefCounted.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B09C61E113A17E5008C46C9 /* IRefCounted.h */; };
7B09C639113A17E5008C46C9 /* ISourceEventHandler.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B09C61F113A17E5008C46C9 /* ISourceEventHandler.h */; };
7B09C63B113A17F5008C46C9 /* OpenAL.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 7B09C63A113A17F5008C46C9 /* OpenAL.framework */; };
7B1075AE114845AF0030E6F5 /* cStandardMemoryProvider.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075AA114845AF0030E6F5 /* cStandardMemoryProvider.h */; };
7B1075AF114845AF0030E6F5 /* cMemoryTracker.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075AB114845AF0030E6F5 /* cMemoryTracker.h */; };
7B1075B0114845AF0030E6F5 /* cMemoryOverride.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075AC114845AF0030E6F5 /* cMemoryOverride.h */; };
7B1075B1114845AF0030E6F5 /* cSTLAllocator.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075AD114845AF0030E6F5 /* cSTLAllocator.h */; };
7B1075B2114845AF0030E6F5 /* cStandardMemoryProvider.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075AA114845AF0030E6F5 /* cStandardMemoryProvider.h */; };
7B1075B3114845AF0030E6F5 /* cMemoryTracker.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075AB114845AF0030E6F5 /* cMemoryTracker.h */; };
7B1075B4114845AF0030E6F5 /* cMemoryOverride.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075AC114845AF0030E6F5 /* cMemoryOverride.h */; };
7B1075B5114845AF0030E6F5 /* cSTLAllocator.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075AD114845AF0030E6F5 /* cSTLAllocator.h */; };
7B1075B9114846CD0030E6F5 /* cAudioMemory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7B1075B6114846CD0030E6F5 /* cAudioMemory.cpp */; };
7B1075BA114846CD0030E6F5 /* cMemoryTracker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7B1075B7114846CD0030E6F5 /* cMemoryTracker.cpp */; };
7B1075BB114846CD0030E6F5 /* cStandardMemoryProvider.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7B1075B8114846CD0030E6F5 /* cStandardMemoryProvider.cpp */; };
7B1075BC114846CD0030E6F5 /* cAudioMemory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7B1075B6114846CD0030E6F5 /* cAudioMemory.cpp */; };
7B1075BD114846CD0030E6F5 /* cMemoryTracker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7B1075B7114846CD0030E6F5 /* cMemoryTracker.cpp */; };
7B1075BE114846CD0030E6F5 /* cStandardMemoryProvider.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7B1075B8114846CD0030E6F5 /* cStandardMemoryProvider.cpp */; };
7B1075C0114846EB0030E6F5 /* IMemoryProvider.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075BF114846EB0030E6F5 /* IMemoryProvider.h */; };
7B1075C1114846EB0030E6F5 /* IMemoryProvider.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075BF114846EB0030E6F5 /* IMemoryProvider.h */; };
7B1075C3114846F00030E6F5 /* cAudioMemory.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075C2114846F00030E6F5 /* cAudioMemory.h */; };
7B1075C4114846F00030E6F5 /* cAudioMemory.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1075C2114846F00030E6F5 /* cAudioMemory.h */; };
7B891F76113A221E001CDBC6 /* cAudio.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B09C606113A17E5008C46C9 /* cAudio.h */; };
7B891F77113A221E001CDBC6 /* cAudioDefines.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B09C607113A17E5008C46C9 /* cAudioDefines.h */; };
7B891F78113A221E001CDBC6 /* cAudioPlatform.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B09C608113A17E5008C46C9 /* cAudioPlatform.h */; };
@ -229,6 +247,15 @@
7B09C61E113A17E5008C46C9 /* IRefCounted.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IRefCounted.h; sourceTree = "<group>"; };
7B09C61F113A17E5008C46C9 /* ISourceEventHandler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ISourceEventHandler.h; sourceTree = "<group>"; };
7B09C63A113A17F5008C46C9 /* OpenAL.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = OpenAL.framework; path = /System/Library/Frameworks/OpenAL.framework; sourceTree = "<absolute>"; };
7B1075AA114845AF0030E6F5 /* cStandardMemoryProvider.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cStandardMemoryProvider.h; sourceTree = "<group>"; };
7B1075AB114845AF0030E6F5 /* cMemoryTracker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cMemoryTracker.h; sourceTree = "<group>"; };
7B1075AC114845AF0030E6F5 /* cMemoryOverride.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cMemoryOverride.h; sourceTree = "<group>"; };
7B1075AD114845AF0030E6F5 /* cSTLAllocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cSTLAllocator.h; sourceTree = "<group>"; };
7B1075B6114846CD0030E6F5 /* cAudioMemory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cAudioMemory.cpp; sourceTree = "<group>"; };
7B1075B7114846CD0030E6F5 /* cMemoryTracker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cMemoryTracker.cpp; sourceTree = "<group>"; };
7B1075B8114846CD0030E6F5 /* cStandardMemoryProvider.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cStandardMemoryProvider.cpp; sourceTree = "<group>"; };
7B1075BF114846EB0030E6F5 /* IMemoryProvider.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IMemoryProvider.h; sourceTree = "<group>"; };
7B1075C2114846F00030E6F5 /* cAudioMemory.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cAudioMemory.h; sourceTree = "<group>"; };
7B891F72113A21C9001CDBC6 /* liblibcAudio_d.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = liblibcAudio_d.a; sourceTree = BUILT_PRODUCTS_DIR; };
D2AAC09D05546B4700DB518D /* libcAudio_d.dylib */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.dylib"; includeInIndex = 0; path = libcAudio_d.dylib; sourceTree = BUILT_PRODUCTS_DIR; };
/* End PBXFileReference section */
@ -294,6 +321,9 @@
7B09C5AE113A17D9008C46C9 /* cEffect.cpp */,
7B09C5AF113A17D9008C46C9 /* cFileLogReceiver.cpp */,
7B09C5B0113A17D9008C46C9 /* cFileSource.cpp */,
7B1075B6114846CD0030E6F5 /* cAudioMemory.cpp */,
7B1075B7114846CD0030E6F5 /* cMemoryTracker.cpp */,
7B1075B8114846CD0030E6F5 /* cStandardMemoryProvider.cpp */,
7B09C5B1113A17D9008C46C9 /* cFilter.cpp */,
7B09C5B2113A17D9008C46C9 /* cListener.cpp */,
7B09C5B3113A17D9008C46C9 /* cLogger.cpp */,
@ -319,6 +349,10 @@
7B09C5D7113A17DD008C46C9 /* cAudioManager.h */,
7B09C5D8113A17DD008C46C9 /* cAudioSource.h */,
7B09C5D9113A17DD008C46C9 /* cConsoleLogReceiver.h */,
7B1075AA114845AF0030E6F5 /* cStandardMemoryProvider.h */,
7B1075AB114845AF0030E6F5 /* cMemoryTracker.h */,
7B1075AC114845AF0030E6F5 /* cMemoryOverride.h */,
7B1075AD114845AF0030E6F5 /* cSTLAllocator.h */,
7B09C5DA113A17DD008C46C9 /* cEffect.h */,
7B09C5DB113A17DD008C46C9 /* cEFXFunctions.h */,
7B09C5DC113A17DD008C46C9 /* cFileLogReceiver.h */,
@ -354,11 +388,13 @@
7B09C60C113A17E5008C46C9 /* IAudioCapture.h */,
7B09C60D113A17E5008C46C9 /* IAudioDecoder.h */,
7B09C60E113A17E5008C46C9 /* IAudioDecoderFactory.h */,
7B1075BF114846EB0030E6F5 /* IMemoryProvider.h */,
7B09C60F113A17E5008C46C9 /* IAudioEffects.h */,
7B09C610113A17E5008C46C9 /* IAudioManager.h */,
7B09C611113A17E5008C46C9 /* IAudioPlugin.h */,
7B09C612113A17E5008C46C9 /* IAudioSource.h */,
7B09C613113A17E5008C46C9 /* ICaptureEventHandler.h */,
7B1075C2114846F00030E6F5 /* cAudioMemory.h */,
7B09C614113A17E5008C46C9 /* IDataSource.h */,
7B09C615113A17E5008C46C9 /* IDataSourceFactory.h */,
7B09C616113A17E5008C46C9 /* IEffect.h */,
@ -432,6 +468,12 @@
7B891FA5113A2222001CDBC6 /* cUtils.h in Headers */,
7B891FA6113A2222001CDBC6 /* cWavAudioDecoderFactory.h in Headers */,
7B891FA7113A2222001CDBC6 /* cWavDecoder.h in Headers */,
7B1075B2114845AF0030E6F5 /* cStandardMemoryProvider.h in Headers */,
7B1075B3114845AF0030E6F5 /* cMemoryTracker.h in Headers */,
7B1075B4114845AF0030E6F5 /* cMemoryOverride.h in Headers */,
7B1075B5114845AF0030E6F5 /* cSTLAllocator.h in Headers */,
7B1075C1114846EB0030E6F5 /* IMemoryProvider.h in Headers */,
7B1075C4114846F00030E6F5 /* cAudioMemory.h in Headers */,
);
runOnlyForDeploymentPostprocessing = 0;
};
@ -489,6 +531,12 @@
7B09C637113A17E5008C46C9 /* IPluginManager.h in Headers */,
7B09C638113A17E5008C46C9 /* IRefCounted.h in Headers */,
7B09C639113A17E5008C46C9 /* ISourceEventHandler.h in Headers */,
7B1075AE114845AF0030E6F5 /* cStandardMemoryProvider.h in Headers */,
7B1075AF114845AF0030E6F5 /* cMemoryTracker.h in Headers */,
7B1075B0114845AF0030E6F5 /* cMemoryOverride.h in Headers */,
7B1075B1114845AF0030E6F5 /* cSTLAllocator.h in Headers */,
7B1075C0114846EB0030E6F5 /* IMemoryProvider.h in Headers */,
7B1075C3114846F00030E6F5 /* cAudioMemory.h in Headers */,
);
runOnlyForDeploymentPostprocessing = 0;
};
@ -575,6 +623,9 @@
7B891FBB113A2227001CDBC6 /* cWavAudioDecoderFactory.cpp in Sources */,
7B891FBC113A2227001CDBC6 /* cWavDecoder.cpp in Sources */,
7B891FBD113A2227001CDBC6 /* Makefile in Sources */,
7B1075BC114846CD0030E6F5 /* cAudioMemory.cpp in Sources */,
7B1075BD114846CD0030E6F5 /* cMemoryTracker.cpp in Sources */,
7B1075BE114846CD0030E6F5 /* cStandardMemoryProvider.cpp in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
@ -604,6 +655,9 @@
7B09C5D1113A17D9008C46C9 /* cWavAudioDecoderFactory.cpp in Sources */,
7B09C5D2113A17D9008C46C9 /* cWavDecoder.cpp in Sources */,
7B09C5D3113A17D9008C46C9 /* Makefile in Sources */,
7B1075B9114846CD0030E6F5 /* cAudioMemory.cpp in Sources */,
7B1075BA114846CD0030E6F5 /* cMemoryTracker.cpp in Sources */,
7B1075BB114846CD0030E6F5 /* cStandardMemoryProvider.cpp in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
@ -666,6 +720,8 @@
isa = XCBuildConfiguration;
buildSettings = {
ARCHS = "$(ARCHS_STANDARD_32_BIT)";
CONFIGURATION_BUILD_DIR = "$(BUILD_DIR)/";
CONFIGURATION_TEMP_DIR = .;
GCC_C_LANGUAGE_STANDARD = c99;
GCC_OPTIMIZATION_LEVEL = 0;
GCC_WARN_ABOUT_RETURN_TYPE = YES;
@ -682,6 +738,8 @@
isa = XCBuildConfiguration;
buildSettings = {
ARCHS = "$(ARCHS_STANDARD_32_BIT)";
CONFIGURATION_BUILD_DIR = "$(BUILD_DIR)/";
CONFIGURATION_TEMP_DIR = .;
GCC_C_LANGUAGE_STANDARD = c99;
GCC_WARN_ABOUT_RETURN_TYPE = YES;
GCC_WARN_UNUSED_VARIABLE = YES;

2
include/IMemoryProvider.h
View File

@ -2,7 +2,7 @@
#define IMEMORYPROVIDER_H_INCLUDED
#include "../include/cAudioDefines.h"
#include <cstring>
namespace cAudio
{
//! Interface for a class that allocates and frees memory used by cAudio.