#include <OpenALSimpleSound.h>

Inheritance diagram for Audio::OpenALSimpleSound:

Public Member Functions
	OpenALSimpleSound (const std::string &name, VSFileSystem::VSFileType type=VSFileSystem::UnknownFile) throw ()

ALBufferHandle	getAlBuffer () const

virtual	~OpenALSimpleSound ()

Public Member Functions inherited from Audio::SimpleSound
virtual	~SimpleSound ()

VSFileSystem::VSFileType	getType () const

Public Member Functions inherited from Audio::Sound
virtual	~Sound ()

const std::string &	getName () const throw ()

const Format &	getFormat () const throw ()

bool	isLoaded () const throw ()

bool	isLoading () const throw ()

bool	isStreaming () const throw ()

void	load (bool wait=true) throw (Exception)

void	unload () throw ()

Protected Member Functions
virtual void	loadImpl (bool wait) throw (Exception)

virtual void	unloadImpl () throw ()

Protected Member Functions inherited from Audio::SimpleSound
	SimpleSound (const std::string &name, VSFileSystem::VSFileType type=VSFileSystem::UnknownFile, bool streaming=false) throw ()

bool	isStreamLoaded () const

void	loadStream () throw (Exception)

void	closeStream () throw (ResourceNotLoadedException)

SharedPtr< Stream >	getStream () const throw (ResourceNotLoadedException)

void	readBuffer (SoundBuffer &buffer) throw (Exception)

virtual void	abortLoad () throw ()

Protected Member Functions inherited from Audio::Sound
	Sound (const std::string &name, bool streaming) throw ()

Format &	getFormat () throw ()

virtual void	onLoaded (bool success) throw ()

virtual void	waitLoad () throw (Exception)

Additional Inherited Members
Protected Attributes inherited from Audio::Sound
struct Audio::Sound::Flags	flags

Detailed Description

OpenAL Simple Sound implementation class

Remarks: This class implements simple (non-streaming) OpenAL sounds. This will load the whole sound into a single OpenAL buffer.

See Also: Sound, SimpleSound

Definition at line 25 of file OpenALSimpleSound.h.

Constructor & Destructor Documentation

Audio::OpenALSimpleSound::OpenALSimpleSound	(	const std::string &	name,
		VSFileSystem::VSFileType	type = `VSFileSystem::UnknownFile`
	)
throw	(
	)

Internal constructor used by derived classes

Definition at line 25 of file OpenALSimpleSound.cpp.

                 :
         SimpleSound(name, type, false),
         bufferHandle(AL_NULL_BUFFER)
     {
     }

Audio::OpenALSimpleSound::~OpenALSimpleSound ( )

virtual

Definition at line 32 of file OpenALSimpleSound.cpp.

33 {

34 }

Member Function Documentation

ALBufferHandle Audio::OpenALSimpleSound::getAlBuffer ( ) const

inline

Package-private: the OpenAL renderer package uses this, YOU DON'T

Definition at line 34 of file OpenALSimpleSound.h.

34 { return bufferHandle; }

void Audio::OpenALSimpleSound::loadImpl	(	bool	wait)
throw	(	Exception
	)

protectedvirtual

Load the resource

Note: Assume it is unloaded and not loading

Implements Audio::Sound.

Definition at line 36 of file OpenALSimpleSound.cpp.

References Audio::__impl::OpenAL::asALFormat(), Audio::Format::bitsPerSample, buffer, checkAlError, clearAlError, e, Audio::SoundBuffer::getBuffer(), Audio::SoundBuffer::getUsedBytes(), max(), VsnetOSS::memcpy(), Audio::Format::nativeOrder, Audio::SoundBuffer::optimize(), Audio::SoundBuffer::reserve(), Audio::Format::sampleFrequency, Audio::SoundBuffer::setUsedBytes(), Audio::Format::signedSamples, and Audio::SoundBuffer::swap().

     {
         // just in case
         unloadImpl();
         
         try {
         
             flags.loading = 1;
             
             // load the stream
             try {
                 loadStream();
             } catch(ResourceAlreadyLoadedException e) {
                 // Weird...
                 getStream()->seek(0);
             }
             SharedPtr<Stream> stream = getStream();
     
             // setup formatted buffer
             // if the format does not match an OpenAL built-in format, we must convert it.
             Format targetFormat = stream->getFormat();
             targetFormat.signedSamples = (targetFormat.bitsPerSample > 8);
             targetFormat.nativeOrder = 1;
             if (targetFormat.bitsPerSample > 8)
                 targetFormat.bitsPerSample = 16;
             else
                 targetFormat.bitsPerSample = 8;
             
             // Set capacity to half a second or 16k samples, whatever's bigger
             size_t bufferCapacity = 
                 std::max( 16384U, targetFormat.sampleFrequency/2 );
             
             // Prepare a list of buffers, we'll stack them here and later append them
             std::list<SoundBuffer> buffers;
             
             try {
                 while (true) {
                     // Prepare a new buffer
                     buffers.push_back(SoundBuffer());
                     SoundBuffer &buffer = buffers.back();
                     buffer.reserve(bufferCapacity, targetFormat);
                     
                     // Fill it in
                     readBuffer(buffer);
                     
                     // Make sure we're not wasting memory
                     buffer.optimize();
                     
                     // Break if there's no more data
                     if (buffer.getUsedBytes() == 0) {
                         buffers.pop_back();
                         break;
                     }
                 }
                 closeStream();
             } catch(EndOfStreamException e) {
                 closeStream();
             } catch(Exception e) {
                 closeStream();
                 throw e;
             }
             
             // Free the stream, asap
             stream.reset();
             
             // Collapse the chunks into a single buffer
             SoundBuffer buffer;
                 
             if (buffers.size() > 1) {
                 // Create a compound buffer with all buffers concatenated
                 { 
                     unsigned int finalBytes = 0;
                     for (std::list<SoundBuffer>::const_iterator it = buffers.begin(); it != buffers.end(); ++it)
                         finalBytes += it->getUsedBytes(); 
                     buffer.reserve(finalBytes);
                 }
                 
                 {
                     char* buf = (char*)buffer.getBuffer();
                     for (std::list<SoundBuffer>::const_iterator it = buffers.begin(); it != buffers.end(); ++it) {
                         memcpy(buf, it->getBuffer(), it->getUsedBytes());
                         buf += it->getUsedBytes();
                         buffer.setUsedBytes( buffer.getUsedBytes() + it->getUsedBytes() );
                     }
                 }
             } else if (buffers.size() > 0) {
                 buffer.swap(buffers.back());
             } else {
                 throw CorruptStreamException(true);
             }
             
             // Free the buffers, asap
             // The AL will copy to their own buffers, freeing now kind of makes certain
             // the AL will have enough memory to do so
             // (kind of since if memory is allocated off the DSP card, it could still fail)
             buffers.clear();
             
             // Send the data to the AL
             clearAlError();
             
             alGenBuffers(1,&bufferHandle); 
             checkAlError();
             
             alBufferData(bufferHandle, 
                 asALFormat(targetFormat), 
                 buffer.getBuffer(), buffer.getUsedBytes(), 
                 targetFormat.sampleFrequency);
             checkAlError();
             
             onLoaded(true);
         } catch(Exception e) {
             onLoaded(false);
             throw e;
         }
     }

void Audio::OpenALSimpleSound::unloadImpl	(	)
throw	(
	)

protectedvirtual

Unload the resource.

Note: Assume it is loaded

Implements Audio::Sound.

Definition at line 153 of file OpenALSimpleSound.cpp.

References AL_NULL_BUFFER.

     {
         if (bufferHandle == AL_NULL_BUFFER) 
             return;
         
         alDeleteBuffers(1, &bufferHandle);
         bufferHandle = AL_NULL_BUFFER;
     }

The documentation for this class was generated from the following files:

src/audio/renderers/OpenAL/OpenALSimpleSound.h
src/audio/renderers/OpenAL/OpenALSimpleSound.cpp

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation