KrotosAudioBufferDSPPhaseDetection.cpp

Go to the documentation of this file.

/*
==============================================================================
 
KrotosAudioBufferDSP.cpp
Created: 13 June 2019 12:22:00am
Author:  sandyw
 
==============================================================================
*/
 
namespace krotos
{
    int KrotosAudioBufferDSP::calcFreeGrain(int centerIndex, int previousGrain, GrainRange range)
    {
        enum corrType
        {
            M2 = 0,
            M1,
            ZE,
            P1,
            P2,
            SIZE
        };
 
        float cor[SIZE];
        cor[M2] = autoCorrelateCentred(centerIndex, previousGrain - 2);
        cor[M1] = autoCorrelateCentred(centerIndex, previousGrain - 1);
        cor[ZE] = autoCorrelateCentred(centerIndex, previousGrain);
        cor[P1] = autoCorrelateCentred(centerIndex, previousGrain + 1);
        cor[P2] = autoCorrelateCentred(centerIndex, previousGrain + 2);
 
        float tolerance = 1.0f + (m_phaseAnalysisCoefficients.cal3 * 0.01f);
        int increment;
        int maxSteps;
        if (cor[ZE] < cor[P1]) // Travelling fwds ?
        {
            increment = 1;
            maxSteps = int(float(previousGrain) * tolerance) - previousGrain;
        }
        else
        {
            increment = -1;
            maxSteps = previousGrain - int(float(previousGrain) / tolerance);
        }
 
        if (maxSteps < 0)
        {
            maxSteps = 0;
        }
 
        int grain = previousGrain;
 
        while ((!((cor[ZE] > cor[M2]) && (cor[ZE] > cor[M1]) && (cor[ZE] > cor[P1]) && (cor[ZE] > cor[P2]))) &&
               (grain < range.max) && (grain > range.min))
        // while ((!((cor[ZE] > cor[M2]) && (cor[ZE] > cor[M1]) && (cor[ZE] > cor[P1]) && (cor[ZE] > cor[P2]))) &&
        // maxSteps--) // non ranged terminator - leave in
        {
            if (increment > 0)
            {
                cor[M2] = cor[M1];
                cor[M1] = cor[ZE];
                cor[ZE] = cor[P1];
                cor[P1] = cor[P2];
                cor[P2] = autoCorrelateCentred(centerIndex, grain + 3);
            }
            else
            {
                cor[P2] = cor[P1];
                cor[P1] = cor[ZE];
                cor[ZE] = cor[M1];
                cor[M1] = cor[M2];
                cor[M2] = autoCorrelateCentred(centerIndex, grain - 3);
            }
 
            grain += increment;
        }
 
        if ((grain >= range.max) || (grain <= range.min) || (maxSteps == 0))
        {
            return -1;
        }
 
        return grain;
    }
 
    void findPeaks(std::vector<float>& graphArray, std::vector<Point<float>>& markerArray, int maxPeaks)
    {
        int graphSize = static_cast<int>(graphArray.size());
        int startAnalisys = 2;
        int endAnalisys = graphSize - 2;
 
        markerArray.clear();
 
        for (int i = startAnalisys; i < endAnalisys; ++i)
        {
            if ((graphArray[i - 1] < graphArray[i] && graphArray[i] > graphArray[i + 1]) &&
                (graphArray[i - 2] < graphArray[i] && graphArray[i] > graphArray[i + 2]))
            {
                markerArray.push_back(Point<float>{(float)i / (float)graphSize, graphArray[i]});
            }
            if (markerArray.size() >= maxPeaks)
                break;
        }
    }
 
    int centralise(std::vector<float>& graphArray, int position)
    {
        int graphSize = static_cast<int>(graphArray.size());
        int startAnalisys = 3;
        int endAnalisys = graphSize - 3;
 
        if ((position <= startAnalisys) || (position >= endAnalisys))
        {
            return -1;
        }
 
        int increment = -1;
        if (graphArray[position] < graphArray[position + 1]) // Are we travelling forward in the array ?
        {
            increment = 1;
        }
 
        int i = position;
        while ((!((graphArray[i - 1] < graphArray[i] && graphArray[i] > graphArray[i + 1]) &&
                  (graphArray[i - 2] < graphArray[i] && graphArray[i] > graphArray[i + 2]))) &&
               (i < endAnalisys) && (i > startAnalisys))
        {
            i = int(int(i) + increment);
        }
 
        if ((i >= endAnalisys) || (i <= startAnalisys))
        {
            return -1;
        }
 
        return int(i);
    }
 
    void sortMarkersByX(std::vector<juce::Point<float>>& markerArray, bool decending = false)
    {
        int i, j, k;
        int n = static_cast<int>(markerArray.size());
        // Gap 'i' between index of the element to be compared, initially n/2.
        for (i = n / 2; i > 0; i = i / 2)
        {
            for (j = i; j < n; j++)
            {
                for (k = j - i; k >= 0; k = k - i)
                {
                    // If value at higher index is greater, then break the loop.
                    if (decending)
                    {
                        if (markerArray[k + i].getX() < markerArray[k].getX())
                            break;
                    }
                    else
                    {
                        if (markerArray[k + i].getX() > markerArray[k].getX())
                            break;
                    }
                    // Switch the values otherwise.
                    {
                        Point<float> temp = markerArray[k];
                        markerArray[k] = markerArray[k + i];
                        markerArray[k + i] = temp;
                    }
                }
            }
        }
    }
 
    void sortMarkersByY(std::vector<Point<float>>& markerArray, bool decending = false)
    {
        int i, j, k;
        int n = static_cast<int>(markerArray.size());
        // Gap 'i' between index of the element to be compared, initially n/2.
        for (i = n / 2; i > 0; i = i / 2)
        {
            for (j = i; j < n; j++)
            {
                for (k = j - i; k >= 0; k = k - i)
                {
                    // If value at higher index is greater, then break the loop.
                    if (decending)
                    {
                        if (markerArray[k + i].getY() < markerArray[k].getY())
                            break;
                    }
                    else
                    {
                        if (markerArray[k + i].getY() > markerArray[k].getY())
                            break;
                    }
                    // Switch the values otherwise.
                    {
                        Point<float> temp = markerArray[k];
                        markerArray[k] = markerArray[k + i];
                        markerArray[k + i] = temp;
                    }
                }
            }
        }
    }
 
    bool KrotosAudioBufferDSP::scanForGrainsFreeMarker(std::vector<int>& returnGrains, const int audioIndexStart,
                                                       const int useableIndexEnd, const int startGrainSize)
    {
        int phaseZeroPosition = audioIndexStart;
        int previousGrainSize = startGrainSize;
        do // Forwards scan
        {
            int newGrainSize = this->calcFreeGrain(phaseZeroPosition, previousGrainSize, m_analysisGrainSizeRange);
            if (newGrainSize < 0)
            {
                return false; // Aborted early
            }
            returnGrains.push_back(newGrainSize);
            phaseZeroPosition += newGrainSize;
            previousGrainSize = newGrainSize;
        } while (phaseZeroPosition < useableIndexEnd);
        return true; // Finished successfully
    }
 
    bool KrotosAudioBufferDSP::scanBackwardsForGrainsFreeMarker(std::vector<int>& returnGrains,
                                                                const int audioIndexStart, const int useableIndexEnd,
                                                                const int startGrainSize)
    {
        int phaseZeroPosition = audioIndexStart;
        int previousGrainSize = startGrainSize;
        do // Backwards scan
        {
            int newGrainSize = this->calcFreeGrain(phaseZeroPosition, previousGrainSize, m_analysisGrainSizeRange);
            if (newGrainSize < 0)
            {
                return false; // Aborted early
            }
            phaseZeroPosition -= newGrainSize; // Decrement phase
            if (phaseZeroPosition < useableIndexEnd)
            {
                break;
            }
            returnGrains.push_back(newGrainSize);
            previousGrainSize = newGrainSize;
        } while (phaseZeroPosition > useableIndexEnd);
        return true; // Finished successfully
    }
 
    void KrotosAudioBufferDSP::buildDescriptors(std::vector<AudioDescriptor>& descriptors,
                                                const std::vector<int>& grainsList, const int startGrainAudioIndex,
                                                bool goingBackwards = false)
    {
        int audioIndex = startGrainAudioIndex;
        bool newSubPath = true;
 
        for (int i = 0; i < grainsList.size(); i++)
        {
            int newGrainSize = grainsList[i];
            float frequency = this->getSampleRate() / (float)newGrainSize;
 
            if (goingBackwards)
            {
                audioIndex -= newGrainSize; // Decrement phase
            }
 
            descriptors.push_back(AudioDescriptor{frequency, 0, audioIndex, (float)newGrainSize, 0, true, false});
 
            newSubPath = false;
 
            if (!goingBackwards)
            {
                audioIndex += newGrainSize; // Increment phase
            }
        }
    }
 
    void KrotosAudioBufferDSP::setAnalysisGrainSizeRange()
    {
        float hzMin{10.0f};
        float hzMax{500.0f};
        int minGrainSize{int(this->getSampleRate() / hzMax)};
        int maxGrainSize{int(this->getSampleRate() / hzMin)};
        m_analysisGrainSizeRange.setLimits(minGrainSize, maxGrainSize);
        m_analysisGrainSizeRange.setToLimits();
    }
 
    void KrotosAudioBufferDSP::setDefaultPhaseAnalysisCoefficients()
    {
        AnalysisCoefficientsPhase coeff;
        coeff.cal0 = 10.0f;               // Power
        coeff.tracking = m_trackingValue; // Tracking (position 0 -> 1)
        coeff.cycles = m_trackingCycles;
        coeff.cal3 = 1.2f; //
        coeff.cal4 = 8.0f; // Num trackers
        coeff.cal5 = 0.0f; // Floor
        setPhaseAnalysisCoefficients(coeff);
    }
 
    void KrotosAudioBufferDSP::analysePhase()
    {
        FloatVectorOperations::disableDenormalisedNumberSupport();
 
        setDefaultPhaseAnalysisCoefficients();
        setAnalysisGrainSizeRange();
 
        if (this->size() < m_analysisGrainSizeRange.max)
        {
            return;
        }
 
        invalidate();
 
        std::vector<AudioDescriptor> grainDescriptionByFrequency;
        std::vector<AudioDescriptor> grainDescriptionByTime;
 
        int useableIndexStart = int(float(this->size()) * m_startPos);
        if (useableIndexStart < m_analysisGrainSizeRange.max)
            useableIndexStart = m_analysisGrainSizeRange.max;
        int useableIndexEnd = int(float(this->size()) * m_endPos);
        if (useableIndexEnd > (this->size() - m_analysisGrainSizeRange.max))
            useableIndexEnd = (this->size() - m_analysisGrainSizeRange.max);
 
        std::vector<int> grainListFwds;
        std::vector<int> grainListBack;
 
        int lengthFwds{0};
        int lengthBack{0};
 
        int bestLengthFwds{0};
        int bestLengthBack{0};
 
        int bestLength = static_cast<int>(1000000000000);
        int bestAudioIndex{-1};
        int bestGrainSize{0};
 
        int startGrainAudioIndex =
                static_cast<int>(jmap<float>(m_phaseAnalysisCoefficients.tracking, 0.0f, 1.0f, m_startPos, m_endPos) *
                                 static_cast<float>(this->size()));
 
        // int startGrainSize = (m_analysisGrainSizeRange.min + m_analysisGrainSizeRange.max) / 2;
 
        int engineRPM = m_phaseAnalysisCoefficients.cycles;
        int engineHz = engineRPM / 60.f;
 
        int startGrainSize = static_cast<int>(this->getSampleRate() / engineHz);
 
        // Grain scans use full range
        useableIndexStart = static_cast<int>(static_cast<float>(this->size()) * m_startPos);
        useableIndexEnd = static_cast<int>(static_cast<float>(this->size()) * m_endPos);
        grainListFwds.clear();
        grainListBack.clear();
        scanForGrainsFreeMarker(grainListFwds, startGrainAudioIndex, useableIndexEnd, startGrainSize);
        scanBackwardsForGrainsFreeMarker(grainListBack, startGrainAudioIndex, useableIndexStart, startGrainSize);
 
        // Throw away the final grain of each scan as it may have run out of wav, and be unreliable
        if (grainListFwds.size() > 0)
            grainListFwds.pop_back();
        if (grainListBack.size() > 0)
            grainListBack.pop_back();
 
        std::vector<AudioDescriptor> descriptorsFree;
        buildDescriptors(descriptorsFree, grainListFwds, startGrainAudioIndex);
        buildDescriptors(descriptorsFree, grainListBack, startGrainAudioIndex, true);
 
        if (!descriptorsFree.size())
            return; // Will be returning invalidated
 
        // The free scan is out of order, so sort by audio index
        std::sort(descriptorsFree.begin(), descriptorsFree.end(),
                  [](AudioDescriptor& a, AudioDescriptor& b) { return a.audioIndex < b.audioIndex; });
 
        // Description is now in time order, so we can tag the grainIndexByTime
        int timeIndex = 0;
        for (std::vector<AudioDescriptor>::iterator it = descriptorsFree.begin(); it != descriptorsFree.end(); ++it)
        {
            it->grainIndexByTime = timeIndex++;
        }
 
        const int numCycles = 1;
        std::vector<AudioDescriptor> descriptorsTime;
 
        if (numCycles == 1)
        {
            descriptorsTime = descriptorsFree;
        }
        else
        {
            int cycleCounter = 0;
            float grainSizeAccumulator = 0;
            for (std::vector<AudioDescriptor>::iterator it = descriptorsFree.begin(); it != descriptorsFree.end(); ++it)
            {
                grainSizeAccumulator += it->grainSize;
                if (++cycleCounter == numCycles) // Thinning out the number of descriptors we keep
                {
                    AudioDescriptor newDesc = *it;
                    newDesc.grainIndexByTime = it->grainIndexByTime / numCycles;
                    newDesc.grainSize = grainSizeAccumulator;
                    newDesc.frequency = this->getSampleRate() / grainSizeAccumulator;
                    descriptorsTime.push_back(newDesc);
                    grainSizeAccumulator = 0.f;
                    cycleCounter = 0;
                }
            }
        }
 
        // Sort by frequency
        std::sort(descriptorsTime.begin(), descriptorsTime.end(),
                  [](AudioDescriptor& a, AudioDescriptor& b) { return a.frequency < b.frequency; });
 
        // Description is now in frequency order, so we can tag the grainIndexFrequencyOrder
        int frequencyIndex = 0;
        for (std::vector<AudioDescriptor>::iterator it = descriptorsTime.begin(); it != descriptorsTime.end(); ++it)
        {
            it->grainIndexByFrequency = frequencyIndex++;
        }
 
        grainDescriptionByFrequency = descriptorsTime; // Store it - by frequency
 
        // Re-sort by time
        std::sort(descriptorsTime.begin(), descriptorsTime.end(),
                  [](AudioDescriptor& a, AudioDescriptor& b) { return a.audioIndex < b.audioIndex; });
 
        grainDescriptionByTime = descriptorsTime; // Store it - by time
 
        if ((grainDescriptionByFrequency.size() > 0) && (grainDescriptionByTime.size() > 0))
        {
            m_grainDescriptionByFrequency = grainDescriptionByFrequency;
            m_grainDescriptionByTime = grainDescriptionByTime;
            m_trackingDataIsValid = true;
        }
    }
 
} // namespace krotos