KrotosAudioBuffer.cpp

Go to the documentation of this file.

#include "KrotosAudioBuffer.h"
 
namespace krotos
{
    static const int START_SAMPLE{0};
 
    KrotosAudioBuffer::KrotosAudioBuffer() {}
    KrotosAudioBuffer::KrotosAudioBuffer(int channels, int size) : AudioBuffer<float>(channels, size) { clear(); }
    KrotosAudioBuffer::KrotosAudioBuffer(const AudioBuffer<float>& buffer, int numOfChannels)
        : AudioBuffer<float>(buffer)
    {
        AudioBuffer<float>::setSize(numOfChannels, getNumSamples(), false, true, false);
        clear(); // setSize should have cleared, but no harm in making sure
    }
 
    KrotosAudioBuffer::~KrotosAudioBuffer() {}
 
    float KrotosAudioBuffer::getPeak(int channel) const { return getMagnitude(channel, START_SAMPLE, getNumSamples()); }
 
    float KrotosAudioBuffer::getRMS(int channel) const
    {
        return AudioBuffer<float>::getRMSLevel(channel, START_SAMPLE, getNumSamples());
    }
 
    void KrotosAudioBuffer::setSize(int newNumChannels, int numSamples, bool keepExistingContent, bool clearExtraSpace,
                                    bool avoidReallocating)
    {
        AudioBuffer<float>::setSize(newNumChannels, numSamples, keepExistingContent, clearExtraSpace,
                                    avoidReallocating);
    }
 
    void KrotosAudioBuffer::setSize(KrotosAudioBuffer& prototypeBuffer)
    {
        setSize(prototypeBuffer.getNumChannels(), prototypeBuffer.getNumSamples());
    }
 
    void KrotosAudioBuffer::fillWithNoise()
    {
        Random randomNumber;
        for (int i = 0; i < getNumChannels(); ++i)
        {
            for (int sample = 0; sample < getNumSamples(); ++sample)
            {
                getWritePointer(i)[sample] = (randomNumber.nextFloat() - 0.5f) * 2;
            }
        }
    }
 
    void KrotosAudioBuffer::processMute(MuteStateMachine& state)
    {
        if (state.isNotRamping())
            return; // If we are not ramping up or down, then we return
 
        float startValue = 0.0f;
        float increment = 1.0f / static_cast<float>(getNumSamples());
 
        if (state.isRampingDown())
        {
            startValue = 1.0f;
            increment = -increment;
        }
 
        for (int i = 0; i < getNumChannels(); ++i)
        {
            float attenuation = startValue;
            for (int sample = 0; sample < getNumSamples(); ++sample)
            {
                getWritePointer(i)[sample] *= attenuation;
                attenuation += increment;
            }
        }
    }
 
    KrotosAudioBuffer KrotosAudioBuffer::getMonoBuffer()
    {
        AudioBuffer<float> mono{1, this->getNumSamples()};
        mono.clear();
        for (int sourceChannel = 0; sourceChannel < this->getNumChannels(); sourceChannel++)
        {
            mono.addFrom(0, 0, this->getJuceAudioBuffer(), sourceChannel, 0, this->getNumSamples(),
                         1.0f / this->getNumChannels());
        }
 
        return KrotosAudioBuffer(mono);
    }
 
    KrotosAudioBuffer KrotosAudioBuffer::mixToMono(KrotosAudioBuffer& multiChannelBuffer)
    {
        return multiChannelBuffer.getMonoBuffer();
    }
    void KrotosAudioBuffer::setDataValid(bool state) { m_isDataValid = state; }
 
    void KrotosAudioBuffer::copyFrom(int destChannel, const float* source, int numSamples)
    {
        AudioBuffer<float>::copyFrom(destChannel, START_SAMPLE, source, numSamples);
    }
 
    void KrotosAudioBuffer::copyFrom(KrotosAudioBuffer& sourceBuffer)
    {
        // Check that the source buffer matches our own dimensions
        jassert(getNumSamples() == sourceBuffer.getNumSamples());
        jassert((getNumChannels() == sourceBuffer.getNumChannels()) || (sourceBuffer.getNumChannels() == 1));
 
        if (sourceBuffer.getNumChannels() == 1) // Mono gets copied to all dest channels
        {
            for (int i = 0; i < getNumChannels(); ++i)
            {
                copyFrom(i, sourceBuffer.getReadPointer(0), getNumSamples());
            }
        }
        else
        {
            for (int i = 0; i < getNumChannels(); ++i)
            {
                copyFrom(i, sourceBuffer.getReadPointer(i), getNumSamples());
            }
        }
 
        setDataValid(sourceBuffer.isDataValid());
    }
 
    void KrotosAudioBuffer::addFrom(int destChannel, const float* source, int numSamples)
    {
        AudioBuffer<float>::addFrom(destChannel, START_SAMPLE, source, numSamples);
    }
 
    void KrotosAudioBuffer::addFrom(KrotosAudioBuffer& srcBuffer)
    {
        if (!srcBuffer.isDataValid())
            return;
 
        // Check that the source buffer matches our own dimensions
        jassert(getNumSamples() == srcBuffer.getNumSamples());
        jassert((getNumChannels() == srcBuffer.getNumChannels()) || (srcBuffer.getNumChannels() == 1));
 
        if (srcBuffer.getNumChannels() == 1) // Mono gets added to all dest channels
        {
            for (int channel = 0; channel < getNumChannels(); ++channel) // For every channel
            {
                // get read pointer from the first channel
                const float* sourceSamples = srcBuffer.getReadPointer(0);
                AudioBuffer<float>::addFrom(channel, START_SAMPLE, sourceSamples, srcBuffer.getNumSamples());
            }
        }
        else
        {
            for (int channel = 0; channel < getNumChannels(); ++channel) // For every channel
            {
                const float* sourceSamples = srcBuffer.getReadPointer(channel);
                AudioBuffer<float>::addFrom(channel, START_SAMPLE, sourceSamples, srcBuffer.getNumSamples());
            }
        }
    }
 
    void KrotosAudioBuffer::processWetDry(KrotosAudioBuffer& wetBuffer, SmoothedFloat& wetDryValue)
    {
 
        //@TODO Very inefficient since addition of smoothed value - needs refactoring
        for (int sample = 0; sample < getNumSamples(); ++sample) // For every sample
        {
            float wetFactor = wetDryValue.getSmoothedValue() / 100.0f;
            float dryFactor = 1.0f - wetFactor;
            for (int channel = 0; channel < getNumChannels(); ++channel) // For every channel
            {
                const float* sourceSamples = wetBuffer.getReadPointer(channel);
                getWritePointer(channel)[sample] =
                        getReadPointer(channel)[sample] * wetFactor + sourceSamples[sample] * dryFactor;
            }
        }
    }
 
    void KrotosAudioBuffer::processGain(SmoothedFloat& gainFactor)
    {
        for (int sample = 0; sample < getNumSamples(); ++sample) // For every sample
        {
            float gain = gainFactor.getSmoothedValue();
            for (int channel = 0; channel < getNumChannels(); ++channel) // For every channel
            {
                getWritePointer(channel)[sample] *= gain;
            }
        }
    }
 
    bool KrotosAudioBuffer::processClamp(float clampValue)
    {
        bool wasClamped = false;
        for (int channel = 0; channel < getNumChannels(); ++channel) // For every channel
        {
            for (int sample = 0; sample < getNumSamples(); ++sample) // For every sample
            {
                float val = getReadPointer(channel)[sample];
                if (val > clampValue)
                {
                    val = clampValue;
                    wasClamped = true;
                }
                else if (val < -clampValue)
                {
                    val = -clampValue;
                    wasClamped = true;
                }
                getWritePointer(channel)[sample] = val;
            }
        }
        return wasClamped;
    }
 
    void KrotosAudioBuffer::processGain(float gainFactor)
    {
 
        for (int sample = 0; sample < getNumSamples(); ++sample) // For every sample
        {
            for (int channel = 0; channel < getNumChannels(); ++channel) // For every channel
            {
                getWritePointer(channel)[sample] *= gainFactor;
            }
        }
    }
 
    void KrotosAudioBuffer::processPan(SmoothedFloat& panValue)
    {
 
        if (getNumChannels() == 2)
        {
            for (int sample = 0; sample < getNumSamples(); ++sample) // For every sample
            {
                float gainFactorL = panValue.getSmoothedValue() * 2.0f;
                float gainFactorR = 2.0f - gainFactorL;
                getWritePointer(0)[sample] *= gainFactorR;
                getWritePointer(1)[sample] *= gainFactorL;
            }
        }
        else
        {
            jassert(false);
        }
    }
 
    bool KrotosAudioBuffer::isDataValid() const { return m_isDataValid; }
 
    inline void KrotosAudioBuffer::setInterpolationType(InterpolationType newInterpolationType)
    {
        m_interpoltationType = newInterpolationType;
    }
 
    StereoSample KrotosAudioBuffer::makeRamp(StereoSample startValue, int samples)
    {
        bool isStereo = false;
        if (getNumChannels() > 1)
            isStereo = true;
        float scaling = 1.0f; // Start out unscaled
        float increment = scaling / samples;
        float* dataLeftChan = getWritePointer(0);
        float* dataRightChan = dataLeftChan; // in case we are MONO, we will use the left channel data
 
        if (isStereo) // are we >= STEREO ?
        {
            dataRightChan = getWritePointer(1); // if so, reference the right channel data
        }
 
        for (int i = 0; i < getNumSamples(); i++)
        {
            dataLeftChan[i] = startValue.left * scaling;
            if (isStereo)
            {
                dataRightChan[i] = startValue.right * scaling;
            }
            scaling -= increment;
            if (scaling < 0.0f)
                scaling = 0.0f;
        }
 
        StereoSample retVal;
        retVal.left = startValue.left * scaling;
        retVal.right = startValue.right * scaling;
        return retVal;
    }
 
    StereoSample KrotosAudioBuffer::getLastSample()
    {
        StereoSample retVal;
 
        const float* dataLeftChan = getReadPointer(0);
        const float* dataRightChan = dataLeftChan; // in case we are MONO, we will use the left channel data
 
        if (getNumChannels() > 1) // are we >= STEREO ?
        {
            dataRightChan = getReadPointer(1); // if so, reference the right channel data
        }
 
        retVal.left = dataLeftChan[getNumSamples() - 1];
        retVal.right = dataRightChan[getNumSamples() - 1];
        return retVal;
    }
 
    inline StereoSample KrotosAudioBuffer::getInterpolatedSample(double index)
    {
        StereoSample retVal;
 
        // clamp the values to 0 -> bufferLength
        if (index <= 0)
        {
            index = 0;
        }
        else if (index >= double(getNumSamples()))
        {
            index = double(getNumSamples()) - 1.0;
        }
 
        int integerPosition = (int)floor(index);
        if (integerPosition >= getNumSamples() - 1 || integerPosition < 0)
        {
            // jassertfalse; // Playhead out of range
            return retVal; // Quit with default sample value of 0,0 before we cause an access exception
        }
 
        const float* dataLeftChan = getReadPointer(0);
        const float* dataRightChan = dataLeftChan; // in case we are MONO, we will use the left channel data
 
        if (getNumChannels() > 1) // are we >= STEREO ?
        {
            dataRightChan = getReadPointer(1); // if so, reference the right channel data
        }
 
        switch (m_interpoltationType)
        {
        case InterpolationType::Linear: // simple linear interpolation
        {
            float alpha = float(index - double(integerPosition));
            auto invAlpha = 1.0f - alpha;
            retVal.left = dataLeftChan[integerPosition] * invAlpha + dataLeftChan[integerPosition + 1] * alpha;
            retVal.right = dataRightChan[integerPosition] * invAlpha + dataRightChan[integerPosition + 1] * alpha;
            break;
        }
        case InterpolationType::Cubic: {
            retVal.left = getCubicInterpolationSample(index, dataLeftChan);
            retVal.right = getCubicInterpolationSample(index, dataRightChan);
            break;
        }
        case InterpolationType::Cosine: {
            retVal.left = getCosineInterpolationSample(index, dataLeftChan);
            retVal.right = getCosineInterpolationSample(index, dataRightChan);
            break;
        }
        case InterpolationType::Cubic3d: {
            retVal.left = getCubic3dInterpolationSample(index, dataLeftChan);
            retVal.right = getCubic3dInterpolationSample(index, dataRightChan);
            break;
        }
        case InterpolationType::NUM_TYPES:
        default: {
            jassertfalse; // Unknown interpolation type
        }
        }
 
        return retVal;
    }
 
    inline float KrotosAudioBuffer::getInterpolatedSampleMono(float playHead)
    {
        StereoSample val = getInterpolatedSample(playHead);
        return (val.left + val.right) * 0.5f;
    }
 
    float KrotosAudioBuffer::getCubic3dInterpolationSample(double playhead, const float* buffer)
    {
        // Interpolation method from http://paulbourke.net/miscellaneous/interpolation/
        int index = static_cast<int>(floor(playhead));
        double mu = playhead - static_cast<double>(index);
 
        int sampleIndex2 = index + 1;
        if (sampleIndex2 >= getNumSamples())
        {
            sampleIndex2 = getNumSamples() - 1;
        }
 
        float y1 = buffer[index];
        float y2 = buffer[sampleIndex2];
 
        int sampleIndex0 = index - 1;
        if (sampleIndex0 < 0)
            sampleIndex0 = 0;
        int sampleIndex3 = sampleIndex2 + 1;
        if (sampleIndex3 >= getNumSamples())
        {
            sampleIndex3 = getNumSamples() - 1;
        }
        float y0 = buffer[sampleIndex0];
        float y3 = buffer[sampleIndex3];
        double mu2 = mu * mu;
 
        float a0 = -0.5f * y0 + 1.5f * y1 - 1.5f * y2 + 0.5f * y3;
        float a1 = y0 - 2.5f * y1 + 2 * y2 - 0.5f * y3;
        float a2 = -0.5f * y0 + 0.5f * y2;
        float a3 = y1;
        return static_cast<float>(a0 * mu * mu2 + a1 * mu2 + a2 * mu + a3);
    }
 
    float KrotosAudioBuffer::getCosineInterpolationSample(double playhead, const float* buffer)
    {
        // Interpolation method from http://paulbourke.net/miscellaneous/interpolation/
        int index = static_cast<int>(floor(playhead));
        double mu = playhead - static_cast<double>(index);
 
        int sampleIndex2 = index + 1;
        if (sampleIndex2 >= getNumSamples())
        {
            sampleIndex2 = getNumSamples() - 1;
        }
        float y1 = buffer[index];
        float y2 = buffer[sampleIndex2];
 
        float mu2 = (1.0f - cosf(static_cast<float>(mu) * juce::MathConstants<float>::pi)) / 2;
        return y1 * (1.0f - mu2) + y2 * mu2;
    }
 
    float KrotosAudioBuffer::getCubicInterpolationSample(double playhead, const float* buffer)
    {
        // Cubic interpolation, for example, could go here
        int y1index = static_cast<int>(floor(playhead));
        int y2index = static_cast<int>(ceil(playhead));
 
        if (y1index == y2index)
        {
            return buffer[y1index];
        }
 
        jassert(y1index >= 0);
        jassert(y2index <= getNumSamples());
 
        jassert((playhead != 0.0) && (y1index != y2index));
 
        int y0index = y1index - 1;
        int y3index = y2index + 1;
 
        double mu = playhead - y1index;
 
        jassert((mu >= 0) && (mu <= 1));
 
        if (y0index == -1)
        {
            y0index = 0;
        }
 
        if (y2index >= getNumSamples())
        {
            y2index = getNumSamples() - 1;
            y3index = getNumSamples() - 1;
        }
 
        else if (y3index >= getNumSamples())
        {
            y3index = getNumSamples() - 1;
        }
 
        jassert(y0index >= 0);
        jassert(y1index >= 0);
        jassert(y2index >= 0);
        jassert(y3index >= 0);
 
        jassert(y0index < getNumSamples());
        jassert(y1index < getNumSamples());
        jassert(y2index < getNumSamples());
        jassert(y3index < getNumSamples());
 
        double y0 = buffer[y0index];
        double y1 = buffer[y1index];
        double y2 = buffer[y2index];
        double y3 = buffer[y3index];
 
        double a0, a1, a2, a3, mu2;
 
        mu2 = mu * mu;
        a0 = y3 - y2 - y0 + y1;
        a1 = y0 - y1 - a0;
        a2 = y2 - y0;
        a3 = y1;
 
        return (static_cast<float>(a0 * mu * mu2 + a1 * mu2 + a2 * mu + a3));
    }
 
    void KrotosAudioBuffer::setSampleRate(float sampleRate) { m_sampleRate = sampleRate; }
 
    float KrotosAudioBuffer::getSampleRate(void) { return m_sampleRate; }
 
    void KrotosAudioBuffer::setSourceSampleRate(float sampleRate) { m_sourceSampleRate = sampleRate; }
 
    float KrotosAudioBuffer::getSourceSampleRate(void) { return m_sourceSampleRate; }
 
    float KrotosAudioBuffer::getNativeNoteFrequency(void)
    {
        // This hardwired value should eventually be supplied from analyis of the sample, or from meta-data
        // For now, sampled notes will be assumed to have a pitch of C4
        return FREQ_Hz_NOTE_C4;
    }
 
    void KrotosAudioBuffer::reverse(int channel, int startSample, int numSamples)
    {
        std::reverse(getWritePointer(channel) + startSample, getWritePointer(channel) + startSample + numSamples);
    }
 
    void KrotosAudioBuffer::reverse(int startSample, int numSamples)
    {
        for (int i = 0; i < getNumChannels(); ++i)
        {
            reverse(i, startSample, numSamples);
        }
    }
 
    juce::AudioBuffer<float>& KrotosAudioBuffer::getJuceAudioBuffer()
    {
        return dynamic_cast<AudioBuffer<float>&>(*this);
    }
 
    void KrotosAudioBuffer::equalPowerCrossFadeFrom(const KrotosAudioBuffer& previousBuffer)
    {
        for (int channel = 0; channel < previousBuffer.getNumChannels(); channel++)
        {
            auto channelData = previousBuffer.getReadPointer(channel);
            auto numOfSamples = previousBuffer.getNumSamples();
 
            float multiplier = -1.0f;
            const float increment = 2.0f / numOfSamples;
            for (int i = 0; i < numOfSamples; i++)
            {
                const float newSample = (sqrt(0.5f * (1.f - multiplier)) * channelData[i]) +
                                        (sqrt(0.5f * (1.f + multiplier)) * getReadPointer(channel)[i]);
                getWritePointer(channel)[i] = newSample;
                multiplier += increment;
            }
        }
    }
 
    inline float KrotosAudioBuffer::findAbsMax()
    {
        float maxVal = 0;
        for (int channel = 0; channel < getNumChannels(); channel++)
        {
            Range<float> range = findMinMax(channel, 0, getNumSamples());
            if (fabs(range.getStart()) > maxVal)
                maxVal = fabs(range.getStart());
            if (fabs(range.getEnd()) > maxVal)
                maxVal = fabs(range.getEnd());
        }
        return maxVal;
    }
 
    void KrotosAudioBuffer::normaliseTo(float scale) { applyGain(scale / findAbsMax()); }
 
    const float KrotosAudioBuffer::FREQ_Hz_NOTE_C3{130.813705f};
    const float KrotosAudioBuffer::FREQ_Hz_NOTE_D3{146.83f};
    const float KrotosAudioBuffer::FREQ_Hz_NOTE_C4{261.63f};
} // namespace krotos