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

add static source type, various bug and compiler error/warning fixes

This commit is contained in:
Arthur Danskin 2015-09-27 15:11:51 -07:00
parent 5c93210189
commit 36943a1885
45 changed files with 1095 additions and 550 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
cAudio/Headers/cAudioCapture.h
View File

@ -4,8 +4,7 @@
#pragma once
#include <al.h>
#include <alc.h>
#include "cOpenALUtil.h"
#include "cMutex.h"
#include "cMemoryOverride.h"
#include "IAudioCapture.h"
@ -36,8 +35,8 @@ namespace cAudio
virtual void updateCaptureBuffer(bool force = false);
virtual void shutdown();
virtual bool isUpdateThreadRunning()
{
return (AudioThread != NULL && AudioThread->isRunning());
{
return (AudioThread != NULL && AudioThread->isRunning());
}
virtual const char* getDeviceName() { return toUTF8(DeviceName); }
@ -68,7 +67,7 @@ namespace cAudio
cAudioMutex Mutex;
//! Our update thread
//! Our update thread
IThread* AudioThread;
bool initOpenALDevice();
@ -92,4 +91,4 @@ namespace cAudio
ALenum convertAudioFormatEnum(AudioFormats format);
void signalEvent(Events sevent);
};
};
};

15
cAudio/Headers/cAudioManager.h
View File

@ -18,6 +18,7 @@
namespace cAudio
{
class IAudioSource;
class IAudioBuffer;
class cAudioManager : public IAudioManager, public cMemoryOverride, public IThreadWorker
{
@ -31,11 +32,11 @@ namespace cAudio
ON_DATASOURCEREGISTER,
};
cAudioManager() : AudioThread(NULL), AudioContext(NULL), Initialized(false), MasterVolume(1.0f) { }
cAudioManager() : Initialized(false), AudioThread(NULL), AudioContext(NULL), MasterVolume(1.0f) { }
virtual ~cAudioManager();
virtual bool initialize(const char* deviceName = 0x0, int outputFrequency = -1, int eaxEffectSlots = 4);
virtual void shutDown();
virtual void shutDown();
virtual void update();
virtual IAudioSource* getSoundByName(const char* name);
virtual void releaseAllSources();
@ -46,6 +47,10 @@ namespace cAudio
virtual void setMasterVolume(float vol);
virtual float getMasterVolume() const;
virtual void setSpeedOfSound(float speed);
virtual float getSpeedOfSound() const;
virtual void setDopplerFactor(float factor) const;
virtual float getDopplerFactor() const;
virtual void stopAllSounds();
virtual IAudioSource* create(const char* name, const char* filename, bool stream = false);
@ -53,6 +58,9 @@ namespace cAudio
virtual IAudioSource* createFromRaw(const char* name, const char* data, size_t length, unsigned int frequency, AudioFormats format);
virtual IAudioSource* createFromAudioBuffer(const char* name, AudioCaptureBuffer* pBiffer, unsigned int frequency, AudioFormats format);
virtual IAudioBuffer* createBuffer(const char* filename);
virtual IAudioSource* createStatic(IAudioBuffer* buffer);
virtual bool registerAudioDecoder(IAudioDecoderFactory* factory, const char* extension);
virtual void unRegisterAudioDecoder(const char* extension);
virtual bool isAudioDecoderRegistered(const char* extension);
@ -77,6 +85,8 @@ namespace cAudio
virtual IAudioEffects* getEffects();
#endif
virtual cAudioMutex *getMutex() { return &Mutex; }
protected:
virtual void run();
@ -101,6 +111,7 @@ namespace cAudio
typedef cAudioMap<cAudioString, IAudioSource*>::Type::iterator audioIndexIterator;
//! Holds all managed audio sources
cAudioVector<IAudioSource*>::Type audioSources;
cAudioVector<IAudioSource*>::Type updateSources;
//! Holds audio sources which gets deleted from the audioManager
cAudioVector<IAudioSource*>::Type managedAudioSources;
//! Holds audio sources which gets deleted from the audioManager

156
cAudio/Headers/cAudioSource.h
View File

@ -7,9 +7,8 @@
#include <list>
#include <string>
#include <vector>
#include <al.h>
#include <alc.h>
#include "cOpenALUtil.h"
#include "cMutex.h"
#include "cEFXFunctions.h"
#include "cMemoryOverride.h"
@ -21,8 +20,8 @@
namespace cAudio
{
class cAudioSource : public IAudioSource, public cMemoryOverride
class cAudioSourceBase : public IAudioSource, public cMemoryOverride
{
public:
@ -34,38 +33,13 @@ namespace cAudio
ON_STOP,
};
#if CAUDIO_EFX_ENABLED == 1
cAudioSource(IAudioDecoder* decoder, IAudioDeviceContext* context, cEFXFunctions* oALFunctions);
#else
cAudioSource(IAudioDecoder* decoder, IAudioDeviceContext* context);
#endif
~cAudioSource();
cAudioSourceBase(IAudioDeviceContext* context);
virtual ~cAudioSourceBase();
virtual bool play();
virtual bool play2d(const bool& toLoop = false);
virtual bool play3d(const cVector3& position, const float& soundstr = 1.0 , const bool& toLoop = false);
virtual void pause();
virtual void stop();
virtual void loop(const bool& toLoop);
virtual bool seek(const float& seconds, bool relative = false);
virtual bool isPlaying() const;
virtual bool isPaused() const;
virtual bool isStopped() const;
virtual float getTotalAudioTime();
virtual int getTotalAudioSize();
virtual int getCompressedAudioSize();
virtual float getCurrentAudioTime();
virtual int getCurrentAudioPosition();
virtual int getCurrentCompressedAudioPosition();
virtual bool update();
virtual const bool isValid() const;
virtual const bool isPlaying() const;
virtual const bool isPaused() const;
virtual const bool isStopped() const;
virtual const bool isLooping() const;
virtual void setPosition(const cVector3& position);
virtual void setVelocity(const cVector3& velocity);
virtual void setDirection(const cVector3& direction);
@ -89,31 +63,90 @@ namespace cAudio
virtual void move(const cVector3& position);
virtual const cVector3 getPosition() const;
virtual const cVector3 getVelocity() const;
virtual const cVector3 getDirection() const;
virtual cVector3 getPosition() const;
virtual cVector3 getVelocity() const;
virtual cVector3 getDirection() const;
virtual const float getRolloffFactor() const;
virtual const float getStrength() const;
virtual const float getMinDistance() const;
virtual const float getMaxDistance() const;
virtual float getRolloffFactor() const;
virtual float getStrength() const;
virtual float getMinDistance() const;
virtual float getMaxDistance() const;
virtual const float getPitch() const;
virtual const float getVolume() const;
virtual const float getMinVolume() const;
virtual const float getMaxVolume() const;
virtual bool isRelative() const;
virtual float calculateGain() const;
virtual const float getInnerConeAngle() const;
virtual const float getOuterConeAngle() const;
virtual const float getOuterConeVolume() const;
virtual float getPitch() const;
virtual float getVolume() const;
virtual float getMinVolume() const;
virtual float getMaxVolume() const;
virtual const float getDopplerStrength() const;
virtual const cVector3 getDopplerVelocity() const;
virtual float getInnerConeAngle() const;
virtual float getOuterConeAngle() const;
virtual float getOuterConeVolume() const;
virtual float getDopplerStrength() const;
virtual cVector3 getDopplerVelocity() const;
virtual void registerEventHandler(ISourceEventHandler* handler);
virtual void unRegisterEventHandler(ISourceEventHandler* handler);
virtual void unRegisterAllEventHandlers();
protected:
//! Mutex for thread synchronization
cAudioMutex Mutex;
//! Signals a event to all event handlers
void signalEvent(Events sevent);
//! The context that owns this source
IAudioDeviceContext* Context;
//! Holds the current volume
float Volume;
//! OpenAL source
ALuint Source;
ALenum oldState;
//! List of registered event handlers
cAudioVector<ISourceEventHandler*>::Type eventHandlerList;
};
class cAudioSource : public cAudioSourceBase {
public:
#if CAUDIO_EFX_ENABLED == 1
cAudioSource(IAudioDecoder* decoder, IAudioDeviceContext* context, cEFXFunctions* oALFunctions);
#else
cAudioSource(IAudioDecoder* decoder, IAudioDeviceContext* context);
#endif
~cAudioSource();
virtual bool play();
virtual bool play2d(const bool& toLoop = false);
virtual bool play3d(const cVector3& position, const float& soundstr = 1.0 , const bool& toLoop = false);
virtual void pause();
virtual void stop();
virtual void loop(const bool& toLoop);
virtual bool seek(const float& seconds, bool relative = false);
virtual bool setBuffer(IAudioBuffer* buffer) { return false; }
virtual IAudioBuffer *getBuffer() { return NULL; }
virtual float getTotalAudioTime();
virtual int getTotalAudioSize();
virtual int getCompressedAudioSize();
virtual float getCurrentAudioTime();
virtual int getCurrentAudioPosition();
virtual int getCurrentCompressedAudioPosition();
virtual bool update();
virtual bool isValid() const;
virtual bool isLooping() const;
virtual bool drop(); //! Override the default behavior
#if CAUDIO_EFX_ENABLED == 1
@ -126,31 +159,14 @@ namespace cAudio
#endif
private:
//! Mutex for thread synchronization
cAudioMutex Mutex;
//! Empties the current working buffer queue
void empty();
//! Checks for OpenAL errors and reports them
bool checkError() const;
//! Streams audio data from the decoder into a buffer
bool stream(ALuint buffer);
//! Signals a event to all event handlers
void signalEvent(Events sevent);
//! Converts our audio format enum to OpenAL's
ALenum convertAudioFormatEnum(AudioFormats format);
//! The context that owns this source
IAudioDeviceContext* Context;
//! Holds the current volume
float Volume;
//! Internal audio buffers
ALuint Buffers[CAUDIO_SOURCE_NUM_BUFFERS];
//! OpenAL source
ALuint Source;
ALenum oldState;
//! cAudio decoder being used to stream data
IAudioDecoder* Decoder;
@ -159,8 +175,10 @@ namespace cAudio
//! Stores whether the source is ready to be used
bool Valid;
//! List of registered event handlers
cAudioList<ISourceEventHandler*>::Type eventHandlerList;
//! position of first buffer in seconds
float BufferTime;
//! position of first buffer in bytes
int BufferPosition;
#if CAUDIO_EFX_ENABLED == 1
//! Holds pointers to all the EFX related functions

248
cAudio/Headers/cAudioStaticSource.h Executable file
View File

@ -0,0 +1,248 @@
#include "cAudioSource.h"
namespace cAudio
{
class cAudioBuffer : public IAudioBuffer
{
ALuint Buffer;
bool Valid;
float TotalTime;
public:
cAudioBuffer(IAudioDecoder *decoder)
{
Buffer = 0;
Valid = false;
TotalTime = decoder->getTotalTime();
decoder->setPosition(0, false);
const int totalSize = decoder->getTotalSize()&~1;
if (totalSize > 0)
{
cAudioVector<char>::Type data(totalSize, 0);
int totalread = 0;
unsigned errorcount = 0;
while (totalread < totalSize)
{
const int actualread = decoder->readAudioData(&data[totalread], totalSize - totalread);
if (actualread > 0) {
totalread += actualread;
} else if (actualread < 0) {
++errorcount;
getLogger()->logDebug("Audio Buffer", "Decoder returned an error: %i (%i of 3)", actualread, errorcount);
if(errorcount >= 3) {
break;
}
} else {
break;
}
}
if (totalread != totalSize) {
getLogger()->logError("Audio Buffer", "Stopped short");
}
alGenBuffers(1, &Buffer);
checkALError();
const ALsizei freq = decoder->getFrequency();
const ALenum format = convertAudioFormatEnum(decoder->getFormat());
getLogger()->logDebug("Audio Buffer", "Buffered %d bytes of data into buffer %d at %d hz.", totalread, (int)Buffer, (int)freq);
alBufferData(Buffer, format, &data[0], data.size(), freq);
checkALError();
Valid = true;
}
}
~cAudioBuffer()
{
if (Valid)
{
alDeleteBuffers(1, &Buffer);
}
}
bool isValid() const { return Valid; }
unsigned getBuffer() const { return Buffer; }
int getChannels() const
{
ALint channels = 0;
alGetBufferi(Buffer, AL_CHANNELS, &channels);
return channels;
}
int getTotalAudioSize() const
{
ALint size = -1;
alGetBufferi(Buffer, AL_SIZE, &size);
return size;
}
float getTotalAudioTime() const { return TotalTime; }
};
class cAudioStaticSource : public cAudioSourceBase
{
IAudioBuffer* Buffer;
public:
cAudioStaticSource(IAudioBuffer* buffer, IAudioDeviceContext* context)
: cAudioSourceBase(context), Buffer(NULL)
{
setBuffer(buffer);
}
~cAudioStaticSource()
{
if (Buffer)
Buffer->drop();
}
bool setBuffer(IAudioBuffer* buffer)
{
if (isPlaying())
stop();
if (Buffer)
Buffer->drop();
Buffer = buffer;
if (Buffer) {
Buffer->grab();
alSourcei(Source, AL_BUFFER, Buffer->getBuffer());
checkALError();
}
return true;
}
IAudioBuffer *getBuffer()
{
return Buffer;
}
bool play()
{
alSourcePlay(Source);
checkALError();
getLogger()->logDebug("Audio Static Source", "Source playing.");
signalEvent(ON_PLAY);
oldState = AL_PLAYING;
return true;
}
bool play2d(const bool& toLoop)
{
alSourcei(Source, AL_SOURCE_RELATIVE, true);
alSourcei(Source, AL_LOOPING, toLoop);
checkALError();
return play();
}
bool play3d(const cVector3& position, const float& soundstr, const bool& toLoop)
{
alSourcei(Source, AL_SOURCE_RELATIVE, false);
alSourcei(Source, AL_LOOPING, toLoop);
checkALError();
setPosition(position);
setStrength(soundstr);
return play();
}
void pause()
{
alSourcePause(Source);
checkALError();
getLogger()->logDebug("Audio Static Source", "Source paused.");
signalEvent(ON_PAUSE);
oldState = AL_PAUSED;
}
void stop()
{
alSourceStop(Source);
alSourceRewind(Source);
checkALError();
getLogger()->logDebug("Audio Static Source", "Source stopped.");
signalEvent(ON_STOP);
oldState = AL_STOPPED;
}
void loop(const bool& toLoop)
{
alSourcei(Source, AL_LOOPING, toLoop);
checkALError();
}
bool seek(const float& seconds, bool relative)
{
float start = relative ? getCurrentAudioTime() : 0.f;
alSourcef(Source, AL_SEC_OFFSET, start + seconds);
checkALError();
return true;
}
float getTotalAudioTime() { return Buffer ? Buffer->getTotalAudioTime() : 0.f; }
int getTotalAudioSize() { return Buffer ? Buffer->getTotalAudioSize() : 0; }
int getCompressedAudioSize() { return -1; }
float getCurrentAudioTime()
{
float time = -1;
alGetSourcef(Source, AL_SEC_OFFSET, &time);
return time;
}
int getCurrentAudioPosition()
{
int offset = -1;
alGetSourcei(Source, AL_BYTE_OFFSET, &offset);
return offset;
}
int getCurrentCompressedAudioPosition() { return -1; }
bool update()
{
if(isValid() || isPlaying()) {
signalEvent(ON_UPDATE);
}
ALenum state;
alGetSourcei(Source, AL_SOURCE_STATE, &state);
checkALError();
if(state == AL_STOPPED && oldState != state)
{
getLogger()->logDebug("Audio Static Source", "Source stopped.");
signalEvent(ON_STOP);
oldState = state;
}
return state != AL_STOPPED;
}
bool isValid() const
{
return Buffer ? Buffer->isValid() : false;
}
bool isLooping() const
{
ALint looping = false;
alGetSourcei(Source, AL_LOOPING, &looping);
return looping == AL_TRUE;
}
#if CAUDIO_EFX_ENABLED == 1
virtual unsigned int getNumEffectSlotsAvailable() const { return 0; }
virtual bool attachEffect(unsigned int slot, IEffect* effect) { return false; }
virtual void removeEffect(unsigned int slot) {}
virtual bool attachFilter(IFilter* filter) { return false; }
virtual void removeFilter() {}
#endif
};
}

6
cAudio/Headers/cMutex.h
View File

@ -7,9 +7,7 @@
#include "cAudioDefines.h"
#if CAUDIO_MAKE_THREAD_SAFE == 1
#ifdef CAUDIO_PLATFORM_WIN
#include <windows.h> //Basic windows include
#else
#ifndef CAUDIO_PLATFORM_WIN
#include <pthread.h> //Assumed linux system
#endif
#endif
@ -61,4 +59,4 @@ namespace cAudio
protected:
cAudioMutex* Mutex;
};
};
};

35
cAudio/Headers/cOpenALDeviceContext.h
View File

@ -4,14 +4,13 @@
#pragma once
#include <al.h>
#include <alc.h>
#include "IAudioDeviceContext.h"
#include "cMemoryOverride.h"
#include "cMutex.h"
#include "cAudioEffects.h"
#include "cOpenALUtil.h"
namespace cAudio
{
class cOpenALDeviceContext : public IAudioDeviceContext, public cMemoryOverride
@ -26,30 +25,30 @@ namespace cAudio
virtual IAudioEffects* getEffects() const;
ALCcontext* getOpenALContext() const;
private:
//! Check for OpenAL errors
bool checkError();
//! Mutex for thread synchronization
private:
//! Check for OpenAL errors
bool checkError();
//! Mutex for thread synchronization
cAudioMutex Mutex;
//! An OpenAL context pointer
ALCcontext* Context;
//! An OpenAL device pointer
//! An OpenAL context pointer
ALCcontext* Context;
//! An OpenAL device pointer
ALCdevice* Device;
IAudioManager* AudioManager;
bool Initialized;
//! Holds whether EFX is supported
//! Holds whether EFX is supported
bool EFXSupported;
#if CAUDIO_EFX_ENABLED == 1
//! Interface for audio effects
cAudioEffects initEffects;
#if CAUDIO_EFX_ENABLED == 1
//! Interface for audio effects
cAudioEffects initEffects;
#endif
};
}
}

69
cAudio/Headers/cOpenALUtil.h Executable file
View File

@ -0,0 +1,69 @@
#ifndef CAUDIO_COPENALUTIL_H
#define CAUDIO_COPENALUTIL_H
#include "cAudio.h"
#if !defined(CAUDIO_PLATFORM_LINUX)
#include <OpenAL/al.h>
#include <OpenAL/alc.h>
#else
#include <AL/al.h>
#include <AL/alc.h>
#endif
#if DEBUG
#ifndef __func__
#define __func__ __FUNCTION__
#endif
#define checkALError() checkALErrorInternal(__FILE__, __func__, __LINE__)
#else
#define checkALError() (false)
#endif
namespace cAudio {
//! Checks for OpenAL errors and reports them
inline bool checkALErrorInternal(const char* file, const char *func, int line)
{
ALenum error = AL_NO_ERROR;
bool anyError = false;
while ((error = alGetError()) != AL_NO_ERROR)
{
const char* errorString = alGetString(error);
if(error == AL_OUT_OF_MEMORY) {
getLogger()->logCritical("Audio Source", "OpenAL Error: %s:%d:%s, %s.", file, line, func, errorString);
} else if (error == -1) {
// this occurs randomly and relatively freqently with Apple's OpenAL and does not seem to cause serious problems.
getLogger()->logWarning("Audio Source", "OpenAL Warning %s:%d:%s, %s.", file, line, func, errorString);
} else {
getLogger()->logError("Audio Source", "OpenAL Error: %s:%d:%s, %s.", file, line, func, errorString);
}
anyError = true;
}
return anyError;
}
//! Converts our audio format enum to OpenAL's
inline ALenum 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;
};
}
}
#endif

2
cAudio/Headers/cPluginManager.h
View File

@ -13,8 +13,6 @@
#ifdef CAUDIO_COMPILE_WITH_PLUGIN_SUPPORT
#ifdef CAUDIO_PLATFORM_WIN
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
struct HINSTANCE__;
typedef struct HINSTANCE__* hInstance;

11
cAudio/Headers/cThread.h
View File

@ -8,11 +8,10 @@
#include "cAudioDefines.h"
#include "IThread.h"
#ifdef CAUDIO_PLATFORM_WIN
#include <windows.h> //Basic windows includes
#include <process.h>
#else
#include <pthread.h> //Assumed linux system
#ifdef CAUDIO_PLATFORM_WIN
#include <process.h>
#else
#include <pthread.h> //Assumed linux system
#endif
namespace cAudio
@ -44,4 +43,4 @@ namespace cAudio
bool IsInit;
bool Loop;
};
};
};

6
cAudio/Headers/cUtils.h
View File

@ -9,8 +9,6 @@
#include "cAudioString.h"
#ifdef CAUDIO_PLATFORM_WIN
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# include <direct.h>
# include <io.h>
#endif
@ -25,14 +23,14 @@ namespace cAudio
{
//! Grabs the current extention of a given string.
static cAudioString getExt(const cAudioString& filename)
inline cAudioString getExt(const cAudioString& filename)
{
if(filename.find_last_of(_CTEXT(".")) == cAudioString::npos) return filename;
return filename.substr(filename.find_last_of(_CTEXT(".")) + 1, filename.length()-filename.find_last_of(_CTEXT("."))-1);
}
//! Returns a list of files/directories in the supplied directory. Used internally for auto-installation of plugins.
static cAudioVector<cAudioString>::Type getFilesInDirectory(cAudioString path)
inline cAudioVector<cAudioString>::Type getFilesInDirectory(cAudioString path)
{
cAudioVector<cAudioString>::Type FileList;
#ifdef CAUDIO_PLATFORM_WIN

2
cAudio/include/EAudioFormats.h
View File

@ -14,4 +14,4 @@ namespace cAudio
EAF_16BIT_MONO,
EAF_16BIT_STEREO
};
};
};

2
cAudio/include/IAudioCapture.h
View File

@ -150,4 +150,4 @@ namespace cAudio
char* buffer;
size_t length;
};
};
};

1
cAudio/include/IAudioDeviceContext.h
View File

@ -17,5 +17,6 @@ namespace cAudio
virtual void update() = 0;
virtual IAudioManager* getAudioManager() const = 0;
virtual IAudioEffects* getEffects() const = 0;
virtual ~IAudioDeviceContext(){}
};
}

1
cAudio/include/IAudioDeviceList.h
View File

@ -24,5 +24,6 @@ namespace cAudio
virtual cAudioString getDeviceDescription(unsigned int idx) = 0;
virtual cAudioString getDefaultDeviceName() = 0;
virtual bool isSupported() = 0;
virtual ~IAudioDeviceList(){}
};
}

2
cAudio/include/IAudioEffects.h
View File

@ -234,4 +234,4 @@ namespace cAudio
};
};
#endif
#endif

30
cAudio/include/IAudioManager.h
View File

@ -15,8 +15,10 @@
namespace cAudio
{
class IAudioSource;
class IAudioBuffer;
class IAudioDecoderFactory;
class AudioCaptureBuffer;
class cAudioMutex;
//! Interface for the playback capabilities of cAudio.
class IAudioManager
@ -89,6 +91,18 @@ namespace cAudio
//! Get the master volume.
virtual float getMasterVolume() const = 0;
//! Set Speed of Sound (for doppler computations)
virtual void setSpeedOfSound(float speed) = 0;
//! Get Speed of Sound (for doppler computations)
virtual float getSpeedOfSound() const = 0;
//! Set Doppler Factor
virtual void setDopplerFactor(float factor) const = 0;
//! Get Doppler Factor
virtual float getDopplerFactor() const = 0;
//! Stops all playing sounds.
virtual void stopAllSounds() = 0;
@ -133,6 +147,20 @@ namespace cAudio
*/
virtual IAudioSource* createFromAudioBuffer(const char* name, AudioCaptureBuffer* pBiffer, unsigned int frequency, AudioFormats format) = 0;
//! Creates a Audio Sample using the highest priority data source that has the referenced filename
/**
\param filename: Path to the file to load audio data from.
\return A pointer to an Audio Source or NULL if creation failed.
*/
virtual IAudioBuffer* createBuffer(const char* filename) = 0;
//! Creates an Audio Source from an Audio Buffer object (see createAudioBuffer())
/**
\param buffer: The buffer to play, or NULL to create an empty static source
\return A pointer to an Audio Source or NULL if creation failed.
*/
virtual IAudioSource* createStatic(IAudioBuffer* buffer) = 0;
//! Register an Audio Decoder.
/**
\param factory: Pointer to the factory instance to use.
@ -207,6 +235,8 @@ namespace cAudio
//! Returns the interface for the listener.
virtual IListener* getListener() = 0;
virtual cAudioMutex *getMutex() = 0;
#if CAUDIO_EFX_ENABLED == 1
//! Returns the interface for audio effects.
virtual IAudioEffects* getEffects() = 0;

2
cAudio/include/IAudioPlugin.h
View File

@ -52,4 +52,4 @@ namespace cAudio
\param capture: Pointer to the soon to be destroyed capture interface. */
virtual void onDestoryAudioCapture(IAudioCapture* capture) { }
};
};
};

75
cAudio/include/IAudioSource.h
View File

@ -14,6 +14,20 @@
namespace cAudio
{
//! interface for a sample (audio buffer): completely loaded into memory, shareable across sources
class IAudioBuffer : public IRefCounted
{
public:
virtual ~IAudioBuffer() {}
virtual bool isValid() const = 0;
virtual unsigned getBuffer() const = 0;
virtual int getChannels() const = 0;
virtual int getTotalAudioSize() const = 0;
virtual float getTotalAudioTime() const = 0;
};
//! Interface for a single audio source, which allow you to manipulate sound sources (speakers) in 2D or 3D space.
class IAudioSource : public IRefCounted
{
@ -39,7 +53,7 @@ namespace cAudio
\param toLoop: Whether to loop (restart) the audio when the end is reached.
\return True if the source is playing, false if not. */
virtual bool play3d(const cVector3& position, const float& soundstr = 1.0 , const bool& toLoop = false) = 0;
//! Pauses playback of the sound source.
virtual void pause() = 0;
@ -57,6 +71,15 @@ namespace cAudio
\return True on success, False if the codec does not support seeking. */
virtual bool seek(const float& seconds, bool relative = false) = 0;
//! Change the audio buffer associated with the source
/** Note: Only supported on sources created with createFromBuffer() or createForBuffer()
\return True on success, False if the sample does not support setting buffers or is currently playing */
virtual bool setBuffer(IAudioBuffer* buffer) = 0;
//! Get the audio buffer associated with the source
/** \return buffer on succes, NULL if no buffer or sample is streaming */
virtual IAudioBuffer *getBuffer() = 0;
//! Returns the total amount of time in the audio stream. See IAudioDecoder for details.
virtual float getTotalAudioTime() = 0;
@ -79,19 +102,19 @@ namespace cAudio
virtual bool update() = 0;
//! Returns if the source is ready to be used.
virtual const bool isValid() const = 0;
virtual bool isValid() const = 0; //
//! Returns if the source is playing.
virtual const bool isPlaying() const = 0;
virtual bool isPlaying() const = 0;
//! Returns if the source is paused.
virtual const bool isPaused() const = 0;
virtual bool isPaused() const = 0;
//! Returns if the source is stopped.
virtual const bool isStopped() const = 0;
virtual bool isStopped() const = 0;
//! Returns if the source is looping.
virtual const bool isLooping() const = 0;
virtual bool isLooping() const = 0;
//! Sets the position of the source in 3D space.
/**
@ -183,52 +206,58 @@ namespace cAudio
virtual void move(const cVector3& position) = 0;
//! Returns the audio objects position
virtual const cVector3 getPosition() const = 0;
virtual cVector3 getPosition() const = 0;
//! Returns the audio objects velocity
virtual const cVector3 getVelocity() const = 0;
virtual cVector3 getVelocity() const = 0;
//! Returns the audio objects direction
virtual const cVector3 getDirection() const = 0;
virtual cVector3 getDirection() const = 0;
//! Returns the factor used in attenuating the source over distance
virtual const float getRolloffFactor() const = 0;
virtual float getRolloffFactor() const = 0;
//! Returns the strength of the source
virtual const float getStrength() const = 0;
virtual float getStrength() const = 0;
//! Returns the distance from the source where attenuation will begin
virtual const float getMinDistance() const = 0;
virtual float getMinDistance() const = 0;
//! Returns the distance from the source where attenuation will stop
virtual const float getMaxDistance() const = 0;
virtual float getMaxDistance() const = 0;
//! Return true for 2d sounds, false for 3d sounds
virtual bool isRelative() const = 0;
//! Return gain, taking into account volume as well as distance attenuation
virtual float calculateGain() const = 0;
//! Returns the pitch of the source
virtual const float getPitch() const = 0;
virtual float getPitch() const = 0;
//! Returns the source volume before attenuation and other effects
virtual const float getVolume() const = 0;
virtual float getVolume() const = 0;
//! Returns the minimum volume that the source can be attenuated to
virtual const float getMinVolume() const = 0;
virtual float getMinVolume() const = 0;
//! Returns the maximum volume that the source can achieve
virtual const float getMaxVolume() const = 0;
virtual float getMaxVolume() const = 0;
//! Returns the angle of the inner sound cone of the source
virtual const float getInnerConeAngle() const = 0;
virtual float getInnerConeAngle() const = 0;
//! Returns the angle of the outer sound cone of the source
virtual const float getOuterConeAngle() const = 0;
virtual float getOuterConeAngle() const = 0;
//! Returns how much the volume of the source is scaled in the outer cone
virtual const float getOuterConeVolume() const = 0;
virtual float getOuterConeVolume() const = 0;
//! Returns the doppler strength, which enhances or diminishes the doppler effect
virtual const float getDopplerStrength() const = 0;
virtual float getDopplerStrength() const = 0;
//! Returns the override for the doppler velocity vector
virtual const cVector3 getDopplerVelocity() const = 0;
virtual cVector3 getDopplerVelocity() const = 0;
//! Registers a new event handler to this source
/**
@ -272,4 +301,4 @@ namespace cAudio
protected:
private:
};
};
};

1
cAudio/include/ICaptureEventHandler.h
View File

@ -29,5 +29,6 @@ namespace cAudio
//! This function is called whe user requests data from the capture buffer.
virtual void onUserRequestBuffer() = 0;
virtual ~ICaptureEventHandler(){}
};
};

2
cAudio/include/ILogReceiver.h
View File

@ -33,7 +33,7 @@ namespace cAudio
{
public:
ILogReceiver() { }
~ILogReceiver() { }
virtual ~ILogReceiver() { }
//! Called on every logged message that is greater than or equal to the minimum log level.
/**

2
cAudio/include/IManagerEventHandler.h
View File

@ -27,6 +27,8 @@ namespace cAudio
//! This function is called when a data source is registered.
virtual void onDataSourceRegister() = 0;
virtual ~IManagerEventHandler(){}
};
};

2
cAudio/include/IMemoryProvider.h
View File

@ -28,5 +28,7 @@ namespace cAudio
//! Returns the largest possible single allocation that can be made.
virtual size_t getMaxAllocationSize() = 0;
virtual ~IMemoryProvider() {}
};
};

2
cAudio/include/IPluginManager.h
View File

@ -15,7 +15,7 @@ namespace cAudio
{
public:
IPluginManager() { }
~IPluginManager() { }
virtual ~IPluginManager() { }
//! Installs a plugin using a statically linked plugin implementation.
/**

12
cAudio/include/ISourceEventHandler.h
View File

@ -11,19 +11,21 @@ namespace cAudio
{
public:
//! This function is called when a source updates its buffers.
virtual void onUpdate() = 0;
virtual void onUpdate(){}
//! This function is called when a source is released and soon to be deleted.
virtual void onRelease() = 0;
virtual void onRelease(){}
//! This function is called when a source starts playing.
virtual void onPlay() = 0;
virtual void onPlay(){}
//! This function is called when a source stopped playback.
virtual void onStop() = 0;
virtual void onStop(){}
//! This function is called when a source is paused.
virtual void onPause() = 0;
virtual void onPause(){}
virtual ~ISourceEventHandler(){}
};
};

4
cAudio/include/IThread.h
View File

@ -13,11 +13,13 @@ namespace cAudio
virtual void join() = 0;
virtual void shutdown() = 0;
virtual bool isRunning() = 0;
virtual ~IThread(){}
};
class IThreadWorker
{
public:
virtual void run() = 0;
virtual ~IThreadWorker(){}
};
}
}

4
cAudio/include/cAudioMemory.h
View File

@ -7,7 +7,7 @@
#include "cAudioDefines.h"
#include "IMemoryProvider.h"
#ifdef CAUDIO_DEBUG
#if 0 /* defined(CAUDIO_DEBUG) */
#define CAUDIO_NEW new (__FILE__, __LINE__, __FUNCTION__)
#define CAUDIO_DELETE delete
#define CAUDIO_MALLOC(size) cAudio::getMemoryProvider()->Allocate(size, __FILE__, __LINE__, __FUNCTION__)
@ -25,4 +25,4 @@ namespace cAudio
/** Used by cAudio for all allocations of memory
\return A pointer to the memory provider */
CAUDIO_API IMemoryProvider* getMemoryProvider();
};
};

17
cAudio/include/cAudioPlatform.h
View File

@ -47,3 +47,20 @@
# define CAUDIO_COMPILER_MINGW
# endif
#endif
#ifdef CAUDIO_PLATFORM_WIN
#ifndef NOMINMAX
#define NOMINMAX
#endif
#define WIN32_LEAN_AND_MEAN
#define _CRT_SECURE_NO_WARNINGS 1
#if defined(_DEBUG) && !defined(DEBUG)
#define DEBUG _DEBUG
#endif
#ifndef DEBUG
#define _SECURE_SCL 0
#define _HAS_ITERATOR_DEBUGGING 0
#endif
#include <windows.h> //Basic windows includes
#endif

2
cAudio/include/cAudioSleep.h
View File

@ -11,4 +11,4 @@ namespace cAudio
//! Causes the current thread to give up control for a certain duration.
/** \param ms: amount of miliseconds to sleep */
CAUDIO_API void cAudioSleep(unsigned int ms);
};
};

78
cAudio/include/cAudioString.h
View File

@ -13,8 +13,6 @@
#include <stdlib.h>
#ifdef CAUDIO_PLATFORM_WIN
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# include <direct.h>
# include <io.h>
#endif
@ -26,12 +24,12 @@ namespace cAudio
# define _CTEXT(x) L ## x
# define cstrcmp wcscmp
# define cAudioChar wchar_t
# define cfopen _wfopen
# define cfopen(N, M) _wfopen((N).c_str(), L ## M)
#else
# define _CTEXT(x) x
# define cstrcmp strcmp
# define cAudioChar char
# define cfopen fopen
# define cfopen(N, M) fopen(toUTF8(N), M)
#endif
#if CAUDIO_REROUTE_STRING_ALLOCATIONS == 1
@ -46,55 +44,13 @@ namespace cAudio
#if defined(CAUDIO_PLATFORM_WIN)
static const TCHAR* toWINSTR(const char* str)
{
#if (defined(UNICODE) || defined(_UNICODE))
static int id = 0;
static wchar_t buffer[8][1024];
id = ++id & 0x7;
int slen = strlen(str);
int buff_size = MultiByteToWideChar(CP_UTF8, 0, str, (int)(slen < 1023 ? slen : 1023), buffer[id], 1023);
buffer[id][buff_size] = 0;
buffer[id][1023] = 0;
return buffer[id];
#else
return str;
#endif
}
static const TCHAR* toWINSTR(const wchar_t* str)
{
#if (defined(UNICODE) || defined(_UNICODE))
return str;
#else
static int id = 0;
static char buffer[8][1024];
id = ++id & 0x7;
int slen = wcslen(str);
int buff_size = WideCharToMultiByte(CP_UTF8, 0, str, (int)(slen < 1023 ? slen : 1023), buffer[id], 1023, 0, false);
buffer[id][buff_size] = 0;
buffer[id][1023] = 0;
return buffer[id];
#endif
}
static wchar_t* charToWChar(const char* text)
{
size_t size = strlen(text) + 1;
wchar_t* wa = new wchar_t[size];
mbstowcs(wa, text, size);
return wa;
}
static const char* toUTF8(const cAudioString& str)
{
static int id = 0;
static char buffer[8][1024];
id = ++id & 0x7;
int buff_size = WideCharToMultiByte(CP_UTF8, 0, charToWChar(str.c_str()), (int)(str.size() < 1023 ? str.size() : 1023), buffer[id], 1023, 0, false);
int buff_size = WideCharToMultiByte(CP_UTF8, 0, str.c_str(), (int)(str.size() < 1023 ? str.size() : 1023), buffer[id], 1023, 0, false);
buffer[id][buff_size] = 0;
buffer[id][1023] = 0;
return buffer[id];
@ -102,34 +58,20 @@ namespace cAudio
static cAudioString fromUTF8(const char* str)
{
wchar_t* buffer = 0;
int buff_size = MultiByteToWideChar(CP_UTF8, 0, str, (int)strlen(str), 0, 0);
if (buff_size == 0)
return cAudioString();
buffer = new wchar_t[buff_size + 1];
memset((void*)buffer, 0, sizeof(wchar_t) * (buff_size + 1));
MultiByteToWideChar(CP_UTF8, 0, str, (int)strlen(str), buffer, buff_size);
char* convert = new char[buff_size+1];
wcstombs(convert, buffer, sizeof(wchar_t) * (buff_size + 1));
cAudioString s(convert);
delete[] buffer;
int str_len = (int)strlen(str);
int buf_size = MultiByteToWideChar(CP_UTF8, 0, str, str_len, 0, 0);
cAudioString s(buf_size, L'\0');
MultiByteToWideChar(CP_UTF8, 0, str, str_len, &s[0], buf_size);
return s;
}
#else
static const char* toWINSTR(const char* str)
{
return str;
}
static const char* toUTF8(const cAudioString& str)
inline const char* toUTF8(const cAudioString& str)
{
return str.c_str();
}
static cAudioString fromUTF8(const char* str)
inline cAudioString fromUTF8(const char* str)
{
return cAudioString(str);
}

2
cAudio/include/cSTLAllocator.h
View File

@ -62,7 +62,7 @@ namespace cAudio
pointer allocate( size_type count, typename std::allocator<void>::const_pointer ptr = 0 )
{
(void)ptr;
register size_type size = count*sizeof( T );
size_type size = count*sizeof( T );
pointer p = static_cast<pointer>(CAUDIO_MALLOC(size));
return p;
}

4
cAudio/include/cVector3.h
View File

@ -91,7 +91,7 @@ namespace cAudio
operator float*() { return &x; }
const float operator[] ( int i ) const { return ( ( float* ) &x ) [i]; }
float operator[] ( int i ) const { return ( ( float* ) &x ) [i]; }
float &operator[] ( int i ) { return ( ( float* ) &x ) [i]; }
@ -151,4 +151,4 @@ namespace cAudio
output[2] = z;
}
};
};
};

18
cAudio/src/cAudio.cpp
View File

@ -91,9 +91,6 @@ namespace cAudio
}
#endif
manager->unRegisterAllAudioDecoders();
manager->unRegisterAllDataSources();
manager->unRegisterAllEventHandlers();
manager->shutDown();
CAUDIO_DELETE manager;
@ -144,9 +141,6 @@ namespace cAudio
// Logger section
//---------------------------------------------------------------------------------------
static cLogger Logger;
static bool FirstTimeLogInit(false);
#if CAUDIO_COMPILE_WITH_CONSOLE_LOG_RECEIVER == 1
static cConsoleLogReceiver ConsoleLog;
#endif
@ -157,17 +151,19 @@ namespace cAudio
CAUDIO_API ILogger* getLogger()
{
if(!FirstTimeLogInit)
static cLogger* Logger = NULL;
if(!Logger)
{
FirstTimeLogInit = true;
Logger = new cLogger;
#if CAUDIO_COMPILE_WITH_CONSOLE_LOG_RECEIVER == 1
Logger.registerLogReceiver(&ConsoleLog, "Console");
Logger->registerLogReceiver(&ConsoleLog, "Console");
#endif
#if CAUDIO_COMPILE_WITH_FILE_LOG_RECEIVER == 1
Logger.registerLogReceiver(&FileLog,"File");
Logger->registerLogReceiver(&FileLog,"File");
#endif
}
return &Logger;
return Logger;
}
//---------------------------------------------------------------------------------------

20
cAudio/src/cAudioCapture.cpp
View File

@ -14,15 +14,15 @@
namespace cAudio
{
cAudioCapture::cAudioCapture() : Frequency(22050), Format(EAF_16BIT_MONO), InternalBufferSize(8192),
SampleSize(2), Ready(false), Capturing(false),
CaptureDevice(NULL), AudioThread(NULL)
cAudioCapture::cAudioCapture() : AudioThread(NULL), Frequency(22050), Format(EAF_16BIT_MONO),
InternalBufferSize(8192), SampleSize(2), Ready(false),
Capturing(false), CaptureDevice(NULL)
{
}
cAudioCapture::~cAudioCapture()
{
shutdown();
cAudioCapture::shutdown();
}
void cAudioCapture::run()
@ -315,7 +315,7 @@ namespace cAudio
case ON_INIT:
for(it; it != eventHandlerList.end(); it++){
for(; it != eventHandlerList.end(); it++){
(*it)->onInit();
}
@ -323,7 +323,7 @@ namespace cAudio
case ON_UPDATE:
for(it; it != eventHandlerList.end(); it++){
for(; it != eventHandlerList.end(); it++){
(*it)->onUpdate();
}
@ -331,7 +331,7 @@ namespace cAudio
case ON_RELEASE:
for(it; it != eventHandlerList.end(); it++){
for(; it != eventHandlerList.end(); it++){
(*it)->onRelease();
}
@ -339,7 +339,7 @@ namespace cAudio
case ON_BEGINCAPTURE:
for(it; it != eventHandlerList.end(); it++){
for(; it != eventHandlerList.end(); it++){
(*it)->onBeginCapture();
}
@ -348,7 +348,7 @@ namespace cAudio
case ON_ENDCAPTURE:
for(it; it != eventHandlerList.end(); it++){
for(; it != eventHandlerList.end(); it++){
(*it)->onEndCapture();
}
@ -356,7 +356,7 @@ namespace cAudio
case ON_USERREQUESTEDBUFFER:
for(it; it != eventHandlerList.end(); it++){
for(; it != eventHandlerList.end(); it++){
(*it)->onUserRequestBuffer();
}

144
cAudio/src/cAudioManager.cpp
View File

@ -5,6 +5,7 @@
#include "cAudioManager.h"
#include "cAudio.h"
#include "cAudioSource.h"
#include "cAudioStaticSource.h"
#include "cAudioPlatform.h"
#include "cAudioSleep.h"
#include "cUtils.h"
@ -22,7 +23,7 @@ namespace cAudio
{
cAudioManager::~cAudioManager()
{
shutDown();
cAudioManager::shutDown();
}
bool cAudioManager::initialize(const char* deviceName, int outputFrequency, int eaxEffectSlots)
@ -60,6 +61,10 @@ namespace cAudio
}
cAudioMutexBasicLock lock(Mutex);
unRegisterAllAudioDecoders();
unRegisterAllDataSources();
unRegisterAllEventHandlers();
releaseAllSources();
@ -78,20 +83,35 @@ namespace cAudio
void cAudioManager::update()
{
cAudioMutexBasicLock lock(Mutex);
size_t count = audioSources.size();
for(size_t i=0; i<count; i++)
{
IAudioSource* source = audioSources[i];
if (source->isValid())
{
source->update();
}
}
updateSources.clear();
{
cAudioMutexBasicLock lock(Mutex);
size_t count = audioSources.size();
for(size_t i=0; i<count; i++)
{
IAudioSource* source = audioSources[i];
if (source->isValid())
{
source->grab();
updateSources.push_back(source);
}
}
}
// not holding the mutex because this might take a while!
for (int i=0; i != updateSources.size(); i++)
{
IAudioSource *src = updateSources[i];
src->update();
src->drop();
}
cAudioMutexBasicLock lock(Mutex);
if (!managedAudioSources.empty())
{
count = managedAudioSources.size();
size_t count = managedAudioSources.size();
for(size_t i=0; i<count; i++)
{
IAudioSource* source = managedAudioSources[i];
@ -148,6 +168,9 @@ namespace cAudio
{
cAudioMutexBasicLock lock(Mutex);
IAudioSource* pAudioSrc = create("", filename, true);
if (!pAudioSrc)
return NULL;
if (!playLooped && !startPaused)
{
@ -212,6 +235,28 @@ namespace cAudio
return MasterVolume;
}
void cAudioManager::setSpeedOfSound(float speed)
{
alSpeedOfSound(speed);
checkALError();
}
float cAudioManager::getSpeedOfSound() const
{
return alGetFloat(AL_SPEED_OF_SOUND);
}
void cAudioManager::setDopplerFactor(float factor) const
{
alDopplerFactor(factor);
checkALError();
}
float cAudioManager::getDopplerFactor() const
{
return alGetFloat(AL_DOPPLER_FACTOR);
}
void cAudioManager::stopAllSounds()
{
cAudioMutexBasicLock lock(Mutex);
@ -225,7 +270,10 @@ namespace cAudio
IAudioSource* cAudioManager::createAudioSource(IAudioDecoder* decoder, const cAudioString& audioName, const cAudioString& dataSource)
{
if(decoder && decoder->isValid())
if (!decoder)
return NULL;
if(decoder->isValid())
{
#if CAUDIO_EFX_ENABLED == 1
IAudioSource* audio = CAUDIO_NEW cAudioSource(decoder, AudioContext, ((cAudioEffects*)getEffects())->getEFXInterface());
@ -248,11 +296,13 @@ namespace cAudio
audio->drop();
return NULL;
}
getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): Audio data could not be decoded by (.%s) decoder.", toUTF8(audioName), toUTF8(decoder->getType()));
getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): Audio data could not be decoded by (.%s) decoder.",
toUTF8(audioName), toUTF8(decoder->getType()));
decoder->drop();
return NULL;
}
IAudioSource* cAudioManager::create(const char* name, const char* filename, bool stream)
{
if(!Initialized) return NULL;
@ -284,8 +334,8 @@ namespace cAudio
if(audio != NULL)
return audio;
if(source)
source->drop();
//if(source)
// source->drop();
return NULL;
}
@ -358,6 +408,56 @@ namespace cAudio
return NULL;
}
IAudioBuffer* cAudioManager::createBuffer(const char* filename)
{
if(!Initialized) return NULL;
cAudioMutexBasicLock lock(Mutex);
cAudioString path = fromUTF8(filename);
cAudioString ext = getExt(path);
IAudioDecoderFactory* factory = getAudioDecoderFactory(toUTF8(ext));
if(!factory) {
getLogger()->logError("AudioManager", "Failed to create Audio Buffer: No decoder could be found for (.%s).", toUTF8(ext));
return NULL;
}
for(size_t i=0; i<dataSourcePriorityList.size(); ++i)
{
const cAudioString dataSourceName = dataSourcePriorityList[i].second;
IDataSourceFactory* dataFactory = datasourcemap[dataSourceName];
if(dataFactory)
{
IDataSource* source = dataFactory->CreateDataSource(filename, false);
if(source && source->isValid())
{
IAudioDecoder* decoder = factory->CreateAudioDecoder(source);
source->drop();
IAudioBuffer* buffer = CAUDIO_NEW cAudioBuffer(decoder);
if(buffer != NULL)
return buffer;
//if(source)
// source->drop();
return NULL;
}
}
}
return NULL;
}
IAudioSource* cAudioManager::createStatic(IAudioBuffer* buffer)
{
if(!Initialized) return NULL;
// FIXME save a reference?
IAudioSource *audio = CAUDIO_NEW cAudioStaticSource(buffer, AudioContext);
return audio;
}
bool cAudioManager::registerAudioDecoder(IAudioDecoderFactory* factory, const char* extension)
{
cAudioMutexBasicLock lock(Mutex);
@ -504,7 +604,7 @@ namespace cAudio
{
case ON_INIT:
for(it; it != eventHandlerList.end(); it++)
for(; it != eventHandlerList.end(); it++)
{
(*it)->onInit();
}
@ -513,7 +613,7 @@ namespace cAudio
case ON_UPDATE:
for(it; it != eventHandlerList.end(); it++)
for(; it != eventHandlerList.end(); it++)
{
(*it)->onUpdate();
}
@ -522,7 +622,7 @@ namespace cAudio
case ON_RELEASE:
for(it; it != eventHandlerList.end(); it++)
for(; it != eventHandlerList.end(); it++)
{
(*it)->onRelease();
}
@ -531,7 +631,7 @@ namespace cAudio
case ON_SOURCECREATE:
for(it; it != eventHandlerList.end(); it++)
for(; it != eventHandlerList.end(); it++)
{
(*it)->onSourceCreate();
}
@ -540,7 +640,7 @@ namespace cAudio
case ON_DECODERREGISTER:
for(it; it != eventHandlerList.end(); it++)
for(; it != eventHandlerList.end(); it++)
{
(*it)->onDecoderRegister();
}
@ -549,7 +649,7 @@ namespace cAudio
case ON_DATASOURCEREGISTER:
for(it; it != eventHandlerList.end(); it++)
for(; it != eventHandlerList.end(); it++)
{
(*it)->onDataSourceRegister();
}

8
cAudio/src/cAudioSleep.cpp
View File

@ -1,12 +1,10 @@
// Copyright (c) 2008-2011 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones, Murat (wolfmanfx) Sari
// This file is part of the "cAudio Engine"
// Copyright (c) 2008-2011 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones, Murat (wolfmanfx) Sari
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h
#include "cAudioPlatform.h"
#ifdef CAUDIO_PLATFORM_WIN
#include <windows.h> //Basic windows include for Sleep();
#else
#ifndef CAUDIO_PLATFORM_WIN
#include <unistd.h> //Assumed linux system, include for usleep()
#include <time.h>
#endif //If you need to support another platform, simply add a define for it

525
cAudio/src/cAudioSource.cpp
View File

@ -9,26 +9,56 @@
#include "cEffect.h"
#include "cAudioSleep.h"
#include <string.h>
#include <algorithm>
#if CAUDIO_EFX_ENABLED == 1
#include "cOpenALDeviceContext.h"
#endif
namespace
{
// return buffer length in seconds
ALfloat GetBufferLength(ALuint buffer)
{
ALint size, bits, channels, freq;
alGetBufferi(buffer, AL_SIZE, &size);
alGetBufferi(buffer, AL_BITS, &bits);
alGetBufferi(buffer, AL_CHANNELS, &channels);
alGetBufferi(buffer, AL_FREQUENCY, &freq);
if(alGetError() != AL_NO_ERROR || !bits || !channels || !freq)
return -1.0f;
return (ALfloat)((ALuint)size/channels/(bits/8)) / (ALfloat)freq;
}
ALint GetBufferSize(ALuint buffer)
{
ALint size;
alGetBufferi(buffer, AL_SIZE, &size);
return size;
}
}
namespace cAudio
{
#if CAUDIO_EFX_ENABLED == 1
cAudioSource::cAudioSource(IAudioDecoder* decoder, IAudioDeviceContext* context, cEFXFunctions* oALFunctions)
: Context(context), Source(0), Volume(1.0), Decoder(decoder), Loop(false), Valid(false),
: cAudioSourceBase(context), Decoder(decoder), Loop(false), Valid(false),
EFX(oALFunctions), Filter(NULL), EffectSlotsAvailable(0), LastFilterTimeStamp(0)
#else
cAudioSource::cAudioSource(IAudioDecoder* decoder, IAudioDeviceContext* context)
: Context(context), Source(0), Volume(1.0), Decoder(decoder), Loop(false), Valid(false)
: cAudioSourceBase(context), Decoder(decoder), Loop(false), Valid(false)
#endif
{
cAudioMutexBasicLock lock(Mutex);
for(int i=0; i<CAUDIO_SOURCE_NUM_BUFFERS; ++i)
BufferPosition = 0;
BufferTime = 0;
for(int i=0; i<CAUDIO_SOURCE_NUM_BUFFERS; ++i) {
Buffers[i] = 0;
}
#if CAUDIO_EFX_ENABLED == 1
for(int i=0; i<CAUDIO_SOURCE_MAX_EFFECT_SLOTS; ++i)
@ -41,16 +71,14 @@ namespace cAudio
if(Decoder)
Decoder->grab();
//Generates 3 buffers for the ogg file
alGenBuffers(CAUDIO_SOURCE_NUM_BUFFERS, Buffers);
bool state = !checkError();
if(state)
{
//Creates one source to be stored.
alGenSources(1, &Source);
state = !checkError();
setVolume(Volume);
}
ALboolean state = alIsSource(Source);
if (state)
{
//Generates 3 buffers for the ogg file
alGenBuffers(CAUDIO_SOURCE_NUM_BUFFERS, Buffers);
state = !checkALError();
}
#if CAUDIO_EFX_ENABLED == 1
Valid = state && (Decoder != NULL) && (Context != NULL) && (EFX != NULL);
@ -84,19 +112,36 @@ namespace cAudio
//Stops the audio Source
alSourceStop(Source);
checkALError();
empty();
//Deletes the source
alDeleteSources(1, &Source);
alSourcei(Source, AL_BUFFER, 0);
//deletes the last filled buffer
alDeleteBuffers(CAUDIO_SOURCE_NUM_BUFFERS, Buffers);
checkError();
checkALError();
if(Decoder) {
Decoder->drop();
Decoder = NULL;
}
}
cAudioSourceBase::cAudioSourceBase(IAudioDeviceContext* context) :
Context(context), Volume(1.f), Source(0)
{
alGenSources(1, &Source);
checkALError();
setVolume(Volume);
}
cAudioSourceBase::~cAudioSourceBase()
{
alSourceStop(Source);
checkALError();
alDeleteSources(1, &Source);
checkALError();
getLogger()->logDebug("Audio Source", "Audio source released.");
signalEvent(ON_RELEASE);
if(Decoder)
Decoder->drop();
unRegisterAllEventHandlers();
}
@ -119,7 +164,9 @@ namespace cAudio
int queueSize = 0;
//Purges all buffers from the source
alSourcei(Source, AL_BUFFER, 0);
checkError();
BufferPosition = Decoder->getCurrentPosition();
BufferTime = Decoder->getCurrentTime();
checkALError();
for(int u = 0; u < CAUDIO_SOURCE_NUM_BUFFERS; u++)
{
int val = stream(Buffers[u]);
@ -133,7 +180,7 @@ namespace cAudio
}
//Stores the sources 3 buffers to be used in the queue
alSourceQueueBuffers(Source, queueSize, Buffers);
checkError();
checkALError();
}
#if CAUDIO_EFX_ENABLED == 1
updateFilter();
@ -141,7 +188,7 @@ namespace cAudio
updateEffect(i);
#endif
alSourcePlay(Source);
checkError();
checkALError();
getLogger()->logDebug("Audio Source", "Source playing.");
signalEvent(ON_PLAY);
oldState = AL_PLAYING;
@ -154,7 +201,7 @@ namespace cAudio
alSourcei(Source, AL_SOURCE_RELATIVE, true);
loop(toLoop);
bool state = play();
checkError();
checkALError();
return state;
}
@ -166,7 +213,7 @@ namespace cAudio
setStrength(soundstr);
loop(toLoop);
bool state = play();
checkError();
checkALError();
return state;
}
@ -174,7 +221,7 @@ namespace cAudio
{
cAudioMutexBasicLock lock(Mutex);
alSourcePause(Source);
checkError();
checkALError();
getLogger()->logDebug("Audio Source", "Source paused.");
signalEvent(ON_PAUSE);
oldState = AL_PAUSED;
@ -196,7 +243,7 @@ namespace cAudio
//Resets the audio to the beginning
Decoder->setPosition(0, false);
checkError();
checkALError();
getLogger()->logDebug("Audio Source", "Source stopped.");
signalEvent(ON_STOP);
oldState = AL_STOPPED;
@ -215,6 +262,16 @@ namespace cAudio
if(Decoder->isSeekingSupported())
{
state = Decoder->seek(seconds, relative);
BufferPosition = Decoder->getCurrentPosition();
BufferTime = Decoder->getCurrentTime();
int queued = 0;
alGetSourcei(Source, AL_BUFFERS_QUEUED, &queued);
if (queued) {
BufferPosition -= queued * GetBufferSize(Buffers[0]);
BufferTime -= queued * GetBufferLength(Buffers[0]);
}
}
return state;
}
@ -236,12 +293,16 @@ namespace cAudio
float cAudioSource::getCurrentAudioTime()
{
return Decoder->getCurrentTime();
float time = -1;
alGetSourcef(Source, AL_SEC_OFFSET, &time);
return BufferTime + time;
}
int cAudioSource::getCurrentAudioPosition()
{
return Decoder->getCurrentPosition();
int offset = -1;
alGetSourcei(Source, AL_BYTE_OFFSET, &offset);
return BufferPosition + offset;
}
int cAudioSource::getCurrentCompressedAudioPosition()
@ -265,15 +326,17 @@ namespace cAudio
//gets the sound source processed buffers
alGetSourcei(Source, AL_BUFFERS_PROCESSED, &processed);
checkError();
checkALError();
//while there is more data refill buffers with audio data.
while (processed--)
{
ALuint buffer;
alSourceUnqueueBuffers(Source, 1, &buffer);
BufferPosition += GetBufferSize(buffer);
BufferTime += GetBufferLength(buffer);
if (checkError())
if (checkALError())
{
processed++;
cAudioSleep(1);
@ -288,7 +351,7 @@ namespace cAudio
alSourceQueueBuffers(Source, 1, &buffer);
}
if (checkError())
if (checkALError())
{
processed++;
cAudioSleep(1);
@ -301,7 +364,7 @@ namespace cAudio
ALenum state;
alGetSourcei(Source, AL_SOURCE_STATE, &state);
checkError();
checkALError();
if(state == AL_STOPPED && oldState != state)
{
//Resets the audio to the beginning
@ -314,69 +377,69 @@ namespace cAudio
return active;
}
const bool cAudioSource::isValid() const
bool cAudioSource::isValid() const
{
return Valid;
}
const bool cAudioSource::isPlaying() const
bool cAudioSourceBase::isPlaying() const
{
ALenum state = 0;
alGetSourcei(Source, AL_SOURCE_STATE, &state);
checkError();
checkALError();
return (state == AL_PLAYING);
}
const bool cAudioSource::isPaused() const
bool cAudioSourceBase::isPaused() const
{
ALenum state = 0;
alGetSourcei(Source, AL_SOURCE_STATE, &state);
checkError();
checkALError();
return (state == AL_PAUSED);
}
const bool cAudioSource::isStopped() const
bool cAudioSourceBase::isStopped() const
{
ALenum state = 0;
alGetSourcei(Source, AL_SOURCE_STATE, &state);
checkError();
checkALError();
return (state == AL_STOPPED);
}
const bool cAudioSource::isLooping() const
bool cAudioSource::isLooping() const
{
return Loop;
}
void cAudioSource::setPosition(const cVector3& position)
void cAudioSourceBase::setPosition(const cVector3& position)
{
cAudioMutexBasicLock lock(Mutex);
alSource3f(Source, AL_POSITION, position.x, position.y, position.z);
checkError();
checkALError();
}
void cAudioSource::setVelocity(const cVector3& velocity)
void cAudioSourceBase::setVelocity(const cVector3& velocity)
{
cAudioMutexBasicLock lock(Mutex);
alSource3f(Source, AL_VELOCITY, velocity.x, velocity.y, velocity.z);
checkError();
checkALError();
}
void cAudioSource::setDirection(const cVector3& direction)
void cAudioSourceBase::setDirection(const cVector3& direction)
{
cAudioMutexBasicLock lock(Mutex);
alSource3f(Source, AL_DIRECTION, direction.x, direction.y, direction.z);
checkError();
checkALError();
}
void cAudioSource::setRolloffFactor(const float& rolloff)
void cAudioSourceBase::setRolloffFactor(const float& rolloff)
{
cAudioMutexBasicLock lock(Mutex);
alSourcef(Source, AL_ROLLOFF_FACTOR, rolloff);
checkError();
checkALError();
}
void cAudioSource::setStrength(const float& soundstrength)
void cAudioSourceBase::setStrength(const float& soundstrength)
{
float inverseStrength = 0.0f;
if(soundstrength > 0.0f)
@ -384,88 +447,88 @@ namespace cAudio
cAudioMutexBasicLock lock(Mutex);
alSourcef(Source, AL_ROLLOFF_FACTOR, inverseStrength);
checkError();
checkALError();
}
void cAudioSource::setMinDistance(const float& minDistance)
void cAudioSourceBase::setMinDistance(const float& minDistance)
{
cAudioMutexBasicLock lock(Mutex);
alSourcef(Source, AL_REFERENCE_DISTANCE, minDistance);
checkError();
checkALError();
}
void cAudioSource::setMaxAttenuationDistance(const float& maxDistance)
void cAudioSourceBase::setMaxAttenuationDistance(const float& maxDistance)
{
cAudioMutexBasicLock lock(Mutex);
alSourcef(Source, AL_MAX_DISTANCE, maxDistance);
checkError();
checkALError();
}
void cAudioSource::setPitch(const float& pitch)
void cAudioSourceBase::setPitch(const float& pitch)
{
cAudioMutexBasicLock lock(Mutex);
alSourcef (Source, AL_PITCH, pitch);
checkError();
checkALError();
}
void cAudioSource::setVolume(const float& volume)
void cAudioSourceBase::setVolume(const float& volume)
{
cAudioMutexBasicLock lock(Mutex);
Volume = volume;
alSourcef(Source, AL_GAIN, Volume * Context->getAudioManager()->getMasterVolume());
checkError();
checkALError();
}
void cAudioSource::setMinVolume(const float& minVolume)
void cAudioSourceBase::setMinVolume(const float& minVolume)
{
cAudioMutexBasicLock lock(Mutex);
alSourcef(Source, AL_MIN_GAIN, minVolume);
checkError();
checkALError();
}
void cAudioSource::setMaxVolume(const float& maxVolume)
void cAudioSourceBase::setMaxVolume(const float& maxVolume)
{
cAudioMutexBasicLock lock(Mutex);
alSourcef(Source, AL_MAX_GAIN, maxVolume);
checkError();
checkALError();
}
void cAudioSource::setInnerConeAngle(const float& innerAngle)
void cAudioSourceBase::setInnerConeAngle(const float& innerAngle)
{
cAudioMutexBasicLock lock(Mutex);
alSourcef(Source, AL_CONE_INNER_ANGLE, innerAngle);
checkError();
checkALError();
}
void cAudioSource::setOuterConeAngle(const float& outerAngle)
void cAudioSourceBase::setOuterConeAngle(const float& outerAngle)
{
cAudioMutexBasicLock lock(Mutex);
alSourcef(Source, AL_CONE_OUTER_ANGLE, outerAngle);
checkError();
checkALError();
}
void cAudioSource::setOuterConeVolume(const float& outerVolume)
void cAudioSourceBase::setOuterConeVolume(const float& outerVolume)
{
cAudioMutexBasicLock lock(Mutex);
alSourcef(Source, AL_CONE_OUTER_GAIN, outerVolume);
checkError();
checkALError();
}
void cAudioSource::setDopplerStrength(const float& dstrength)
void cAudioSourceBase::setDopplerStrength(const float& dstrength)
{
cAudioMutexBasicLock lock(Mutex);
alSourcef(Source, AL_DOPPLER_FACTOR, dstrength);
checkError();
checkALError();
}
void cAudioSource::setDopplerVelocity(const cVector3& dvelocity)
void cAudioSourceBase::setDopplerVelocity(const cVector3& dvelocity)
{
cAudioMutexBasicLock lock(Mutex);
alSource3f(Source, AL_DOPPLER_VELOCITY, dvelocity.x, dvelocity.y, dvelocity.z);
checkError();
checkALError();
}
void cAudioSource::move(const cVector3& position)
void cAudioSourceBase::move(const cVector3& position)
{
cAudioMutexBasicLock lock(Mutex);
cVector3 oldPos = getPosition();
@ -473,45 +536,45 @@ namespace cAudio
alSource3f(Source, AL_VELOCITY, velocity.x, velocity.y, velocity.z);
alSource3f(Source, AL_POSITION, position.x, position.y, position.z);
checkError();
checkALError();
}
const cVector3 cAudioSource::getPosition() const
cVector3 cAudioSourceBase::getPosition() const
{
cVector3 position;
alGetSourcefv(Source, AL_POSITION, &position.x);
checkError();
checkALError();
return position;
}
const cVector3 cAudioSource::getVelocity() const
cVector3 cAudioSourceBase::getVelocity() const
{
cVector3 velocity;
alGetSourcefv(Source, AL_VELOCITY, &velocity.x);
return velocity;
}
const cVector3 cAudioSource::getDirection() const
cVector3 cAudioSourceBase::getDirection() const
{
cVector3 direction;
alGetSourcefv(Source, AL_DIRECTION, &direction.x);
checkError();
checkALError();
return direction;
}
const float cAudioSource::getRolloffFactor() const
float cAudioSourceBase::getRolloffFactor() const
{
float value = 0.0f;
alGetSourcef(Source, AL_ROLLOFF_FACTOR, &value);
checkError();
checkALError();
return value;
}
const float cAudioSource::getStrength() const
float cAudioSourceBase::getStrength() const
{
float value = 0.0f;
alGetSourcef(Source, AL_ROLLOFF_FACTOR, &value);
checkError();
checkALError();
float inverseStrength = 0.0f;
if(value > 0.0f)
@ -520,88 +583,116 @@ namespace cAudio
return inverseStrength;
}
const float cAudioSource::getMinDistance() const
float cAudioSourceBase::getMinDistance() const
{
float value = 0.0f;
alGetSourcef(Source, AL_REFERENCE_DISTANCE, &value);
checkError();
checkALError();
return value;
}
const float cAudioSource::getMaxDistance() const
float cAudioSourceBase::getMaxDistance() const
{
float value = 0.0f;
alGetSourcef(Source, AL_MAX_DISTANCE, &value);
checkError();
checkALError();
return value;
}
const float cAudioSource::getPitch() const
bool cAudioSourceBase::isRelative() const
{
int relative = 0;
alGetSourcei(Source, AL_SOURCE_RELATIVE, &relative);
return relative;
}
float cAudioSourceBase::calculateGain() const
{
// OpenAL Inverse Distance Clamped Model
// distance = max(distance,AL_REFERENCE_DISTANCE);
// distance = min(distance,AL_MAX_DISTANCE);
// gain = AL_REFERENCE_DISTANCE / (AL_REFERENCE_DISTANCE +
// AL_ROLLOFF_FACTOR *
// (distance – AL_REFERENCE_DISTANCE));
cVector3 lpos = Context->getAudioManager()->getListener()->getPosition();
cVector3 pos = getPosition();
float refDist = getMinDistance();
float dist = 0.f;
dist = isRelative() ? pos.length() : (pos - lpos).length();
dist = std::max(dist, refDist);
dist = std::min(dist, getMaxDistance());
float gain = refDist / (refDist + getRolloffFactor() * (dist - refDist));
return gain * getVolume();
}
float cAudioSourceBase::getPitch() const
{
float value = 0.0f;
alGetSourcef(Source, AL_PITCH, &value);
checkError();
checkALError();
return value;
}
const float cAudioSource::getVolume() const
float cAudioSourceBase::getVolume() const
{
return Volume;
}
const float cAudioSource::getMinVolume() const
float cAudioSourceBase::getMinVolume() const
{
float value = 0.0f;
alGetSourcef(Source, AL_MIN_GAIN, &value);
checkError();
checkALError();
return value;
}
const float cAudioSource::getMaxVolume() const
float cAudioSourceBase::getMaxVolume() const
{
float value = 0.0f;
alGetSourcef(Source, AL_MAX_GAIN, &value);
checkError();
checkALError();
return value;
}
const float cAudioSource::getInnerConeAngle() const
float cAudioSourceBase::getInnerConeAngle() const
{
float value = 0.0f;
alGetSourcef(Source, AL_CONE_INNER_ANGLE, &value);
checkError();
checkALError();
return value;
}
const float cAudioSource::getOuterConeAngle() const
float cAudioSourceBase::getOuterConeAngle() const
{
float value = 0.0f;
alGetSourcef(Source, AL_CONE_OUTER_ANGLE, &value);
checkError();
checkALError();
return value;
}
const float cAudioSource::getOuterConeVolume() const
float cAudioSourceBase::getOuterConeVolume() const
{
float value = 0.0f;
alGetSourcef(Source, AL_CONE_OUTER_GAIN, &value);
checkError();
checkALError();
return value;
}
const float cAudioSource::getDopplerStrength() const
float cAudioSourceBase::getDopplerStrength() const
{
float value = 0.0f;
alGetSourcef(Source, AL_DOPPLER_FACTOR, &value);
checkError();
checkALError();
return value;
}
const cVector3 cAudioSource::getDopplerVelocity() const
cVector3 cAudioSourceBase::getDopplerVelocity() const
{
cVector3 velocity;
alGetSourcefv(Source, AL_DOPPLER_VELOCITY, &velocity.x);
checkError();
checkALError();
return velocity;
}
@ -668,100 +759,70 @@ namespace cAudio
{
int queued = 0;
alGetSourcei(Source, AL_BUFFERS_QUEUED, &queued);
checkError();
checkALError();
while (queued--)
{
ALuint buffer;
alSourceUnqueueBuffers(Source, 1, &buffer);
checkError();
checkALError();
}
}
bool cAudioSource::checkError() const
{
int error = alGetError();
if (error != AL_NO_ERROR)
{
const char* errorString = alGetString(error);
if(error == AL_OUT_OF_MEMORY)
getLogger()->logCritical("Audio Source", "OpenAL Error: %s.", errorString);
else
getLogger()->logError("Audio Source", "OpenAL Error: %s.", errorString);
return true;
}
return false;
}
bool cAudioSource::stream(ALuint buffer)
{
if(Decoder)
if(!Decoder)
return false;
//stores the calculated data into buffer that is passed to output.
size_t totalread = 0;
unsigned int errorcount = 0;
char tempbuffer[CAUDIO_SOURCE_BUFFER_SIZE];
while( totalread < CAUDIO_SOURCE_BUFFER_SIZE )
{
//stores the calculated data into buffer that is passed to output.
size_t totalread = 0;
unsigned int errorcount = 0;
char tempbuffer[CAUDIO_SOURCE_BUFFER_SIZE];
while( totalread < CAUDIO_SOURCE_BUFFER_SIZE )
{
char tempbuffer2[CAUDIO_SOURCE_BUFFER_SIZE];
int actualread = Decoder->readAudioData(tempbuffer2, CAUDIO_SOURCE_BUFFER_SIZE-totalread);
if(actualread > 0)
{
memcpy(tempbuffer+totalread,tempbuffer2,actualread);
totalread += actualread;
}
if(actualread < 0)
{
++errorcount;
getLogger()->logDebug("Audio Source", "Decoder returned an error: %i (%i of 3)", actualread, errorcount);
if(errorcount >= 3)
{
stop();
break;
}
}
if(actualread == 0)
{
if(isLooping())
{
//If we are to loop, set to the beginning and reload from the start
Decoder->setPosition(0, false);
getLogger()->logDebug("Audio Source", "Buffer looping.");
}
else
break;
}
}
//Second check, in case looping is not enabled, we will return false for end of stream
if(totalread == 0)
{
return false;
}
getLogger()->logDebug("Audio Source", "Buffered %i bytes of data into buffer %i at %i hz.", totalread, buffer, Decoder->getFrequency());
alBufferData(buffer, convertAudioFormatEnum(Decoder->getFormat()), tempbuffer, totalread, Decoder->getFrequency());
checkError();
return true;
char tempbuffer2[CAUDIO_SOURCE_BUFFER_SIZE];
Mutex.unlock(); // this can take a long time
int actualread = Decoder->readAudioData(tempbuffer2, CAUDIO_SOURCE_BUFFER_SIZE-totalread);
Mutex.lock();
if(actualread > 0)
{
memcpy(tempbuffer+totalread,tempbuffer2,actualread);
totalread += actualread;
}
if(actualread < 0)
{
++errorcount;
getLogger()->logDebug("Audio Source", "Decoder returned an error: %i (%i of 3)", actualread, errorcount);
if(errorcount >= 3)
{
stop();
break;
}
}
if(actualread == 0)
{
if(isLooping())
{
//If we are to loop, set to the beginning and reload from the start
Decoder->setPosition(0, false);
getLogger()->logDebug("Audio Source", "Buffer looping.");
}
else
break;
}
}
return false;
}
ALenum cAudioSource::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;
};
}
//Second check, in case looping is not enabled, we will return false for end of stream
if(totalread == 0)
{
return false;
}
getLogger()->logDebug("Audio Source", "Buffered %i bytes of data into buffer %i at %i hz.", totalread, buffer, Decoder->getFrequency());
alBufferData(buffer, convertAudioFormatEnum(Decoder->getFormat()), tempbuffer, totalread, Decoder->getFrequency());
checkALError();
return true;
}
#if CAUDIO_EFX_ENABLED == 1
void cAudioSource::updateFilter(bool remove)
@ -777,7 +838,7 @@ namespace cAudio
if(theFilter)
{
alSourcei(Source, AL_DIRECT_FILTER, theFilter->getOpenALFilter());
checkError();
checkALError();
return;
}
}
@ -785,7 +846,7 @@ namespace cAudio
}
}
alSourcei(Source, AL_DIRECT_FILTER, AL_FILTER_NULL);
checkError();
checkALError();
}
void cAudioSource::updateEffect(unsigned int slot, bool remove)
@ -809,7 +870,7 @@ namespace cAudio
filterID = theFilter->getOpenALFilter();
}
alSource3i(Source, AL_AUXILIARY_SEND_FILTER, theEffect->getOpenALEffectSlot(), slot, filterID);
checkError();
checkALError();
return;
}
}
@ -817,12 +878,12 @@ namespace cAudio
}
}
alSource3i(Source, AL_AUXILIARY_SEND_FILTER, AL_EFFECTSLOT_NULL, slot, AL_FILTER_NULL);
checkError();
checkALError();
}
}
#endif
void cAudioSource::registerEventHandler(ISourceEventHandler* handler)
void cAudioSourceBase::registerEventHandler(ISourceEventHandler* handler)
{
if(handler)
{
@ -831,71 +892,51 @@ namespace cAudio
}
}
void cAudioSource::unRegisterEventHandler(ISourceEventHandler* handler)
void cAudioSourceBase::unRegisterEventHandler(ISourceEventHandler* handler)
{
if(handler)
{
cAudioMutexBasicLock lock(Mutex);
eventHandlerList.remove(handler);
for(int i=0; i<eventHandlerList.size(); i++) {
if(eventHandlerList[i] == handler)
eventHandlerList.erase(eventHandlerList.begin() + i);
}
}
}
void cAudioSource::unRegisterAllEventHandlers()
void cAudioSourceBase::unRegisterAllEventHandlers()
{
cAudioMutexBasicLock lock(Mutex);
eventHandlerList.clear();
}
void cAudioSource::signalEvent(Events sevent)
void cAudioSourceBase::signalEvent(Events sevent)
{
cAudioMutexBasicLock lock(Mutex);
cAudioList<ISourceEventHandler*>::Type::iterator it = eventHandlerList.begin();
if(eventHandlerList.empty())
return;
if(it != eventHandlerList.end()){
size_t size = eventHandlerList.size();
switch(sevent){
for(int i=0; i<size; )
{
ISourceEventHandler *handler = eventHandlerList[i];
case ON_UPDATE:
for( ; it != eventHandlerList.end(); it++){
(*it)->onUpdate();
}
break;
case ON_RELEASE:
for( ; it != eventHandlerList.end(); it++){
(*it)->onRelease();
}
break;
case ON_PLAY:
for( ; it != eventHandlerList.end(); it++){
(*it)->onPlay();
}
break;
case ON_PAUSE:
for( ; it != eventHandlerList.end(); it++){
(*it)->onPause();
}
break;
case ON_STOP:
for( ; it != eventHandlerList.end(); it++){
(*it)->onStop();
}
break;
}
}
}
switch(sevent)
{
case ON_UPDATE: handler->onUpdate(); break;
case ON_RELEASE: handler->onRelease(); break;
case ON_PLAY: handler->onPlay(); break;
case ON_PAUSE: handler->onPause(); break;
case ON_STOP: handler->onStop(); break;
}
// handler may have unregistered itself
if(size == eventHandlerList.size()) {
i++;
} else {
size = eventHandlerList.size();
}
}
}
}

4
cAudio/src/cConsoleLogReceiver.cpp
View File

@ -11,8 +11,8 @@ namespace cAudio
{
bool cConsoleLogReceiver::OnLogMessage(const char* sender, const char* message, LogLevel level, float time)
{
//std::cout << time << " " << sender << ": [" << LogLevelStrings[level] << "] " << message << std::endl;
std::cout << "[" << LogLevelStrings[level] << "] " << message << std::endl;
std::cout << sender << ": " << message << std::endl;
//std::cout << "[" << LogLevelStrings[level] << "] " << message << std::endl;
return true;
}
};

2
cAudio/src/cFileSource.cpp
View File

@ -17,7 +17,7 @@ cFileSource::cFileSource(const char* filename) : pFile(NULL), Valid(false), File
cAudioString safeFilename = fromUTF8(filename);
if(safeFilename.length() != 0)
{
pFile = fopen(toUTF8(safeFilename),"rb");
pFile = cfopen(safeFilename, "rb");
if(pFile)
Valid = true;
}

15
cAudio/src/cListener.cpp
View File

@ -1,10 +1,10 @@
// Copyright (c) 2008-2011 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones, Murat (wolfmanfx) Sari
// This file is part of the "cAudio Engine"
// Copyright (c) 2008-2011 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones, Murat (wolfmanfx) Sari
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h
#include "cListener.h"
#include "cEFXFunctions.h"
#include <al.h>
#include "cOpenALUtil.h"
namespace cAudio
{
@ -13,6 +13,7 @@ namespace cAudio
cAudioMutexBasicLock lock(Mutex);
Position = pos;
alListener3f(AL_POSITION, Position.x, Position.y, Position.z);
checkALError();
}
void cListener::setDirection(const cVector3& dir)
{
@ -20,6 +21,7 @@ namespace cAudio
Direction = dir;
float orient[6] = {Direction[0], Direction[1], Direction[2], UpVector[0], UpVector[1], UpVector[2]};
alListenerfv(AL_ORIENTATION, orient);
checkALError();
}
void cListener::setUpVector(const cVector3& up)
{
@ -27,18 +29,21 @@ namespace cAudio
UpVector = up;
float orient[6] = {Direction[0], Direction[1], Direction[2], UpVector[0], UpVector[1], UpVector[2]};
alListenerfv(AL_ORIENTATION, orient);
checkALError();
}
void cListener::setVelocity(const cVector3& vel)
{
cAudioMutexBasicLock lock(Mutex);
Velocity = vel;
alListener3f(AL_VELOCITY, Velocity.x, Velocity.y, Velocity.z);
checkALError();
}
void cListener::setMasterVolume(const float& volume)
{
cAudioMutexBasicLock lock(Mutex);
MasterGain = volume;
alListenerf(AL_GAIN, MasterGain);
checkALError();
}
void cListener::move(const cVector3& pos)
{
@ -48,12 +53,14 @@ namespace cAudio
alListener3f(AL_POSITION, Position.x, Position.y, Position.z);
alListener3f(AL_VELOCITY, Velocity.x, Velocity.y, Velocity.z);
checkALError();
}
#if CAUDIO_EFX_ENABLED == 1
void cListener::setMetersPerUnit(const float& meters)
{
cAudioMutexBasicLock lock(Mutex);
alListenerf(AL_METERS_PER_UNIT, meters);
checkALError();
}
float cListener::getMetersPerUnit(void) const
@ -63,4 +70,4 @@ namespace cAudio
return value;
}
#endif
};
};

16
cAudio/src/cMutex.cpp
View File

@ -1,5 +1,5 @@
// Copyright (c) 2008-2011 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones, Murat (wolfmanfx) Sari
// This file is part of the "cAudio Engine"
// Copyright (c) 2008-2011 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones, Murat (wolfmanfx) Sari
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h
#include "cMutex.h"
@ -30,7 +30,7 @@ namespace cAudio
#ifdef CAUDIO_PLATFORM_WIN
EnterCriticalSection(&criticalSection);
#else
int error = pthread_mutex_lock(&Mutex);
pthread_mutex_lock(&Mutex);
#endif
}
@ -41,7 +41,7 @@ namespace cAudio
#ifdef CAUDIO_PLATFORM_WIN
LeaveCriticalSection(&criticalSection);
#else
int error = pthread_mutex_unlock(&Mutex);
pthread_mutex_unlock(&Mutex);
#endif
}
@ -51,10 +51,10 @@ namespace cAudio
InitializeCriticalSection(&criticalSection);
#else
pthread_mutexattr_t attr;
int error = pthread_mutexattr_init(&attr);
error = pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
error = pthread_mutex_init(&Mutex, &attr);
error = pthread_mutexattr_destroy(&attr);
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&Mutex, &attr);
pthread_mutexattr_destroy(&attr);
#endif
Initialized=true;
}

8
cAudio/src/cOggDecoder.cpp
View File

@ -136,7 +136,7 @@ namespace cAudio
{
if(relative)
{
float curtime = ov_time_tell(&oggStream);
double curtime = ov_time_tell(&oggStream);
return (ov_time_seek(&oggStream,curtime+seconds)==0);
}
else
@ -153,7 +153,8 @@ namespace cAudio
int cOggDecoder::getTotalSize()
{
return ov_pcm_total(&oggStream, -1) * vorbisInfo->channels;
// ov_pcm_total is in samples
return ov_pcm_total(&oggStream, -1) * vorbisInfo->channels * 2;
}
int cOggDecoder::getCompressedSize()
@ -168,7 +169,8 @@ namespace cAudio
int cOggDecoder::getCurrentPosition()
{
return ov_pcm_tell(&oggStream) * vorbisInfo->channels;
// ov_pcm_tell is in samples
return ov_pcm_tell(&oggStream) * vorbisInfo->channels * 2;
}
int cOggDecoder::getCurrentCompressedPosition()

12
cAudio/src/cOpenALAudioDeviceList.cpp
View File

@ -2,11 +2,8 @@
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h
#pragma once
#include "cOpenALAudioDeviceList.h"
#include <al.h>
#include <alc.h>
#include "cOpenALUtil.h"
namespace cAudio
{
@ -23,12 +20,15 @@ namespace cAudio
}
else
{
#if ALC_ENUMERATE_ALL_EXT
if( alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") == AL_TRUE )
{
specifier = ALC_ALL_DEVICES_SPECIFIER;
defaultDevice = ALC_DEFAULT_ALL_DEVICES_SPECIFIER;
}
else if( alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE )
else
#endif
if( alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE )
{
specifier = ALC_DEVICE_SPECIFIER;
defaultDevice = ALC_DEFAULT_DEVICE_SPECIFIER;
@ -87,4 +87,4 @@ namespace cAudio
}
return AvailableDevices.size() > 0;
}
}
}

19
cAudio/src/cOpenALDeviceContext.cpp
View File

@ -84,9 +84,9 @@ namespace cAudio
return false;
}
getLogger()->logInfo("AudioManager", "OpenAL Version: %s", alGetString(AL_VERSION));
getLogger()->logInfo("AudioManager", "Vendor: %s", alGetString(AL_VENDOR));
getLogger()->logInfo("AudioManager", "Renderer: %s", alGetString(AL_RENDERER));
getLogger()->logWarning("AudioManager", "OpenAL Version: %s", alGetString(AL_VERSION));
getLogger()->logWarning("AudioManager", "Vendor: %s", alGetString(AL_VENDOR));
getLogger()->logWarning("AudioManager", "Renderer: %s", alGetString(AL_RENDERER));
#if CAUDIO_EFX_ENABLED == 1
initEffects.getEFXInterface()->Mutex.lock();
@ -108,7 +108,8 @@ namespace cAudio
getLogger()->logWarning("AudioManager", "EFX is not supported, EFX disabled.");
}
#endif
getLogger()->logInfo("AudioManager", "Supported Extensions: %s", alGetString(AL_EXTENSIONS));
getLogger()->logWarning("AudioManager", "Supported Extensions: %s", alGetString(AL_EXTENSIONS));
Initialized = true;
return true;
}
@ -124,8 +125,8 @@ namespace cAudio
alcDestroyContext(Context);
Context = NULL;
//Close the device
alcCloseDevice(Device);
checkError();
if (!alcCloseDevice(Device))
getLogger()->logError("AudioManager", "alcCloseDevice failed");
Device = NULL;
Initialized = false;
@ -169,16 +170,16 @@ namespace cAudio
return true;
}
if(Device)
//if(Device)
{
error = alcGetError(Device);
if (error != AL_NO_ERROR)
{
errorString = alGetString(error);
errorString = alcGetString(Device, error);
getLogger()->logError("AudioManager", "OpenAL Error: %s.", errorString);
return true;
}
}
return false;
}
}
}

45
cAudio/src/cThread.cpp
View File

@ -13,8 +13,6 @@ namespace cAudio
cAudioThread::~cAudioThread()
{
if(IsInit)
shutdown();
}
bool cAudioThread::start()
@ -28,8 +26,6 @@ namespace cAudio
#ifdef CAUDIO_PLATFORM_WIN
ThreadHandle = reinterpret_cast<HANDLE>(_beginthreadex(0, 0, threadFunc, this, 0, &ThreadID));
if(ThreadHandle == 0)
CloseHandle( ThreadHandle );
#else
pthread_create( &ThreadHandle, 0, threadFunc, this );
#endif
@ -79,9 +75,43 @@ namespace cAudio
}
#ifdef CAUDIO_PLATFORM_WIN
//
// Usage: SetThreadName (-1, "MainThread");
//
const DWORD MS_VC_EXCEPTION = 0x406D1388;
#pragma pack(push,8)
typedef struct tagTHREADNAME_INFO
{
DWORD dwType; // Must be 0x1000.
LPCSTR szName; // Pointer to name (in user addr space).
DWORD dwThreadID; // Thread ID (-1=caller thread).
DWORD dwFlags; // Reserved for future use, must be zero.
} THREADNAME_INFO;
#pragma pack(pop)
inline void SetThreadName(DWORD dwThreadID, const char* threadName)
{
THREADNAME_INFO info;
info.dwType = 0x1000;
info.szName = threadName;
info.dwThreadID = dwThreadID;
info.dwFlags = 0;
__try
{
RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
}
}
unsigned int __stdcall cAudioThread::threadFunc(void *args)
{
cAudioThread* pThread = reinterpret_cast<cAudioThread*>(args);
SetThreadName(GetCurrentThreadId(), "cAudio");
pThread->updateLoop();
return 0;
}
@ -89,8 +119,13 @@ namespace cAudio
void* cAudioThread::threadFunc(void* args)
{
cAudioThread* pThread = reinterpret_cast<cAudioThread*>(args);
#if defined(CAUDIO_PLATFORM_MAC) || defined(CAUDIO_PLATFORM_IPHONE)
pthread_setname_np("cAudio");
#else
pthread_setname_np(pthread_self(), "cAudio");
#endif
pThread->updateLoop();
return 0;
}
#endif
};
};

3
cAudio/src/cWavDecoder.cpp
View File

@ -19,7 +19,6 @@ namespace cAudio
char ident[4];
int tempint32 = 0;
short tempint16 = 0;
char tempint8 = 0;
unsigned int startOffset = 0;
@ -192,7 +191,7 @@ namespace cAudio
bool cWavDecoder::seek(float seconds,bool relative)
{
int amountToSeek = seconds * (float)SampleRate * (float)Channels * (float)(BitsPerSample/8);
int amountToSeek = (int) (seconds * (float)SampleRate * (float)Channels * (float)(BitsPerSample/8));
return setPosition(amountToSeek, relative);
}