KrotosAudioBuffer.h

Go to the documentation of this file.

/*
==============================================================================
 
KrotosAudioBuffer.h
Created: 26 June 2018 16:23:00am
Author:  sandyw
 
==============================================================================
*/
 
#pragma once
 
namespace krotos
{
    class StereoSample
    {
      public:
        // Overload + operator to add two StereoSample objects
        inline StereoSample operator+(const StereoSample& b)
        {
            StereoSample ssamp;
            ssamp.left = this->left + b.left;
            ssamp.right = this->right + b.right;
            return ssamp;
        }
        // Overload += operator to add two StereoSample objects
        inline StereoSample operator+=(const StereoSample& b)
        {
            this->left += b.left;
            this->right += b.right;
            return *this;
        }
        // Overload - operator to subtract two StereoSample objects
        inline StereoSample operator-(const StereoSample& b)
        {
            StereoSample ssamp;
            ssamp.left = this->left - b.left;
            ssamp.right = this->right - b.right;
            return ssamp;
        }
        // Overload * operator to multiply two StereoSample objects
        inline StereoSample operator*(const StereoSample& b)
        {
            StereoSample ssamp;
            ssamp.left = this->left * b.left;
            ssamp.right = this->right * b.right;
            return ssamp;
        }
        // Overload / operator to divide two StereoSample objects
        inline StereoSample operator/(const StereoSample& b)
        {
            StereoSample ssamp;
            ssamp.left = this->left / b.left;
            ssamp.right = this->right / b.right;
            return ssamp;
        }
        // Overload * operator to multiply a StereoSample object by a float
        inline StereoSample operator*(float b)
        {
            StereoSample ssamp;
            ssamp.left = this->left * b;
            ssamp.right = this->right * b;
            return ssamp;
        }
        // Overload / operator to divide a StereoSample object by a float
        inline StereoSample operator/(float b)
        {
            StereoSample ssamp;
            ssamp.left = this->left / b;
            ssamp.right = this->right / b;
            return ssamp;
        }
        // Pan left/right using linear law - equal combined amplitude - this is going to audibly dip in the centre
        inline StereoSample panLinear(float pan)
        {
            StereoSample ssamp;
            ssamp.left = this->left * (1.f - pan);
            ssamp.right = this->right * pan;
            return ssamp;
        }
        // Pan left/right using square law - equal-combined power across both channels
        inline StereoSample panSquare(float pan)
        {
            StereoSample ssamp;
            ssamp.left = this->left * sqrt(1.f - pan);
            ssamp.right = this->right * sqrt(pan);
            return ssamp;
        }
        // Pan left/right using sine law - alternative equal-combined power across both channels
        inline StereoSample panSine(float pan)
        {
            StereoSample ssamp;
            ssamp.left = this->left * sinf((1.f - pan) * MathConstants<float>::halfPi);
            ssamp.right = this->right * sinf(pan * MathConstants<float>::halfPi);
            return ssamp;
        }
        // Adjust the width of the stereo field
        inline StereoSample width(float width)
        {
            StereoSample ssamp;
            float mono = (1.0f - width) * 0.5f * (this->left + this->right);
            ssamp.left = this->left * width + mono;
            ssamp.right = this->right * width + mono;
            return ssamp;
        }
 
        float left{0.f}, right{0.f};
    };
 
    class KrotosAudioBuffer : public juce::AudioBuffer<float>
    {
      public:
        enum BufferType
        {
            Samples = 0,
            Spectral
        };
 
        enum InterpolationType
        {
            Linear = 0,
            Cubic,
            Cosine,
            Cubic3d,
            NUM_TYPES
        };
 
        KrotosAudioBuffer();
        KrotosAudioBuffer(int channels, int size);
 
        explicit KrotosAudioBuffer(const AudioBuffer<float>& buffer) : AudioBuffer<float>(buffer) {}
 
        explicit KrotosAudioBuffer(const AudioBuffer<float>& buffer, int numOfChannels);
 
        ~KrotosAudioBuffer();
 
        float getPeak(int channel) const;
        float getRMS(int channel) const;
 
        void setSize(int newNumChannels, int numSamples, bool keepExistingContent = true, bool clearExtraSpace = true,
                     bool avoidReallocating = true);
 
        void setSize(KrotosAudioBuffer& prototypeBuffer);
        void copyFrom(int destChannel, const float* source, int numSamples);
        void copyFrom(KrotosAudioBuffer& sourceBuffer);
        void addFrom(int destChannel, const float* source, int numSamples);
        void addFrom(KrotosAudioBuffer& srcBuffer);
        void processWetDry(KrotosAudioBuffer& wetBuffer, SmoothedFloat& wetDryValue);
        void processGain(SmoothedFloat& gainFactor);
        void processGain(float gainFactor);
        void processPan(SmoothedFloat& panValue);
        bool processClamp(float clampValue);
        void fillWithNoise();
        void processMute(MuteStateMachine& state);
        void setDataValid(bool state);
        bool isDataValid() const;
        void setSampleRate(float sampleRate);
        float getSampleRate(void);
        void setSourceSampleRate(float sampleRate);
        float getSourceSampleRate(void);
        float getNativeNoteFrequency(void);
        void setInterpolationType(InterpolationType newInterpolationType);
        StereoSample makeRamp(StereoSample startValue, int samples);
        StereoSample getLastSample();
        StereoSample getInterpolatedSample(double index);
        float getInterpolatedSampleMono(float playHead);
        KrotosAudioBuffer getMonoBuffer();
        static KrotosAudioBuffer mixToMono(KrotosAudioBuffer& multiChannelBuffer);
 
        void reverse(int channel, int startSample, int numSamples);
        void reverse(int startSample, int numSamples);
        juce::AudioBuffer<float>& getJuceAudioBuffer();
 
        void equalPowerCrossFadeFrom(const KrotosAudioBuffer& previousBuffer);
 
        float findAbsMax();
 
        void normaliseTo(float scale);
 
        /*
        void setGainModIndicator(float val)
        {
            m_gainModIndicator = m_gainModIndicator * 0.99f + val * 0.01f;
        }
 
        float getGainModIndicator()
        {
            return m_gainModIndicator;
        }
        */
 
      private:
        float getCubic3dInterpolationSample(double playhead, const float* buffer);
        float getCosineInterpolationSample(double playhead, const float* buffer);
        float getCubicInterpolationSample(double playhead, const float* buffer);
 
        bool m_isDataValid{true};
 
        InterpolationType m_interpoltationType{InterpolationType::Cubic3d};
        float m_sampleRate{48000.0f};
        float m_sourceSampleRate{48000.0f};
        // volatile std::atomic<float> m_gainModIndicator{ 0.f };
 
        // Frequences of notes in Hz, equal tempered scale, A4 = 440 Hz
        static const float FREQ_Hz_NOTE_C3;
        static const float FREQ_Hz_NOTE_D3;
        static const float FREQ_Hz_NOTE_C4;
    };
 
} // namespace krotos