Mirrors/eepp
1
0
Fork 0
mirror of https://github.com/SpartanJ/eepp.git synced 2026-08-18 06:55:48 +03:00
Code Issues Packages Projects Releases Wiki Activity

Audio Module refactored.

Browse Source
This commit is contained in:
Martín Lucas Golini
2014-06-14 02:56:58 -03:00
parent f9455c7556
commit e71d79ccd8
28 changed files with 314 additions and 314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/eepp/audio/caudiodevice.cpp → src/eepp/audio/audiodevice.cpp
View File

@@ -1,5 +1,5 @@
#include <eepp/audio/caudiodevice.hpp>
#include <eepp/audio/caudiolistener.hpp>
#include <eepp/audio/audiodevice.hpp>
#include <eepp/audio/audiolistener.hpp>
#include <eepp/audio/openal.hpp>
namespace EE { namespace Audio {
@@ -7,7 +7,7 @@ namespace EE { namespace Audio {
ALCdevice * mDevice = NULL;
ALCcontext * mContext = NULL;
cAudioDevice::cAudioDevice() {
AudioDevice::AudioDevice() {
PrintInfo();
// Create the device
@@ -42,7 +42,7 @@ cAudioDevice::cAudioDevice() {
}
}
void cAudioDevice::PrintInfo() {
void AudioDevice::PrintInfo() {
std::string log( "OpenAL devices detected:\n" );
if ( alcIsExtensionPresent( NULL, (const ALCchar *) "ALC_ENUMERATION_EXT" ) == AL_TRUE ) {
@@ -62,7 +62,7 @@ void cAudioDevice::PrintInfo() {
eePRINTL( log.c_str() );
}
cAudioDevice::~cAudioDevice() {
AudioDevice::~AudioDevice() {
// Destroy the context
alcMakeContextCurrent( NULL );
@@ -74,7 +74,7 @@ cAudioDevice::~cAudioDevice() {
alcCloseDevice( mDevice );
}
bool cAudioDevice::IsExtensionSupported( const std::string& extension ) {
bool AudioDevice::IsExtensionSupported( const std::string& extension ) {
EnsureALInit();
if ( ( extension.length() > 2 ) && ( extension.substr(0, 3) == "ALC" ) )
@@ -83,7 +83,7 @@ bool cAudioDevice::IsExtensionSupported( const std::string& extension ) {
return alIsExtensionPresent( extension.c_str() ) != AL_FALSE;
}
int cAudioDevice::GetFormatFromChannelCount( unsigned int ChannelCount ) {
int AudioDevice::GetFormatFromChannelCount( unsigned int ChannelCount ) {
EnsureALInit();
int format = 0;
@@ -104,7 +104,7 @@ int cAudioDevice::GetFormatFromChannelCount( unsigned int ChannelCount ) {
return format;
}
bool cAudioDevice::IsAvailable() {
bool AudioDevice::IsAvailable() {
return NULL != mDevice && NULL != mContext;
}

22
src/eepp/audio/caudiolistener.cpp → src/eepp/audio/audiolistener.cpp
View File

@@ -1,9 +1,9 @@
#include <eepp/audio/caudiolistener.hpp>
#include <eepp/audio/audiolistener.hpp>
#include <eepp/audio/openal.hpp>
namespace EE { namespace Audio {
void cAudioListener::GlobalVolume( const float& Volume ) {
void AudioListener::GlobalVolume( const float& Volume ) {
EnsureALInit();
#if EE_PLATFORM != EE_PLATFORM_EMSCRIPTEN
@@ -11,7 +11,7 @@ void cAudioListener::GlobalVolume( const float& Volume ) {
#endif
}
float cAudioListener::GlobalVolume() {
float AudioListener::GlobalVolume() {
EnsureALInit();
float Volume = 0.f;
@@ -21,17 +21,17 @@ float cAudioListener::GlobalVolume() {
return Volume * 100.f;
}
void cAudioListener::Position( const float& X, const float& Y, const float& Z ) {
void AudioListener::Position( const float& X, const float& Y, const float& Z ) {
EnsureALInit();
ALCheck( alListener3f( AL_POSITION, X, Y, Z ) );
}
void cAudioListener::Position(const eeVector3ff& Position) {
cAudioListener::Position( Position.x, Position.y, Position.z );
void AudioListener::Position(const eeVector3ff& Position) {
AudioListener::Position( Position.x, Position.y, Position.z );
}
eeVector3ff cAudioListener::Position() {
eeVector3ff AudioListener::Position() {
EnsureALInit();
eeVector3ff Position;
@@ -40,18 +40,18 @@ eeVector3ff cAudioListener::Position() {
return Position;
}
void cAudioListener::Target( const float& X, const float& Y, const float& Z ) {
void AudioListener::Target( const float& X, const float& Y, const float& Z ) {
EnsureALInit();
float Orientation[] = {X, Y, Z, 0.f, 1.f, 0.f};
ALCheck( alListenerfv( AL_ORIENTATION, Orientation ) );
}
void cAudioListener::Target(const eeVector3ff& Target) {
cAudioListener::Target( Target.x, Target.y, Target.z );
void AudioListener::Target(const eeVector3ff& Target) {
AudioListener::Target( Target.x, Target.y, Target.z );
}
eeVector3ff cAudioListener::Target() {
eeVector3ff AudioListener::Target() {
EnsureALInit();
float Orientation[6];

26
src/eepp/audio/cmusic.cpp → src/eepp/audio/music.cpp
View File

@@ -1,29 +1,29 @@
#include <eepp/audio/cmusic.hpp>
#include <eepp/audio/csoundfile.hpp>
#include <eepp/audio/music.hpp>
#include <eepp/audio/soundfile.hpp>
#include <eepp/system/cpackmanager.hpp>
namespace EE { namespace Audio {
cMusic::cMusic( std::size_t BufferSize ) :
Music::Music( std::size_t BufferSize ) :
mFile ( NULL ),
mDuration( 0.f ),
mSamples( BufferSize )
{
}
cMusic::~cMusic() {
Music::~Music() {
Stop();
eeSAFE_DELETE( mFile );
}
bool cMusic::OpenFromPack( cPack* Pack, const std::string& FilePackPath ) {
bool Music::OpenFromPack( cPack* Pack, const std::string& FilePackPath ) {
if ( Pack->IsOpen() && Pack->ExtractFileToMemory( FilePackPath, mData ) )
return OpenFromMemory( reinterpret_cast<const char*> ( mData.Data ), mData.DataSize );
return false;
}
bool cMusic::OpenFromFile( const std::string& Filename ) {
bool Music::OpenFromFile( const std::string& Filename ) {
if ( !FileSystem::FileExists( Filename ) ) {
if ( cPackManager::instance()->FallbackToPacks() ) {
std::string tPath( Filename );
@@ -42,7 +42,7 @@ bool cMusic::OpenFromFile( const std::string& Filename ) {
Stop();
eeSAFE_DELETE( mFile );
mFile = cSoundFile::CreateRead( Filename );
mFile = SoundFile::CreateRead( Filename );
if ( NULL == mFile ) {
eePRINTL( "Failed to open %s for reading", Filename.c_str() );
@@ -60,12 +60,12 @@ bool cMusic::OpenFromFile( const std::string& Filename ) {
return true;
}
bool cMusic::OpenFromMemory( const char * Data, std::size_t SizeInBytes ) {
bool Music::OpenFromMemory( const char * Data, std::size_t SizeInBytes ) {
Stop();
eeSAFE_DELETE( mFile );
// Create the sound file implementation, and open it in read mode
mFile = cSoundFile::CreateRead( Data, SizeInBytes );
mFile = SoundFile::CreateRead( Data, SizeInBytes );
if ( NULL == mFile ) {
eePRINTL( "Failed to open music from memory for reading" );
@@ -81,11 +81,11 @@ bool cMusic::OpenFromMemory( const char * Data, std::size_t SizeInBytes ) {
return true;
}
bool cMusic::OnStart() {
bool Music::OnStart() {
return NULL != mFile && mFile->Restart();
}
bool cMusic::OnGetData( cSoundStream::Chunk& Data ) {
bool Music::OnGetData( SoundStream::Chunk& Data ) {
if ( NULL != mFile ) {
// Fill the chunk parameters
Data.Samples = &mSamples[0];
@@ -98,11 +98,11 @@ bool cMusic::OnGetData( cSoundStream::Chunk& Data ) {
return false;
}
cTime cMusic::GetDuration() const {
cTime Music::GetDuration() const {
return Seconds( mDuration );
}
void cMusic::OnSeek( cTime timeOffset ) {
void Music::OnSeek( cTime timeOffset ) {
if ( NULL != mFile ) {
mFile->Seek( timeOffset );
}

4
src/eepp/audio/openal.cpp
View File

@@ -1,5 +1,5 @@
#include <eepp/audio/openal.hpp>
#include <eepp/audio/caudiodevice.hpp>
#include <eepp/audio/audiodevice.hpp>
#include <iostream>
namespace EE { namespace Audio {
@@ -41,7 +41,7 @@ void ALCheckError(const std::string& File, unsigned int Line) {
}
void EnsureALInit() {
static cAudioDevice GlobalDevice;
static AudioDevice GlobalDevice;
}
}}

72
src/eepp/audio/csound.cpp → src/eepp/audio/sound.cpp
View File

@@ -1,10 +1,10 @@
#include <eepp/audio/csound.hpp>
#include <eepp/audio/caudiodevice.hpp>
#include <eepp/audio/sound.hpp>
#include <eepp/audio/audiodevice.hpp>
#include <eepp/audio/openal.hpp>
namespace EE { namespace Audio {
cSound::cSound() :
Sound::Sound() :
mBuffer(NULL)
{
EnsureALInit();
@@ -13,7 +13,7 @@ cSound::cSound() :
ALCheck( alSourcei( mSource, AL_BUFFER, 0 ) );
}
cSound::cSound( const cSoundBuffer& Buffer, const bool& Loop, const float& Pitch, const float& Volume, const eeVector3ff& Position ) :
Sound::Sound( const SoundBuffer& Buffer, const bool& Loop, const float& Pitch, const float& Volume, const eeVector3ff& Position ) :
mBuffer(&Buffer)
{
EnsureALInit();
@@ -27,7 +27,7 @@ cSound::cSound( const cSoundBuffer& Buffer, const bool& Loop, const float& Pitch
ALCheck( alSource3f( mSource, AL_POSITION, Position.x, Position.y, Position.z ) );
}
cSound::cSound(const cSound& Copy) :
Sound::Sound(const Sound& Copy) :
mBuffer(Copy.mBuffer)
{
EnsureALInit();
@@ -41,7 +41,7 @@ cSound::cSound(const cSound& Copy) :
ALCheck( alSource3f( mSource, AL_POSITION, Copy.Position().x, Copy.Position().y, Copy.Position().z) );
}
cSound::~cSound() {
Sound::~Sound() {
if ( mSource ) {
if ( mBuffer ) {
Stop();
@@ -52,19 +52,19 @@ cSound::~cSound() {
}
}
void cSound::Play() {
void Sound::Play() {
ALCheck( alSourcePlay( mSource ) );
}
void cSound::Pause() {
void Sound::Pause() {
ALCheck( alSourcePause( mSource ) );
}
void cSound::Stop() {
void Sound::Stop() {
ALCheck( alSourceStop( mSource ) );
}
void cSound::Buffer(const cSoundBuffer& Buffer) {
void Sound::Buffer(const SoundBuffer& Buffer) {
if ( NULL != mBuffer ) {
Stop();
mBuffer->DetachSound( this );
@@ -76,60 +76,60 @@ void cSound::Buffer(const cSoundBuffer& Buffer) {
ALCheck( alSourcei( mSource, AL_BUFFER, mBuffer ? mBuffer->mBuffer : 0 ) );
}
void cSound::Loop( const bool& Loop ) {
void Sound::Loop( const bool& Loop ) {
ALCheck( alSourcei( mSource, AL_LOOPING, Loop ) );
}
void cSound::Pitch( const float& Pitch ) {
void Sound::Pitch( const float& Pitch ) {
ALCheck( alSourcef( mSource, AL_PITCH, Pitch ) );
}
void cSound::Volume( const float& Volume ) {
void Sound::Volume( const float& Volume ) {
ALCheck( alSourcef( mSource, AL_GAIN, Volume * 0.01f ) );
}
void cSound::Position( const float& X, const float& Y, const float& Z ) {
void Sound::Position( const float& X, const float& Y, const float& Z ) {
ALCheck( alSource3f( mSource, AL_POSITION, X, Y, Z ) );
}
void cSound::Position( const eeVector3ff& Position ) {
void Sound::Position( const eeVector3ff& Position ) {
this->Position( Position.x, Position.y, Position.z );
}
void cSound::MinDistance( const float& MinDistance ) {
void Sound::MinDistance( const float& MinDistance ) {
ALCheck( alSourcef( mSource, AL_REFERENCE_DISTANCE, MinDistance ) );
}
void cSound::Attenuation( const float& Attenuation ) {
void Sound::Attenuation( const float& Attenuation ) {
ALCheck( alSourcef( mSource, AL_ROLLOFF_FACTOR, Attenuation ) );
}
const cSoundBuffer* cSound::Buffer() const {
const SoundBuffer* Sound::Buffer() const {
return mBuffer;
}
bool cSound::Loop() const {
bool Sound::Loop() const {
ALint Loop;
ALCheck( alGetSourcei( mSource, AL_LOOPING, &Loop ) );
return Loop != 0;
}
float cSound::Pitch() const {
float Sound::Pitch() const {
float Pitch;
ALCheck( alGetSourcef( mSource, AL_PITCH, &Pitch ) );
return Pitch;
}
float cSound::Volume() const {
float Sound::Volume() const {
float Gain = 1;
ALCheck( alGetSourcef( mSource, AL_GAIN, &Gain ) );
return Gain * 100.f;
}
eeVector3ff cSound::Position() const {
eeVector3ff Sound::Position() const {
eeVector3ff Position;
#if EE_PLATFORM != EE_PLATFORM_EMSCRIPTEN
@@ -139,35 +139,35 @@ eeVector3ff cSound::Position() const {
return Position;
}
float cSound::MinDistance() const {
float Sound::MinDistance() const {
float MinDistance;
ALCheck( alGetSourcef( mSource, AL_REFERENCE_DISTANCE, &MinDistance ) );
return MinDistance;
}
float cSound::Attenuation() const {
float Sound::Attenuation() const {
float Attenuation;
ALCheck( alGetSourcef( mSource, AL_ROLLOFF_FACTOR, &Attenuation ) );
return Attenuation;
}
cSound::Status cSound::GetState() const {
Sound::Status Sound::GetState() const {
ALint State;
ALCheck( alGetSourcei( mSource, AL_SOURCE_STATE, &State ) );
switch (State) {
case AL_INITIAL :
case AL_STOPPED : return cSound::Stopped;
case AL_PAUSED : return cSound::Paused;
case AL_PLAYING : return cSound::Playing;
case AL_STOPPED : return Sound::Stopped;
case AL_PAUSED : return Sound::Paused;
case AL_PLAYING : return Sound::Playing;
}
return cSound::Stopped;
return Sound::Stopped;
}
cTime cSound::PlayingOffset() const {
cTime Sound::PlayingOffset() const {
float secs = 0.f;
ALCheck( alGetSourcef( mSource, AL_SEC_OFFSET, &secs ) );
@@ -175,11 +175,11 @@ cTime cSound::PlayingOffset() const {
return Seconds( secs );
}
void cSound::PlayingOffset( const cTime &TimeOffset ) {
void Sound::PlayingOffset( const cTime &TimeOffset ) {
ALCheck( alSourcef( mSource, AL_SEC_OFFSET, TimeOffset.AsSeconds() ) );
}
cSound& cSound::operator =( const cSound& Other ) {
Sound& Sound::operator =( const Sound& Other ) {
if ( NULL != mBuffer ) {
Stop();
mBuffer->DetachSound( this );
@@ -202,17 +202,17 @@ cSound& cSound::operator =( const cSound& Other ) {
return *this;
}
void cSound::SetRelativeToListener( const bool& Relative ) {
void Sound::SetRelativeToListener( const bool& Relative ) {
ALCheck( alSourcei( mSource, AL_SOURCE_RELATIVE, Relative ) );
}
bool cSound::IsRelativeToListener() const {
bool Sound::IsRelativeToListener() const {
ALint Relative;
ALCheck( alGetSourcei( mSource, AL_SOURCE_RELATIVE, &Relative ) );
return Relative != 0;
}
void cSound::ResetBuffer() {
void Sound::ResetBuffer() {
// First stop the sound in case it is playing
Stop();
@@ -226,7 +226,7 @@ void cSound::ResetBuffer() {
}
}
cSound::Status cSound::State() const {
Sound::Status Sound::State() const {
return GetState();
}

52
src/eepp/audio/csoundbuffer.cpp → src/eepp/audio/soundbuffer.cpp
View File

@@ -1,14 +1,14 @@
#include <eepp/audio/csoundbuffer.hpp>
#include <eepp/audio/csound.hpp>
#include <eepp/audio/csoundfile.hpp>
#include <eepp/audio/caudiodevice.hpp>
#include <eepp/audio/soundbuffer.hpp>
#include <eepp/audio/sound.hpp>
#include <eepp/audio/soundfile.hpp>
#include <eepp/audio/audiodevice.hpp>
#include <eepp/system/cpackmanager.hpp>
#include <eepp/audio/openal.hpp>
#include <memory>
namespace EE { namespace Audio {
cSoundBuffer::cSoundBuffer() :
SoundBuffer::SoundBuffer() :
mBuffer(0),
mDuration()
{
@@ -17,7 +17,7 @@ cSoundBuffer::cSoundBuffer() :
ALCheck( alGenBuffers( 1, &mBuffer ) );
}
cSoundBuffer::cSoundBuffer(const cSoundBuffer& Copy) :
SoundBuffer::SoundBuffer(const SoundBuffer& Copy) :
mBuffer(0),
mSamples(Copy.mSamples),
mDuration(Copy.mDuration),
@@ -29,7 +29,7 @@ cSoundBuffer::cSoundBuffer(const cSoundBuffer& Copy) :
Update( Copy.GetChannelCount(), Copy.GetSampleRate() );
}
cSoundBuffer::~cSoundBuffer() {
SoundBuffer::~SoundBuffer() {
for ( SoundList::const_iterator it = mSounds.begin(); it != mSounds.end(); ++it )
(*it)->ResetBuffer();
@@ -37,7 +37,7 @@ cSoundBuffer::~cSoundBuffer() {
ALCheck( alDeleteBuffers( 1, &mBuffer ) );
}
bool cSoundBuffer::LoadFromFile(const std::string& Filename) {
bool SoundBuffer::LoadFromFile(const std::string& Filename) {
if ( !FileSystem::FileExists( Filename ) ) {
if ( cPackManager::instance()->FallbackToPacks() ) {
std::string tPath( Filename );
@@ -54,7 +54,7 @@ bool cSoundBuffer::LoadFromFile(const std::string& Filename) {
}
// Create the sound file
cSoundFile * File = cSoundFile::CreateRead( Filename );
SoundFile * File = SoundFile::CreateRead( Filename );
// Open the sound file
if ( NULL != File ) {
@@ -87,7 +87,7 @@ bool cSoundBuffer::LoadFromFile(const std::string& Filename) {
}
}
bool cSoundBuffer::LoadFromPack( cPack* Pack, const std::string& FilePackPath ) {
bool SoundBuffer::LoadFromPack( cPack* Pack, const std::string& FilePackPath ) {
bool Ret = false;
SafeDataPointer PData;
@@ -97,9 +97,9 @@ bool cSoundBuffer::LoadFromPack( cPack* Pack, const std::string& FilePackPath )
return Ret;
}
bool cSoundBuffer::LoadFromMemory( const char* Data, std::size_t SizeInBytes ) {
bool SoundBuffer::LoadFromMemory( const char* Data, std::size_t SizeInBytes ) {
// Create the sound file
cSoundFile * File = cSoundFile::CreateRead( Data, SizeInBytes );
SoundFile * File = SoundFile::CreateRead( Data, SizeInBytes );
// Open the sound file
if ( NULL != File ) {
@@ -131,7 +131,7 @@ bool cSoundBuffer::LoadFromMemory( const char* Data, std::size_t SizeInBytes ) {
}
}
bool cSoundBuffer::LoadFromSamples( const Int16 * Samples, std::size_t SamplesCount, unsigned int ChannelCount, unsigned int SampleRate ) {
bool SoundBuffer::LoadFromSamples( const Int16 * Samples, std::size_t SamplesCount, unsigned int ChannelCount, unsigned int SampleRate ) {
if ( Samples && SamplesCount && ChannelCount && SampleRate ) {
// Copy the new audio samples
mSamples.assign( Samples, Samples + SamplesCount );
@@ -147,9 +147,9 @@ bool cSoundBuffer::LoadFromSamples( const Int16 * Samples, std::size_t SamplesCo
}
}
bool cSoundBuffer::SaveToFile(const std::string& Filename) const {
bool SoundBuffer::SaveToFile(const std::string& Filename) const {
// Create the sound file in write mode
std::auto_ptr<cSoundFile> File( cSoundFile::CreateWrite( Filename, GetChannelCount(), GetSampleRate() ) );
std::auto_ptr<SoundFile> File( SoundFile::CreateWrite( Filename, GetChannelCount(), GetSampleRate() ) );
if ( File.get() ) {
// Write the samples to the opened file
@@ -162,32 +162,32 @@ bool cSoundBuffer::SaveToFile(const std::string& Filename) const {
}
}
const Int16* cSoundBuffer::GetSamples() const {
const Int16* SoundBuffer::GetSamples() const {
return mSamples.empty() ? NULL : &mSamples[0];
}
std::size_t cSoundBuffer::GetSamplesCount() const {
std::size_t SoundBuffer::GetSamplesCount() const {
return mSamples.size();
}
unsigned int cSoundBuffer::GetSampleRate() const {
unsigned int SoundBuffer::GetSampleRate() const {
ALint SampleRate;
ALCheck( alGetBufferi( mBuffer, AL_FREQUENCY, &SampleRate ) );
return SampleRate;
}
unsigned int cSoundBuffer::GetChannelCount() const {
unsigned int SoundBuffer::GetChannelCount() const {
ALint ChannelCount;
ALCheck( alGetBufferi( mBuffer, AL_CHANNELS, &ChannelCount ) );
return ChannelCount;
}
cTime cSoundBuffer::GetDuration() const {
cTime SoundBuffer::GetDuration() const {
return mDuration;
}
cSoundBuffer& cSoundBuffer::operator =( const cSoundBuffer& Other ) {
cSoundBuffer Temp( Other );
SoundBuffer& SoundBuffer::operator =( const SoundBuffer& Other ) {
SoundBuffer Temp( Other );
std::swap( mSamples , Temp.mSamples );
std::swap( mBuffer , Temp.mBuffer );
@@ -197,13 +197,13 @@ cSoundBuffer& cSoundBuffer::operator =( const cSoundBuffer& Other ) {
return *this;
}
bool cSoundBuffer::Update( unsigned int ChannelCount, unsigned int SampleRate ) {
bool SoundBuffer::Update( unsigned int ChannelCount, unsigned int SampleRate ) {
// Check parameters
if ( !SampleRate || !ChannelCount || mSamples.empty() )
return false;
// Find the good format according to the number of channels
ALenum Format = cAudioDevice::GetFormatFromChannelCount( ChannelCount );
ALenum Format = AudioDevice::GetFormatFromChannelCount( ChannelCount );
// Check if the format is valid
if ( Format == 0 ) {
@@ -228,11 +228,11 @@ bool cSoundBuffer::Update( unsigned int ChannelCount, unsigned int SampleRate )
return true;
}
void cSoundBuffer::AttachSound( cSound* sound ) const {
void SoundBuffer::AttachSound( Sound* sound ) const {
mSounds.insert(sound);
}
void cSoundBuffer::DetachSound( cSound* sound ) const {
void SoundBuffer::DetachSound( Sound* sound ) const {
mSounds.erase(sound);
}

54
src/eepp/audio/csoundfile.cpp → src/eepp/audio/soundfile.cpp
View File

@@ -1,29 +1,29 @@
#include <eepp/audio/csoundfile.hpp>
#include <eepp/audio/soundfile.hpp>
#ifdef EE_LIBSNDFILE_ENABLED
#include <eepp/audio/csoundfiledefault.hpp>
#include <eepp/audio/soundfiledefault.hpp>
#endif
#include <eepp/audio/csoundfileogg.hpp>
#include <eepp/audio/soundfileogg.hpp>
namespace EE { namespace Audio {
cSoundFile::cSoundFile() :
SoundFile::SoundFile() :
mSamplesCount (0),
mChannelCount(0),
mSampleRate (0)
{
}
cSoundFile::~cSoundFile()
SoundFile::~SoundFile()
{
}
cSoundFile * cSoundFile::CreateRead( const std::string& Filename ) {
SoundFile * SoundFile::CreateRead( const std::string& Filename ) {
// Create the file according to its type
cSoundFile * File = NULL;
SoundFile * File = NULL;
if ( cSoundFileOgg::IsFileSupported( Filename, true ) ) File = eeNew( cSoundFileOgg, () );
if ( SoundFileOgg::IsFileSupported( Filename, true ) ) File = eeNew( SoundFileOgg, () );
#ifdef EE_LIBSNDFILE_ENABLED
else if ( cSoundFileDefault::IsFileSupported( Filename, true ) ) File = eeNew( cSoundFileDefault, () );
else if ( SoundFileDefault::IsFileSupported( Filename, true ) ) File = eeNew( SoundFileDefault, () );
#endif
// Open it for reading
@@ -48,13 +48,13 @@ cSoundFile * cSoundFile::CreateRead( const std::string& Filename ) {
return File;
}
cSoundFile * cSoundFile::CreateRead( const char* Data, std::size_t SizeInMemory ) {
SoundFile * SoundFile::CreateRead( const char* Data, std::size_t SizeInMemory ) {
// Create the file according to its type
cSoundFile * File = NULL;
SoundFile * File = NULL;
if ( cSoundFileOgg::IsFileSupported( Data, SizeInMemory ) ) File = eeNew( cSoundFileOgg, () );
if ( SoundFileOgg::IsFileSupported( Data, SizeInMemory ) ) File = eeNew( SoundFileOgg, () );
#ifdef EE_LIBSNDFILE_ENABLED
else if ( cSoundFileDefault::IsFileSupported( Data, SizeInMemory ) ) File = eeNew( cSoundFileDefault, () );
else if ( SoundFileDefault::IsFileSupported( Data, SizeInMemory ) ) File = eeNew( SoundFileDefault, () );
#endif
// Open it for reading
@@ -79,13 +79,13 @@ cSoundFile * cSoundFile::CreateRead( const char* Data, std::size_t SizeInMemory
return File;
}
cSoundFile * cSoundFile::CreateWrite( const std::string& Filename, unsigned int ChannelCount, unsigned int SampleRate ) {
SoundFile * SoundFile::CreateWrite( const std::string& Filename, unsigned int ChannelCount, unsigned int SampleRate ) {
// Create the file according to its type
cSoundFile * File = NULL;
SoundFile * File = NULL;
if ( cSoundFileOgg::IsFileSupported( Filename, false ) ) File = eeNew( cSoundFileOgg, () );
if ( SoundFileOgg::IsFileSupported( Filename, false ) ) File = eeNew( SoundFileOgg, () );
#ifdef EE_LIBSNDFILE_ENABLED
else if ( cSoundFileDefault::IsFileSupported( Filename, false ) ) File = eeNew( cSoundFileDefault, () );
else if ( SoundFileDefault::IsFileSupported( Filename, false ) ) File = eeNew( SoundFileDefault, () );
#endif
// Open it for writing
@@ -106,20 +106,20 @@ cSoundFile * cSoundFile::CreateWrite( const std::string& Filename, unsigned int
return File;
}
std::size_t cSoundFile::GetSamplesCount() const
std::size_t SoundFile::GetSamplesCount() const
{
return mSamplesCount;
}
unsigned int cSoundFile::GetChannelCount() const {
unsigned int SoundFile::GetChannelCount() const {
return mChannelCount;
}
unsigned int cSoundFile::GetSampleRate() const {
unsigned int SoundFile::GetSampleRate() const {
return mSampleRate;
}
bool cSoundFile::Restart() {
bool SoundFile::Restart() {
if ( mData ) {
// Reopen from memory
return OpenRead( mData, mSize, mSamplesCount, mChannelCount, mSampleRate );
@@ -132,31 +132,31 @@ bool cSoundFile::Restart() {
}
}
bool cSoundFile::OpenRead(const std::string& Filename, std::size_t&, unsigned int&, unsigned int&) {
bool SoundFile::OpenRead(const std::string& Filename, std::size_t&, unsigned int&, unsigned int&) {
eePRINTL( "Failed to open sound file %s, format is not supported by eepp", Filename.c_str() );
return false;
}
bool cSoundFile::OpenRead(const char*, std::size_t, std::size_t&, unsigned int&, unsigned int&) {
bool SoundFile::OpenRead(const char*, std::size_t, std::size_t&, unsigned int&, unsigned int&) {
eePRINTL( "Failed to open sound file from memory, format is not supported by eepp" );
return false;
}
bool cSoundFile::OpenWrite(const std::string& Filename, unsigned int, unsigned int) {
bool SoundFile::OpenWrite(const std::string& Filename, unsigned int, unsigned int) {
eePRINTL( "Failed to open sound file %s, format is not supported by eepp", Filename.c_str() );
return false;
}
std::size_t cSoundFile::Read(Int16*, std::size_t) {
std::size_t SoundFile::Read(Int16*, std::size_t) {
eePRINTL( "Failed to read from sound file (not supported)" );
return 0;
}
void cSoundFile::Write(const Int16*, std::size_t) {
void SoundFile::Write(const Int16*, std::size_t) {
eePRINTL( "Failed to write to sound file (not supported)" );
}
void cSoundFile::Seek( cTime timeOffset ) {
void SoundFile::Seek( cTime timeOffset ) {
eePRINTL( "Trying to seek a file that doesn't support seeking." );
}

12
src/eepp/audio/csoundfile.hpp → src/eepp/audio/soundfile.hpp
View File

@@ -6,18 +6,18 @@
namespace EE { namespace Audio {
/** @brief Provide read and write access to sound files */
class EE_API cSoundFile {
class EE_API SoundFile {
public:
/** @brief Open a sound file for reading */
static cSoundFile * CreateRead(const std::string& Filename);
static SoundFile * CreateRead(const std::string& Filename);
/** @brief Open a sound file from memory for reading */
static cSoundFile * CreateRead(const char* Data, std::size_t SizeInBytes);
static SoundFile * CreateRead(const char* Data, std::size_t SizeInBytes);
/** @brief Open a sound file for writing */
static cSoundFile * CreateWrite(const std::string& Filename, unsigned int ChannelCount, unsigned int SampleRate);
static SoundFile * CreateWrite(const std::string& Filename, unsigned int ChannelCount, unsigned int SampleRate);
virtual ~cSoundFile();
virtual ~SoundFile();
/** @brief Get the total number of audio samples in the file */
std::size_t GetSamplesCount() const;
@@ -50,7 +50,7 @@ class EE_API cSoundFile {
** @param timeOffset New playing position, from the beginning of the file */
virtual void Seek( cTime timeOffset );
protected :
cSoundFile();
SoundFile();
virtual bool OpenRead(const std::string& Filename, std::size_t& SamplesCount, unsigned int& ChannelCount, unsigned int& SampleRate);

46
src/eepp/audio/csoundfiledefault.cpp → src/eepp/audio/soundfiledefault.cpp
View File

@@ -1,20 +1,20 @@
#include <eepp/audio/csoundfiledefault.hpp>
#include <eepp/audio/soundfiledefault.hpp>
#ifdef EE_LIBSNDFILE_ENABLED
namespace EE { namespace Audio {
cSoundFileDefault::cSoundFileDefault() :
SoundFileDefault::SoundFileDefault() :
mFile(NULL)
{
}
cSoundFileDefault::~cSoundFileDefault() {
SoundFileDefault::~SoundFileDefault() {
if ( NULL != mFile )
sf_close( mFile );
}
bool cSoundFileDefault::IsFileSupported( const std::string& Filename, bool Read ) {
bool SoundFileDefault::IsFileSupported( const std::string& Filename, bool Read ) {
if ( Read ) {
// Open the sound file
SF_INFO fileInfos;
@@ -33,7 +33,7 @@ bool cSoundFileDefault::IsFileSupported( const std::string& Filename, bool Read
}
}
bool cSoundFileDefault::IsFileSupported( const char* Data, std::size_t SizeInBytes ) {
bool SoundFileDefault::IsFileSupported( const char* Data, std::size_t SizeInBytes ) {
// Define the I/O custom functions for reading from memory
MemoryIO tMemoryIO;
SF_VIRTUAL_IO io = tMemoryIO.Prepare( Data, SizeInBytes );
@@ -51,7 +51,7 @@ bool cSoundFileDefault::IsFileSupported( const char* Data, std::size_t SizeInByt
return false;
}
bool cSoundFileDefault::OpenRead( const std::string& Filename, std::size_t& SamplesCount, unsigned int& ChannelCount, unsigned int& SampleRate ) {
bool SoundFileDefault::OpenRead( const std::string& Filename, std::size_t& SamplesCount, unsigned int& ChannelCount, unsigned int& SampleRate ) {
// If the file is already opened, first close it
if ( NULL != mFile )
sf_close( mFile );
@@ -78,7 +78,7 @@ bool cSoundFileDefault::OpenRead( const std::string& Filename, std::size_t& Samp
return true;
}
bool cSoundFileDefault::OpenRead( const char* Data, std::size_t SizeInBytes, std::size_t& SamplesCount, unsigned int& ChannelCount, unsigned int& SampleRate ) {
bool SoundFileDefault::OpenRead( const char* Data, std::size_t SizeInBytes, std::size_t& SamplesCount, unsigned int& ChannelCount, unsigned int& SampleRate ) {
// If the file is already opened, first close it
if ( NULL != mFile )
sf_close( mFile );
@@ -108,7 +108,7 @@ bool cSoundFileDefault::OpenRead( const char* Data, std::size_t SizeInBytes, std
return true;
}
bool cSoundFileDefault::OpenWrite( const std::string& Filename, unsigned int ChannelCount, unsigned int SampleRate ) {
bool SoundFileDefault::OpenWrite( const std::string& Filename, unsigned int ChannelCount, unsigned int SampleRate ) {
// If the file is already opened, first close it
if ( NULL != mFile )
sf_close( mFile );
@@ -138,26 +138,26 @@ bool cSoundFileDefault::OpenWrite( const std::string& Filename, unsigned int Cha
return true;
}
std::size_t cSoundFileDefault::Read( Int16 * Data, std::size_t SamplesCount ) {
std::size_t SoundFileDefault::Read( Int16 * Data, std::size_t SamplesCount ) {
if ( NULL != mFile && Data && SamplesCount )
return static_cast<std::size_t>( sf_read_short( mFile, Data, SamplesCount ) );
else
return 0;
}
void cSoundFileDefault::Write( const Int16 * Data, std::size_t SamplesCount ) {
void SoundFileDefault::Write( const Int16 * Data, std::size_t SamplesCount ) {
if ( NULL != mFile && Data && SamplesCount )
sf_write_short( mFile, Data, SamplesCount );
}
void cSoundFileDefault::Seek( cTime timeOffset ) {
void SoundFileDefault::Seek( cTime timeOffset ) {
if ( NULL != mFile ) {
sf_count_t frameOffset = static_cast<sf_count_t>( timeOffset.AsSeconds() * mSampleRate / 1000 );
sf_seek( mFile, frameOffset, SEEK_SET );
}
}
int cSoundFileDefault::GetFormatFromFilename(const std::string& Filename) {
int SoundFileDefault::GetFormatFromFilename(const std::string& Filename) {
// Extract the extension
std::string ext = "wav";
std::string::size_type Pos = Filename.find_last_of(".");
@@ -194,14 +194,14 @@ int cSoundFileDefault::GetFormatFromFilename(const std::string& Filename) {
return -1;
}
SF_VIRTUAL_IO cSoundFileDefault::MemoryIO::Prepare( const void * data, std::size_t sizeInBytes ) {
SF_VIRTUAL_IO SoundFileDefault::MemoryIO::Prepare( const void * data, std::size_t sizeInBytes ) {
// Setup the I/O functions
SF_VIRTUAL_IO io;
io.get_filelen = &cSoundFileDefault::MemoryIO::GetLength;
io.read = &cSoundFileDefault::MemoryIO::Read;
io.seek = &cSoundFileDefault::MemoryIO::Seek;
io.tell = &cSoundFileDefault::MemoryIO::Tell;
io.write = &cSoundFileDefault::MemoryIO::Write;
io.get_filelen = &SoundFileDefault::MemoryIO::GetLength;
io.read = &SoundFileDefault::MemoryIO::Read;
io.seek = &SoundFileDefault::MemoryIO::Seek;
io.tell = &SoundFileDefault::MemoryIO::Tell;
io.write = &SoundFileDefault::MemoryIO::Write;
// Initialize the memory data
mDataStart = static_cast<const char*>(data);
@@ -211,13 +211,13 @@ SF_VIRTUAL_IO cSoundFileDefault::MemoryIO::Prepare( const void * data, std::size
return io;
}
sf_count_t cSoundFileDefault::MemoryIO::GetLength( void* UserData ) {
sf_count_t SoundFileDefault::MemoryIO::GetLength( void* UserData ) {
MemoryIO * self = static_cast<MemoryIO*>(UserData);
return self->mTotalSize;
}
sf_count_t cSoundFileDefault::MemoryIO::Read( void* Ptr, sf_count_t Count, void* UserData ) {
sf_count_t SoundFileDefault::MemoryIO::Read( void* Ptr, sf_count_t Count, void* UserData ) {
MemoryIO * self = static_cast<MemoryIO*>(UserData);
sf_count_t Position = self->mDataPtr - self->mDataStart;
@@ -232,7 +232,7 @@ sf_count_t cSoundFileDefault::MemoryIO::Read( void* Ptr, sf_count_t Count, void*
return Count;
}
sf_count_t cSoundFileDefault::MemoryIO::Seek( sf_count_t Offset, int Whence, void* UserData ) {
sf_count_t SoundFileDefault::MemoryIO::Seek( sf_count_t Offset, int Whence, void* UserData ) {
MemoryIO * self = static_cast<MemoryIO*>(UserData);
sf_count_t Position = 0;
@@ -262,13 +262,13 @@ sf_count_t cSoundFileDefault::MemoryIO::Seek( sf_count_t Offset, int Whence, voi
return Position;
}
sf_count_t cSoundFileDefault::MemoryIO::Tell( void* UserData ) {
sf_count_t SoundFileDefault::MemoryIO::Tell( void* UserData ) {
MemoryIO * self = static_cast<MemoryIO*>(UserData);
return self->mDataPtr - self->mDataStart;
}
sf_count_t cSoundFileDefault::MemoryIO::Write( const void*, sf_count_t, void* ) {
sf_count_t SoundFileDefault::MemoryIO::Write( const void*, sf_count_t, void* ) {
return 0;
}

8
src/eepp/audio/csoundfiledefault.hpp → src/eepp/audio/soundfiledefault.hpp
View File

@@ -6,15 +6,15 @@
#ifdef EE_LIBSNDFILE_ENABLED
#include <sndfile.h>
#include <eepp/audio/csoundfile.hpp>
#include <eepp/audio/soundfile.hpp>
namespace EE { namespace Audio {
class EE_API cSoundFileDefault : public cSoundFile {
class EE_API SoundFileDefault : public SoundFile {
public :
cSoundFileDefault();
SoundFileDefault();
~cSoundFileDefault();
~SoundFileDefault();
/** Check if a given file is supported by this loader. */
static bool IsFileSupported(const std::string& Filename, bool Read);

18
src/eepp/audio/csoundfileogg.cpp → src/eepp/audio/soundfileogg.cpp
View File

@@ -1,20 +1,20 @@
#include <eepp/audio/csoundfileogg.hpp>
#include <eepp/audio/soundfileogg.hpp>
#include <eepp/helper/stb_vorbis/stb_vorbis.h>
namespace EE { namespace Audio {
cSoundFileOgg::cSoundFileOgg() :
SoundFileOgg::SoundFileOgg() :
mStream (NULL),
mChannelCount(0)
{
}
cSoundFileOgg::~cSoundFileOgg() {
SoundFileOgg::~SoundFileOgg() {
if ( NULL != mStream )
stb_vorbis_close( mStream );
}
bool cSoundFileOgg::IsFileSupported( const std::string& Filename, bool Read ) {
bool SoundFileOgg::IsFileSupported( const std::string& Filename, bool Read ) {
if ( Read ) {
// Open the vorbis stream
stb_vorbis* Stream = stb_vorbis_open_filename( const_cast<char*>( Filename.c_str() ), NULL, NULL );
@@ -28,7 +28,7 @@ bool cSoundFileOgg::IsFileSupported( const std::string& Filename, bool Read ) {
return false;
}
bool cSoundFileOgg::IsFileSupported( const char* Data, std::size_t SizeInBytes ) {
bool SoundFileOgg::IsFileSupported( const char* Data, std::size_t SizeInBytes ) {
// Open the vorbis stream
unsigned char* Buffer = reinterpret_cast<unsigned char*>( const_cast<char*>( Data ) );
int Length = static_cast<int>( SizeInBytes );
@@ -42,7 +42,7 @@ bool cSoundFileOgg::IsFileSupported( const char* Data, std::size_t SizeInBytes )
return false;
}
bool cSoundFileOgg::OpenRead( const std::string& Filename, std::size_t& SamplesCount, unsigned int& ChannelCount, unsigned int& SampleRate ) {
bool SoundFileOgg::OpenRead( const std::string& Filename, std::size_t& SamplesCount, unsigned int& ChannelCount, unsigned int& SampleRate ) {
// Close the file if already opened
if ( NULL != mStream )
stb_vorbis_close( mStream );
@@ -64,7 +64,7 @@ bool cSoundFileOgg::OpenRead( const std::string& Filename, std::size_t& SamplesC
return true;
}
bool cSoundFileOgg::OpenRead( const char* Data, std::size_t SizeInBytes, std::size_t& SamplesCount, unsigned int& ChannelCount, unsigned int& SampleRate ) {
bool SoundFileOgg::OpenRead( const char* Data, std::size_t SizeInBytes, std::size_t& SamplesCount, unsigned int& ChannelCount, unsigned int& SampleRate ) {
// Close the file if already opened
if ( NULL != mStream )
stb_vorbis_close( mStream );
@@ -89,7 +89,7 @@ bool cSoundFileOgg::OpenRead( const char* Data, std::size_t SizeInBytes, std::si
return true;
}
std::size_t cSoundFileOgg::Read( Int16 * Data, std::size_t SamplesCount ) {
std::size_t SoundFileOgg::Read( Int16 * Data, std::size_t SamplesCount ) {
if ( NULL != mStream && Data && SamplesCount ) {
int Read = stb_vorbis_get_samples_short_interleaved( mStream, mChannelCount, Data, static_cast<int>( SamplesCount ) );
@@ -101,7 +101,7 @@ std::size_t cSoundFileOgg::Read( Int16 * Data, std::size_t SamplesCount ) {
return 0;
}
void cSoundFileOgg::Seek( cTime timeOffset ) {
void SoundFileOgg::Seek( cTime timeOffset ) {
if ( NULL != mStream ) {
Uint32 frameOffset = static_cast<Uint32>( timeOffset.AsSeconds() * mSampleRate / 1000 );
stb_vorbis_seek( mStream, frameOffset );

8
src/eepp/audio/csoundfileogg.hpp → src/eepp/audio/soundfileogg.hpp
View File

@@ -2,16 +2,16 @@
#define EE_AUDIOCSOUNDFILEOGG_H
#include <eepp/audio/base.hpp>
#include <eepp/audio/csoundfile.hpp>
#include <eepp/audio/soundfile.hpp>
struct stb_vorbis;
namespace EE { namespace Audio {
class EE_API cSoundFileOgg : public cSoundFile {
class EE_API SoundFileOgg : public SoundFile {
public:
cSoundFileOgg();
~cSoundFileOgg();
SoundFileOgg();
~SoundFileOgg();
/** Check if a given file is supported by this loader. */
static bool IsFileSupported(const std::string& Filename, bool Read);

72
src/eepp/audio/csoundstream.cpp → src/eepp/audio/soundstream.cpp
View File

@@ -1,12 +1,12 @@
#include <eepp/audio/csoundstream.hpp>
#include <eepp/audio/caudiodevice.hpp>
#include <eepp/audio/soundstream.hpp>
#include <eepp/audio/audiodevice.hpp>
#include <eepp/system/sys.hpp>
#include <eepp/audio/openal.hpp>
using namespace EE::System;
namespace EE { namespace Audio {
cSoundStream::cSoundStream() :
SoundStream::SoundStream() :
mIsStreaming(false),
mChannelCount(0),
mSampleRate (0),
@@ -16,16 +16,16 @@ cSoundStream::cSoundStream() :
{
}
cSoundStream::~cSoundStream() {
SoundStream::~SoundStream() {
Stop(); // Stop the sound if it was playing
}
void cSoundStream::Initialize(unsigned int ChannelCount, unsigned int SampleRate) {
void SoundStream::Initialize(unsigned int ChannelCount, unsigned int SampleRate) {
mChannelCount = ChannelCount;
mSampleRate = SampleRate;
// Deduce the format from the number of channels
mFormat = cAudioDevice::GetFormatFromChannelCount(ChannelCount);
mFormat = AudioDevice::GetFormatFromChannelCount(ChannelCount);
if ( mFormat == 0 ) { // Check if the format is valid
mChannelCount = 0;
@@ -34,14 +34,14 @@ void cSoundStream::Initialize(unsigned int ChannelCount, unsigned int SampleRate
}
}
void cSoundStream::Play() {
void SoundStream::Play() {
if ( mFormat == 0 ) { // Check if the sound parameters have been set
eePRINTL( "Failed to play audio stream : sound parameters have not been initialized (call Initialize first)." );
return;
}
if ( mIsStreaming ) { // If the sound is already playing (probably paused), just resume it
cSound::Play();
Sound::Play();
return;
}
@@ -52,33 +52,33 @@ void cSoundStream::Play() {
Launch();
}
void cSoundStream::Pause() {
void SoundStream::Pause() {
ALCheck( alSourcePause( mSource ) );
}
void cSoundStream::Stop() {
void SoundStream::Stop() {
mIsStreaming = false; // Wait for the thread to terminate
Wait();
}
unsigned int cSoundStream::GetChannelCount() const {
unsigned int SoundStream::GetChannelCount() const {
return mChannelCount;
}
unsigned int cSoundStream::GetSampleRate() const {
unsigned int SoundStream::GetSampleRate() const {
return mSampleRate;
}
cSound::Status cSoundStream::GetState() const {
Status status = cSound::GetState();
Sound::Status SoundStream::GetState() const {
Status status = Sound::GetState();
if ( ( status == cSound::Stopped ) && mIsStreaming ) // To compensate for the lag between Play() and alSourcePlay()
status = cSound::Playing;
if ( ( status == Sound::Stopped ) && mIsStreaming ) // To compensate for the lag between Play() and alSourcePlay()
status = Sound::Playing;
return status;
}
cTime cSoundStream::PlayingOffset() const {
cTime SoundStream::PlayingOffset() const {
if ( mSampleRate && mChannelCount ) {
float secs = 0.f;
@@ -90,7 +90,7 @@ cTime cSoundStream::PlayingOffset() const {
return cTime::Zero;
}
void cSoundStream::PlayingOffset( const cTime &timeOffset ) {
void SoundStream::PlayingOffset( const cTime &timeOffset ) {
Status oldStatus = State();
// Stop the stream
@@ -114,15 +114,15 @@ void cSoundStream::PlayingOffset( const cTime &timeOffset ) {
}
}
void cSoundStream::Loop( const bool& Loop ) {
void SoundStream::Loop( const bool& Loop ) {
mLoop = Loop;
}
bool cSoundStream::Loop() const {
bool SoundStream::Loop() const {
return mLoop;
}
void cSoundStream::Run() {
void SoundStream::Run() {
ALCheck( alGenBuffers( BuffersCount, mBuffers ) );
for ( int i = 0; i < BuffersCount; ++i )
@@ -131,14 +131,14 @@ void cSoundStream::Run() {
// Fill the queue
bool RequestStop = FillQueue();
cSound::Play();
Sound::Play();
while ( mIsStreaming ) {
// The stream has been interrupted !
if ( cSound::GetState() == cSound::Stopped ) {
if ( Sound::GetState() == Sound::Stopped ) {
// User requested to stop : finish the streaming loop
if ( !RequestStop ) {
cSound::Play();
Sound::Play();
} else {
// Streaming is not completed : restart the sound
mIsStreaming = false;
@@ -147,12 +147,12 @@ void cSoundStream::Run() {
// Get the number of buffers that have been processed (ie. ready for reuse)
ALint NbProcessed = 0;
ALCheck( alGetSourcei( cSound::mSource, AL_BUFFERS_PROCESSED, &NbProcessed ) );
ALCheck( alGetSourcei( Sound::mSource, AL_BUFFERS_PROCESSED, &NbProcessed ) );
while ( NbProcessed-- ) {
// Pop the first unused buffer from the queue
ALuint Buffer;
ALCheck( alSourceUnqueueBuffers( cSound::mSource, 1, &Buffer ) );
ALCheck( alSourceUnqueueBuffers( Sound::mSource, 1, &Buffer ) );
// Find its number
Uint32 bufferNum = 0;
@@ -183,22 +183,22 @@ void cSoundStream::Run() {
}
// Leave some time for the other threads if the stream is still playing
if ( cSound::GetState() != cSound::Stopped )
if ( Sound::GetState() != Sound::Stopped )
Sys::Sleep(10);
}
// Stop the playback
cSound::Stop();
Sound::Stop();
// Unqueue any buffer left in the queue
ClearQueue();
// Delete the buffers
ALCheck( alSourcei( cSound::mSource, AL_BUFFER, 0 ) );
ALCheck( alSourcei( Sound::mSource, AL_BUFFER, 0 ) );
ALCheck( alDeleteBuffers( BuffersCount, mBuffers ) );
}
bool cSoundStream::FillAndPushBuffer( const unsigned int& Buffer ) {
bool SoundStream::FillAndPushBuffer( const unsigned int& Buffer ) {
bool RequestStop = false;
// Acquire audio data
@@ -233,13 +233,13 @@ bool cSoundStream::FillAndPushBuffer( const unsigned int& Buffer ) {
ALCheck( alBufferData( buffer, mFormat, Data.Samples, Size, mSampleRate ) );
// Push it into the sound queue
ALCheck( alSourceQueueBuffers( cSound::mSource, 1, &buffer ) );
ALCheck( alSourceQueueBuffers( Sound::mSource, 1, &buffer ) );
}
return RequestStop;
}
bool cSoundStream::FillQueue() {
bool SoundStream::FillQueue() {
// Fill and enqueue all the available buffers
bool RequestStop = false;
@@ -251,18 +251,18 @@ bool cSoundStream::FillQueue() {
return RequestStop;
}
void cSoundStream::ClearQueue() {
void SoundStream::ClearQueue() {
// Get the number of buffers still in the queue
ALint NbQueued;
ALCheck( alGetSourcei( cSound::mSource, AL_BUFFERS_QUEUED, &NbQueued ) );
ALCheck( alGetSourcei( Sound::mSource, AL_BUFFERS_QUEUED, &NbQueued ) );
// Unqueue them all
ALuint Buffer;
for ( ALint i = 0; i < NbQueued; ++i )
ALCheck( alSourceUnqueueBuffers( cSound::mSource, 1, &Buffer ) );
ALCheck( alSourceUnqueueBuffers( Sound::mSource, 1, &Buffer ) );
}
cSound::Status cSoundStream::State() const {
Sound::Status SoundStream::State() const {
return GetState();
}

4
src/eepp/graphics/cconsole.cpp
View File

@@ -1,7 +1,7 @@
#include <eepp/graphics/cconsole.hpp>
#include <eepp/window/cengine.hpp>
#include <eepp/graphics/renderer/cgl.hpp>
#include <eepp/audio/caudiolistener.hpp>
#include <eepp/audio/audiolistener.hpp>
#include <eepp/window/cinput.hpp>
#include <eepp/window/ccursormanager.hpp>
#include <eepp/window/cwindow.hpp>
@@ -728,7 +728,7 @@ void cConsole::CmdSetVolume( const std::vector < String >& params ) {
bool Res = String::FromString<Float>( tFloat, params[1] );
if ( Res && ( tFloat >= 0.0f && tFloat <= 100.0f ) ) {
EE::Audio::cAudioListener::GlobalVolume( tFloat );
EE::Audio::AudioListener::GlobalVolume( tFloat );
PrivPushText( "setvolume " + String::ToStr( tFloat ) );
return;
}

2
src/eepp/window/cengine.cpp
View File

@@ -9,7 +9,7 @@
#include <eepp/graphics/cframebuffermanager.hpp>
#include <eepp/graphics/cvertexbuffermanager.hpp>
#include <eepp/ui/cuimanager.hpp>
#include <eepp/audio/caudiolistener.hpp>
#include <eepp/audio/audiolistener.hpp>
#include <eepp/helper/haikuttf/hkfontmanager.hpp>
#include <eepp/physics/cphysicsmanager.hpp>
#include <eepp/network/ssl/csslsocket.hpp>

8
src/examples/sound/sound.cpp
View File

@@ -7,11 +7,11 @@ std::string AppPath = Sys::GetProcessPath();
void PlaySound() {
// The sound manager class simplyfies the load of a SoundBuffer and the creation of the Sound
// It manages the sound playing, if the sound channel is already playing, it will open a new channel to play the sound
cSoundManager SoundManager;
SoundManager SoundManager;
if ( SoundManager.LoadFromFile( "sound", AppPath + "assets/sounds/sound.ogg" ) ) {
// Get the sound buffer to display the buffer information
cSoundBuffer& buffer = SoundManager.GetBuffer( "sound" );
SoundBuffer& buffer = SoundManager.GetBuffer( "sound" );
// Display sound informations
std::cout << "sound.ogg :" << std::endl;
@@ -27,7 +27,7 @@ void PlaySound() {
/// Play a music
void PlayMusic() {
// Load an ogg music file
cMusic music;
Music music;
if (!music.OpenFromFile( AppPath + "assets/sounds/music.ogg" ) )
return;
@@ -42,7 +42,7 @@ void PlayMusic() {
music.Play();
// Loop while the music is playing
while ( music.State() == cSound::Playing ) {
while ( music.State() == Sound::Playing ) {
// Leave some CPU time for other processes
Sys::Sleep( 100 );

8
src/test/eetest.cpp
View File

@@ -91,7 +91,7 @@ void cEETest::Init() {
CreateShaders();
if ( mMusEnabled ) {
Mus = eeNew( cMusic, () );
Mus = eeNew( Music, () );
if ( Mus->OpenFromFile( MyPath + "sounds/music.ogg" ) ) {
Mus->Loop( true );
@@ -818,7 +818,7 @@ void cEETest::LoadTextures() {
}
#endif
mResLoad.Add( eeNew( cSoundLoader, ( &SndMng, "mysound", MyPath + "sounds/sound.ogg" ) ) );
mResLoad.Add( eeNew( SoundLoader, ( &SndMng, "mysound", MyPath + "sounds/sound.ogg" ) ) );
mResLoad.Load( cb::Make1( this, &cEETest::OnTextureLoaded ) );
@@ -1284,7 +1284,7 @@ void cEETest::Input() {
mWindow->FrameRateLimit( 10 );
if ( mMusEnabled && Mus->State() == cSound::Playing )
if ( mMusEnabled && Mus->State() == Sound::Playing )
Mus->Pause();
} else {
@@ -1300,7 +1300,7 @@ void cEETest::Input() {
mWindow->FrameRateLimit( mLastFPSLimit );
if ( mMusEnabled && Mus->State() == cSound::Paused )
if ( mMusEnabled && Mus->State() == Sound::Paused )
Mus->Play();
}

4
src/test/eetest.hpp
View File

@@ -121,8 +121,8 @@ class cEETest : private cThread {
bool iL1, iL2;
Float HWidth, HHeight;
cMusic * Mus;
cSoundManager SndMng;
Music * Mus;
SoundManager SndMng;
bool DrawBack;