fmodsoundio.cpp

使用stl技术,(还没看,是听说的)

// Conditional Build Step
#ifdef FMOD_AUDIO_BUILD
#include "OgrePrerequisites.h"
#include "FmodSoundIO.h"
#include "OgreTimer.h"
#include "OgreLogManager.h"
#include "OgreStringConverter.h"
#include "OgrePlatformManager.h"

namespace Ogre
{
	AudioClip::AudioClip() : mStream(0), mPaused(false), mChannel(0) 
	{
		mTimer = mTimer = PlatformManager::getSingleton().createTimer();
		if( !mTimer )
			throw;

		pauseTimeAdjustmentTotal = 0;
		pauseTimeAdjustmentStop = 0;
	}

	AudioClip::~AudioClip()
	{
		if(mTimer)
			PlatformManager::getSingleton().destroyTimer( mTimer );

		mTimer = 0;
	}

	void AudioClip::setAudioStreamPause( bool pause )
	{
		if( pause == mPaused )
			return;

		FSOUND_SetPaused( mChannel, pause );
		
		//This will replace this soon
		//mTimer->setPausedState( pause );

		if( pause == true )
			pauseTimeAdjustmentStop = getAudioStreamTime();
		else
			pauseTimeAdjustmentTotal += getAudioStreamTime() - pauseTimeAdjustmentStop;

		mPaused = pause;
	}

	float AudioClip::getAudioStreamTime()
	{
		//xxx: fix timer imprecision. ie, acount for blank audio, 
		//and buffer lag
		return mTimer->getMilliseconds() - pauseTimeAdjustmentTotal;
	}

	//--------------------------------------------------------------------------//
	bool AudioClip::openAudioStream( unsigned int sampleRate, 
									 eAudioSampleFormat sf,
									 unsigned int bufferSize,
									 unsigned int flags )
	{
		unsigned int mode = FSOUND_SIGNED;

		if( mStream )
			return false;
		
		if( sf == SF_16Bit )
			mode |= FSOUND_16BITS;

		if( flags & THEORA_AUDIOSTREAM_STEREO )
			mode |= FSOUND_STEREO;
		else
			mode |= FSOUND_MONO;

		mStream = FSOUND_Stream_Create( CustomStreamCallBack, 
										MY_FMOD_BUFF_SIZE, 
										mode, 
										sampleRate, 
										this);

		if( mStream )
			return true;			
		else
			return false;
	}

	//--------------------------------------------------------------------------//
	bool AudioClip::closeAudioStream()
	{
		if( mStream )
		{
			FSOUND_Stream_Stop( mStream );
			FSOUND_Stream_Close( mStream );
		}
		
		mChannel = 0;
		mPaused = true;
		mStream = 0;

		return true;
	}

	//--------------------------------------------------------------------------//
	bool AudioClip::startAudioStream()
	{
		mChannel = FSOUND_Stream_Play( FSOUND_FREE, mStream );
		mPaused = false;

		mTimer->reset();

		if( mChannel > 0 )
			return true;
		else
			return false;
	}
	
	//--------------------------------------------------------------------------//
	signed char F_CALLBACKAPI AudioClip::CustomStreamCallBack( 
										FSOUND_STREAM *stream, void *buff, int len, void *param )
	{
		AudioClip *pAudio = (AudioClip*)param;
		int numRead = pAudio->outFIFO.read( buff, len );
		
		// Zero out remainder of buffer if we run out of data
		if( numRead < len )
		{
			int temp = len - numRead;
			memset((char *)buff+numRead, 0, temp );
		}

		return 1;
	}
	
	//---------------------------------------------------------------------------//
	SoundManager::SoundManager()
	{
		if ( FSOUND_GetVersion() < FMOD_VERSION )
			throw;
	
		FSOUND_SetOutput(FSOUND_OUTPUT_DSOUND);		
		FSOUND_SetDriver(0);	//Primary
		FSOUND_SetSpeakerMode( FSOUND_SPEAKERMODE_SURROUND ); 
		FSOUND_SetMixer(FSOUND_MIXER_AUTODETECT);

		if (!FSOUND_Init(44100, 32, 0))
			throw;

		mAudioClip = 0;

	}
	
	//---------------------------------------------------------------------------//
	SoundManager::~SoundManager()
	{
		delete mAudioClip;
		FSOUND_Close();
	}

	AudioClip* SoundManager::getAudioClip()
	{
		assert( !mAudioClip );
		mAudioClip = new AudioClip;
		return mAudioClip;
	}
	
	void SoundManager::destroyAudioClip()
	{
		delete mAudioClip;
		mAudioClip = 0;
	}

} //end namespace

#endif //End if building fmod