CAudioBuffer.hpp

Go to the documentation of this file.

#ifndef __CAudioBuffer__
#define __CAudioBuffer__

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

#include <Basics/CCountedObject.hpp>
#include <Exceptions/CException.hpp>
#include <MathTools/CMathTools.hpp>

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

using Exponent::Basics::CCountedObject;
using Exponent::Exceptions::CException;
using Exponent::MathTools::CMathTools;

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

namespace Exponent
{
    namespace Audio
    {
        class CAudioBuffer : public CCountedObject
        {
            EXPONENT_CLASS_DECLARATION;
//  ===========================================================================

        public:

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

            const static double CAUDIO_BUFFER_DENORMAL;     
//  ===========================================================================

            enum EStereoChannels
            {
                e_left = 0,     
                e_right,        
                e_mono = 1,     
                e_stereo,       
            };

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

            CAudioBuffer(const long bufferSize);

            CAudioBuffer();

            virtual ~CAudioBuffer();

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

            double **getMutableAudioData() const { return m_waveData; }

            const double **getAudioData() const { return (const double **)&m_waveData[0]; }

            FORCEINLINE double *getChannel(const long channel) { return m_waveData[channel]; }

            FORCEINLINE double getSample(const long channel, const long index) { return m_waveData[channel][index]; }

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

            void initialise(const long bufferSize);

            void uninitialise();

            void reInitialise(const long bufferSize);

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

            void FORCEINLINE clearWaveForm()
            {
                const size_t size = m_bufferSize * sizeof(double);
                memset(m_waveData[0], 0, size);
                memset(m_waveData[1], 0, size);
            }

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

            void FORCEINLINE mergeChannels()
            {
                for (long i = 0; i < m_bufferSize; i++)
                {
                    m_waveData[0][i] = m_waveData[1][i] = ((m_waveData[0][i] * 0.5) + (m_waveData[1][i] * 0.5));
                }
            }

            void FORCEINLINE mergeWithBuffer(CAudioBuffer *buffer)
            {
                if (buffer->getBufferSize() != m_bufferSize)
                {
                    throw CException("Buffer sizes do not match", "CAudioBuffer::mergeWithBuffer(CAudioBuffer *)");
                }

                double *left   = m_waveData[0];
                double *right  = m_waveData[1];
                double *leftF  = buffer->getChannel(e_left);
                double *rightF = buffer->getChannel(e_right);

                for (long i = 0; i < m_bufferSize; i++)
                {
                    left[i]  += leftF[i];
                    right[i] += rightF[i];
                }
            }

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

            void FORCEINLINE accumulateInToFloatData(float **output, const long numberOfSamples)
            {
                double *left  = m_waveData[0];
                double *right = m_waveData[1];
                float *leftF  = output[0];
                float *rightF = output[1];

                for (long i = 0; i < numberOfSamples; i++)
                {
                    leftF[i]  += (float)left[i];
                    rightF[i] += (float)right[i];
                }
            }

            void FORCEINLINE mergeToBuffer(double *output, const long numberOfSamples)
            {
                if (output == NULL)
                {
                    throw CException("Output buffer is NULL", "CAudioBuffer::mergeToBuffer(double *, const long)");
                }

                double *left  = m_waveData[0];
                double *right = m_waveData[1];

                for (long i = 0; i < numberOfSamples; i++)
                {
                    output[i] = (left[i] * 0.5) + (right[i] * 0.5);
                }
            }

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

            long getBufferSize() const { return m_bufferSize; }

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

            void FORCEINLINE setFromAudioBuffer(CAudioBuffer *buffer)
            {
                if (buffer->getBufferSize() != m_bufferSize)
                {
                    throw CException("Buffer sizes do not match", "CAudioBuffer::setFromAudioBuffer(CAudioBuffer *)");
                }

                memcpy(m_waveData[0], buffer->getChannel(e_left),  m_bufferSize * sizeof(double));
                memcpy(m_waveData[1], buffer->getChannel(e_right), m_bufferSize * sizeof(double));
            }

            void FORCEINLINE setWaveDataFromFloatData(float **waveData, const long numberOfSamples)
            {
                double *left  = m_waveData[0];
                double *right = m_waveData[1];

                float *leftF  = waveData[0];
                float *rightF = waveData[1];

                for (long i = 0; i < numberOfSamples; i++)
                {
                    left[i]  = (double)leftF[i];
                    right[i] = (double)rightF[i];
                }
            }

            void FORCEINLINE setWaveDataFromFloatDataAndDenormal(float **waveData, const long numberOfSamples)
            {
                double *left  = m_waveData[0];
                double *right = m_waveData[1];

                float *leftF  = waveData[0];
                float *rightF = waveData[1];

                for (long i = 0; i < numberOfSamples; i++)
                {
                    left[i]  = (double)leftF[i]  + CAUDIO_BUFFER_DENORMAL;
                    right[i] = (double)rightF[i] + CAUDIO_BUFFER_DENORMAL;
                }
            }

            void FORCEINLINE copyToFloatBufferFromWaveData(float **waveData, const long numberOfSamples)
            {
                double *left  = m_waveData[0];
                double *right = m_waveData[1];

                float *leftF  = waveData[0];
                float *rightF = waveData[1];

                for (long i = 0; i < numberOfSamples; i++)
                {
                    leftF[i]  = (float)left[i];
                    rightF[i] = (float)right[i];
                }
            }

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

            void FORCEINLINE denormal(const long numberOfSamples)
            {
                double *left  = m_waveData[0];
                double *right = m_waveData[1];
                for (long i = 0; i < numberOfSamples; i++)
                {
                    left[i]  += CAUDIO_BUFFER_DENORMAL;
                    right[i] += CAUDIO_BUFFER_DENORMAL;
                }
            }

            void FORCEINLINE changeGain(const double volume)
            {
                double *left  = m_waveData[0];
                double *right = m_waveData[1];
                for (long i = 0; i < m_bufferSize; i++)
                {
                    left[i]  *= volume;
                    right[i] *= volume;
                }
            }

            void getMaxSamples(double &left, double &right);

            void FORCEINLINE applyTanhLimiting()
            {
                double *left  = m_waveData[0];
                double *right = m_waveData[1];
                for (long i = 0; i < m_bufferSize; i++)
                {
                    left[i]  = CMathTools::tanhApproximation(left[i]);
                    right[i] = CMathTools::tanhApproximation(right[i]);
                }
            }

            FORCEINLINE static double computeRMS(const double *buffer, const long numberOfSamplesToProcess)
            {
                // Compute the squares
                double mean1 = 0.0, mean2 = 0.0, mean3 = 0.0, mean4 = 0.0;
                for (long i = 0; i < numberOfSamplesToProcess - 4; i+=4)
                {
                    mean1 += buffer[i]     * buffer[i];
                    mean2 += buffer[i + 1] * buffer[i + 1];
                    mean3 += buffer[i + 2] * buffer[i + 2];
                    mean4 += buffer[i + 3] * buffer[i + 3];
                }
                /*for (long i = 0; i < numberOfSamplesToProcess; i++)
                {
                    mean += buffer[i] * buffer[i];
                }*/
                return sqrt((mean1 + mean2 + mean3 + mean4) / numberOfSamplesToProcess);

                // Compute the mean
                //mean /= numberOfSamplesToProcess;

                // Return the RMS
                //return sqrt(mean);
            }

            FORCEINLINE static double computeRMS(const float *buffer, const long numberOfSamplesToProcess)
            {
                // Compute the squares
                double mean = 0.0;
                for (long i = 0; i < numberOfSamplesToProcess; i++)
                {
                    mean += (double)(buffer[i] * buffer[i]);
                }

                // Compute the mean
                mean /= numberOfSamplesToProcess;

                // Return the RMS
                return sqrt(mean);
            }

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

        protected:

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

            double **m_waveData;        
            long m_bufferSize;          
        };
    }
}

#endif  // End of CAudioBuffer.hpp

---