TAudioBuffer.hpp

Go to the documentation of this file.

#ifndef __TAudioBuffer__
#define __TAudioBuffer__

//  ===========================================================================

#include <Basics/CCountedObject.hpp>
#include <MathTools/CMathTools.hpp>
#include <Collections/TAutomaticPointer.hpp>
using Exponent::MathTools::CMathTools;
using Exponent::Basics::CCountedObject;
using Exponent::Collections::TAutomaticPointer;

//  ===========================================================================

namespace Exponent
{
    namespace Audio
    {
        template<typename TypeName> class TAudioBuffer : public CCountedObject
        {
            EXPONENT_CLASS_DECLARATION;
//  ===========================================================================

        public:

//  ===========================================================================

            typedef TAutomaticPointer< TAutomaticPointer<TypeName> > TAudioBufferPointer;

//  ===========================================================================

            TAudioBuffer() : m_buffer(NULL), m_numberOfSamples(0), m_numberOfChannels(0), m_bufferSize(0)
            {
                NULL_POINTER(m_buffer);
                m_numberOfSamples  = 0;
                m_numberOfChannels = 0;
                m_bufferSize       = 0;
            }

            virtual ~TAudioBuffer()
            {
                this->uninitialise();
            }

//  ===========================================================================


            bool initialise(const unsigned long numberOfSamples, const unsigned long numberOfChannels)
            {
                // Delete the old buffer
                if (m_buffer)
                {
                    this->uninitialise();
                }

                // Total size of the buffer
                m_numberOfSamples  = numberOfSamples;
                m_numberOfChannels = numberOfChannels;
                m_bufferSize       = m_numberOfSamples * m_numberOfChannels;

                // Create the buffer
                m_buffer = new TypeName[m_bufferSize];

                // Clear the audio buffers out
                this->clearBuffer();

                // We are done :)
                return true;
            }

            void uninitialise()
            {
                // Check we've got a buffer
                if (m_buffer)
                {
                    // Delete the main buffer
                    FREE_ARRAY_POINTER(m_buffer);

                    // Default values
                    m_numberOfChannels = 0;
                    m_numberOfSamples  = 0;
                    m_bufferSize       = 0;
                }
            }

            void clearBuffer()
            {
                // Check we've got a buffer
                if (m_buffer)
                {
                    memset(m_buffer, 0, m_bufferSize * sizeof(TypeName));
                }
            }

//  ===========================================================================

            const TypeName *operator[](const long index) const
            {
                return this->getChannel(index);
            }

//  ===========================================================================

            const TypeName *getChannel(const unsigned long index) const
            {
                if (m_buffer && index < m_numberOfChannels)
                {
                    return &m_buffer[index];
                }
                return NULL;
            }

            TypeName *getMutableChannel(const unsigned long index)
            {
                if (m_buffer && index < m_numberOfChannels)
                {
                    return &m_buffer[index];
                }
                return NULL;
            }

            const TypeName *getData() const
            {
                if (m_buffer)
                {
                    return m_buffer;
                }
                return NULL;
            }

            TypeName *getMutableData()
            {
                if (m_buffer)
                {
                    return m_buffer;
                }
                return NULL;
            }

//  ===========================================================================

            FORCEINLINE unsigned long getNumberOfChannels() const { return m_numberOfChannels; }

            FORCEINLINE unsigned long getNumberOfSamples() const { return m_numberOfSamples; }

            FORCEINLINE unsigned long getBufferSize() const { return m_bufferSize; }

            FORCEINLINE unsigned long getSampleFrameSize() const { return m_numberOfChannels; }

//  ===========================================================================

            TypeName getMaximumSample(const unsigned long channel) const
            {
                if (channel < m_numberOfChannels && m_buffer)
                {
                    TypeName *buffer  = &m_buffer[channel];
                    TypeName maxValue = -2.0;   // Well outside of range
                    for (long i = 0; i < m_numberOfSamples; i++)
                    {
                        maxValue = CMathTools::fastMaximum(*buffer, maxValue);
                        buffer  += m_numberOfChannels;
                    }
                    return maxValue;
                }
                return (TypeName)0;
            }

            TypeName getMinimumSample(const unsigned long channel) const
            {
                if (channel < m_numberOfChannels && m_buffer)
                {
                    TypeName *buffer  = &m_buffer[channel];
                    TypeName minValue = 2.0;    // Well outside of range
                    for (long i = 0; i < m_numberOfSamples; i++)
                    {
                        minValue = CMathTools::fastMinimum(*buffer, minValue);
                        buffer  += m_numberOfChannels;
                    }
                    return minValue;
                }
                return (TypeName)0;
            }

            FORCEINLINE TypeName getRMSLevel(const unsigned long channel, const unsigned long numberOfSamples, const unsigned long startSample = 0) const
            {
                if (channel < m_numberOfChannels && m_buffer && numberOfSamples <= m_numberOfSamples && startSample + numberOfSamples <= m_numberOfSamples)
                {
                    TypeName mean = 0.0;
                    const TypeName *theChannel = &m_buffer[channel + (this->getSampleFrameSize() * startSample)];

                    // Compute the squares
                    for (unsigned long i = 0; i < numberOfSamples; i++)
                    {
                        mean += *theChannel * *theChannel;
                        theChannel += this->getSampleFrameSize();
                    }

                    // Return the RMS
                    return sqrt(mean / (TypeName)numberOfSamples);
                }
                return (TypeName)0;
            }

            void denormal()
            {
                // Check the buffer is valid
                if (m_buffer == NULL)
                {
                    return;
                }

                // Loop and apply the denormalling..
                for (unsigned long i = 0; i < m_bufferSize; i++)
                {
                    m_buffer[i] += (TypeName)1e-15;
                }
            }

            bool mergeChannelsToMono()
            {
                // Check we have an audio buffer
                if (m_buffer == NULL)
                {
                    return false;
                }

                // Check if we are mono already
                if (m_numberOfChannels <= 1)
                {
                    return true;        // We it is a sucess really ;)
                }

                // Compute the level of each channel
                const TypeName level = 1.0 / (TypeName)m_numberOfChannels;

                // Store the internal buffer
                TypeName *buffer = new TypeName[m_numberOfSamples];             // Note single channel!!
                memset(buffer, 0, m_numberOfSamples * sizeof(TypeName));
                TypeName *bufferPointer = &m_buffer[0];

                // Merge the samples
                for (unsigned long i = 0; i < m_numberOfSamples; i++)
                {
                    for (unsigned long j = 0; j < m_numberOfChannels; j++)
                    {
                        buffer[i] += *bufferPointer++ * level;
                    }
                }

                // Delete the old buffer
                FREE_POINTER(m_buffer);

                // Store the new buffer
                m_buffer = buffer;

                // Set the number of channels
                m_numberOfChannels = 1;
                m_bufferSize       = m_numberOfSamples;

                // We are complete!
                return true;
            }

            bool copySamples(const TypeName *buffer, const unsigned long numberOfSamples)
            {
                // Check if we have room
                if (numberOfSamples <= m_numberOfSamples * m_numberOfChannels && m_buffer)
                {
                    // Copy the buffer
                    memcpy(m_buffer, buffer, numberOfSamples * sizeof(TypeName));

                    // Complete!
                    return true;
                }

                // Failed
                return false;
            }

            bool mergeChannelToBuffer(float *buffer, const unsigned long startSample, const unsigned long numberOfSamples, const unsigned long channel)
            {
                // Compute the length to process
                const unsigned long length = startSample + numberOfSamples;

                // Check for the validity
                if (length <= m_numberOfSamples && channel < m_numberOfChannels && buffer != NULL)
                {
                    //&m_buffer[index];

                    // Get the audio data
                    const TypeName *audioData = &m_buffer[channel][startSample * m_numberOfChannels];

                    // Check we got proper audio data
                    if (audioData == NULL)
                    {
                        return false;
                    }

                    // Now loop through and process
                    for (unsigned long i = 0; i < numberOfSamples; i++)
                    {
                        buffer[i] += (float)*audioData;
                        audioData += m_numberOfChannels;
                    }

                    // Sucess
                    return true;
                }

                // Failed
                return false;
            }

            bool mergeChannelToBuffer(double *buffer, const unsigned long startSample, const unsigned long numberOfSamples, const unsigned long channel)
            {
                // Compute the length to process
                const unsigned long length = startSample + numberOfSamples;

                // Check for the validity
                if (length <= m_numberOfSamples && channel < m_numberOfChannels && buffer != NULL)
                {
                    //&m_buffer[index];

                    // Get the audio data
                    const TypeName *audioData = &m_buffer[startSample * m_numberOfChannels];

                    // Now loop through and process
                    for (unsigned long i = 0; i < numberOfSamples; i++)
                    {
                        buffer[i] += (double)*audioData;
                        audioData += m_numberOfChannels;
                    }

                    // Sucess
                    return true;
                }

                // Failed
                return false;
            }

//  ===========================================================================

        protected:

//  ===========================================================================

            TypeName *m_buffer;                 
            unsigned long m_numberOfSamples;    
            unsigned long m_numberOfChannels;   
            unsigned long m_bufferSize;         
//  ===========================================================================

        };

        typedef TAudioBuffer<double> TDoublePrecisionAudioBuffer;

        typedef TAudioBuffer<float> TSinglePrecisionAudioBuffer;

         EXPONENT_TEMPLATE_CLASS_IMPLEMENTATION(TAudioBuffer<TypeName>, TypeName, CCountedObject);
    }
}
#endif  // End of TAudioBuffer.hpp

---