KrotosAudioBufferDSP.cpp

Go to the documentation of this file.

/*
==============================================================================
 
KrotosAudioBufferDSP.cpp
 
Created:
    13 June 2019 12:22:00am S White
 
Contributers:
    Team Krotos
 
==============================================================================
*/
 
namespace krotos
{
 
    KrotosAudioBufferDSP::KrotosAudioBufferDSP() : Thread("Analysis Thread") { addListener(this); }
 
    ProgressTracker& KrotosAudioBufferDSP::getProgressTracker() { return m_progressTracker; }
 
    void KrotosAudioBufferDSP::timerCallback() { analyse(); }
 
    bool KrotosAudioBufferDSP::shouldRegenerateDisplayCache()
    {
        auto retVal = m_requestDisplayCacheRegeneration;
        m_requestDisplayCacheRegeneration = false;
        return retVal;
    }
 
    void KrotosAudioBufferDSP::analyse()
    {
        // This method needs to be non-blocking so it doesn't hold up the
        // message thread which has called it
#if !UNIT_TEST
#if ENABLE_REFORMER
        // This method will sometimes be called repeatedly in fast succession as the various Params
        // which call Analyse() are updated during state recall - we need to be able to
        // abort and then return to do the analysis. If an analysis is already in progress ...
        if (isThreadRunning())
        {
            signalThreadShouldExit(); // ... then we ask it to exit ...
            notify();                 // We can't predict how long it will take to exit, so we
                                      // don't wait around, we start a timer
            if (!isTimerRunning())
            {
                // If the timer has not already been started
                startTimer(ANALYSIS_TIMER_PERIOD); // ... then we start it
                // The timer will will call Analyse again after ANALYSIS_TIMER_PERIOD mS
            }
        }
        else // If there is no analysis running, we are clear to start one
        {
            if (isTimerRunning()) // If the timer is running, we stop it ...
            {
                stopTimer(); // ... as it is no longer needed
            }
            startThread(); // We are sure analysis is not already in progress,
                           // so lets start the analysis thread
        }
#else
        return;
#endif /* INCLUDE_REFORMER */
#endif /* UNIT_TEST */
    }
 
    void KrotosAudioBufferDSP::run()
    {
        invalidate();
 
        // Reinstate this switch once we have a working choice of scheme
        switch (getAnalysisScheme())
        {
 
        case AnalysisScheme::GeneralScheme:
            generalScheme();
            break;
 
        case AnalysisScheme::Vehicle:
            analysePhase();
            break;
 
        case AnalysisScheme::SchemeNone:
        default:
            break;
        }
 
        if (!analysisResultsAreValid()) // If analysis didn't complete ...
        {
            if (threadShouldExit())
                return;
 
            // ... then clean up any mess
            cleanupAnalysis();
        }
    }
 
    std::vector<float> KrotosAudioBufferDSP::averageBufferToMono()
    {
        // Retrieve Buffer
        AudioBuffer<float>* buffer = dynamic_cast<AudioBuffer<float>*>(this);
 
        // Average signal to mono if it's stereo
        AudioBuffer<float> mono;
        mono.setSize(1, getNumSamples());
        mono.copyFrom(0, 0, *buffer, 0, 0, getNumSamples());
        if (buffer->getNumChannels() == 2)
        {
            mono.addFrom(0, 0, *buffer, 1, 0, getNumSamples());
            mono.applyGain(0, getNumSamples(), 0.5f);
        }
        float* start = mono.getWritePointer(0); // get pointer to the first sample of the first channel
        int size = mono.getNumSamples();
        // Data from the buffer copied into vector
        std::vector<float> bufferVector(start, start + size);
 
        return bufferVector;
    }
 
    std::vector<std::vector<float>> KrotosAudioBufferDSP::segmentOnsetSlices(std::vector<int> onsetPositions,
                                                                             std::vector<float> signalBufferMono)
    {
        int startSample{0};
        int finishSample{0};
        // Contains sliced up buffer according to onset
        std::vector<std::vector<float>> timeDomainSlices;
 
        for (int i = 0; i < onsetPositions.size(); i++)
        {
            startSample = onsetPositions.at(i);
            if (i < onsetPositions.size() - 1)
                finishSample = onsetPositions.at(i + 1) - 1;
            else
                finishSample = static_cast<int>(signalBufferMono.size());
 
            std::vector<float> subVector(signalBufferMono.begin() + startSample,
                                         signalBufferMono.begin() + finishSample);
            timeDomainSlices.push_back(subVector);
        }
 
        return timeDomainSlices;
    }
 
    std::vector<std::vector<float>> KrotosAudioBufferDSP::segmentChunks(std::vector<int> onsetPositions,
                                                                        std::vector<float> bufferVector,
                                                                        std::size_t window_length)
 
    {
        std::vector<std::vector<float>> timeDomainSlices;
        const auto N = bufferVector.size();
        for (auto onset : onsetPositions)
        {
            const auto start_sample = onset;
            const auto end_sample = std::min(start_sample + window_length,
                                             N); // handles case where audio is shorter than window_length
 
            std::vector<float> clip(bufferVector.begin() + start_sample, bufferVector.begin() + end_sample);
            timeDomainSlices.push_back(clip);
        }
        return timeDomainSlices;
    }
 
    std::vector<int> KrotosAudioBufferDSP::chunk(const std::vector<float>& bufferVector, std::size_t window_length,
                                                 std::size_t hop_length)
    {
        std::vector<int> onsets;
        if (bufferVector.size() > window_length)
        {
            for (size_t i = 0; i < bufferVector.size() - window_length; i += hop_length)
            {
                onsets.push_back(static_cast<int>(i));
            }
        }
 
        // if we didn't find any, set as onset the beginning of the file
        if (onsets.empty())
        {
            onsets.push_back(0);
        }
 
        return onsets;
    }
 
    std::vector<int> KrotosAudioBufferDSP::envelopeOnsetDetection(const std::vector<float>& bufferVector,
                                                                  float samplerate)
    {
 
        // envelope follower with corrected peak detection
        auto envFollower = std::make_unique<EnvelopeFollowerSPD>(samplerate);
        // slope calculation using linear regression object
        auto slopeGenerator = std::make_unique<SlopeGenerator>();
        // onsetDetection object
        auto onsetDetector = std::make_unique<OnsetDetector>(samplerate);
 
        // Initialise OnsetDetection Parameters
        onsetDetector.get()->setThresholdPercentage(jmap<float>(m_AnalysisCoefficients.coeff0, 0.f, 1.f, 1e-3f,
                                                                1.f)); // 0.4 for percussive
        onsetDetector.get()->setOnsetMiliSeconds(jmap<float>(m_AnalysisCoefficients.coeff1, 0.f, 1.f, 100e-3f,
                                                             1000e-3f)); // 100e-3 for percussive
        onsetDetector.get()->setDecayLengthMiliSeconds(jmap<float>(m_AnalysisCoefficients.coeff2, 0.f, 1.f, 1e-3f,
                                                                   10e-3f)); // 1e-3 for percussive
 
        // Produce envelope follower vector from input Buffer data
        std::vector<float> signalEnvelope = envFollower.get()->filterVector(bufferVector);
        std::vector<float> normalisedEnvelope = envFollower.get()->normaliseEnvelope(signalEnvelope);
 
        // Create slope Array
        auto slopeVector = slopeGenerator.get()->createSlopeVectorFromEnvelope(normalisedEnvelope);
 
        // Detect onsets
        auto onsetPositions = onsetDetector.get()->calculateOnsetsGlobal(slopeVector, normalisedEnvelope);
 
        // if we didn't find any, set as onset the beginning of the file
        if (onsetPositions.empty())
        {
            onsetPositions.push_back(0);
        }
        return onsetPositions;
    }
 
    std::vector<int> KrotosAudioBufferDSP::superFluxOnsetDetection(float sampleRate)
    {
        // Create filterBank
        auto filterBank = std::make_unique<MusicScaleFilterBank>(sampleRate);
        // STFT parameters
        const int analysisFrameSize{2048};
        const int hopSize = 221;
        // STFT object
        auto m_stft = std::make_unique<ShortTimeFourierTransform>(
                analysisFrameSize, analysisFrameSize, hopSize, WindowType::Hann,
                ShortTimeFourierTransform::fftMode::freqMagOnly, static_cast<int>(sampleRate));
 
        // Retrieve all the spectral frames from STFT
        AudioBuffer<float>* buffer = dynamic_cast<AudioBuffer<float>*>(this);
        // TODO: Should return MatrixXf instead of vector<vector<float>>
        auto spectralFrames = m_stft.get()->stft(*buffer);
        // Filter the spectrogram with the filterBank and take the log
        // amplitude
        auto filteredSpec = filterBank.get()->filterSpectrum(spectralFrames);
 
        // SuperFlux object
        auto onsetDetector = std::make_unique<SuperFluxOnsetDetection>(filteredSpec, sampleRate, hopSize);
        // Setup parameters for onset Detection
        // Initialise OnsetDetection Parameters
        onsetDetector.get()->setParametersMS(
                jmap<float>(m_AnalysisCoefficients.coeff0, 0.f, 1.f, 30e-3f, 100e-3f) /*preMax*/,
                jmap<float>(m_AnalysisCoefficients.coeff1, 0.f, 1.f, 30e-3f, 100e-3f) /*postMax*/,
                jmap<float>(m_AnalysisCoefficients.coeff2, 0.f, 1.f, 100e-3f, 200e-3f) /*preAvg*/,
                jmap<float>(m_AnalysisCoefficients.coeff3, 0.f, 1.f, 35e-3f, 140e-3f) /*postAvg*/,
                jmap<float>(m_AnalysisCoefficients.coeff4, 0.f, 1.f, 30e-3f, 100e-3f)) /*combWidth*/;
        onsetDetector.get()->setDeltaPercentage(jmap<float>(m_AnalysisCoefficients.coeff7, 0.f, 1.f, 0.1f, 1.5f));
 
        // Get Onset positions in samples
        auto onsetPositions = onsetDetector.get()->findOnsetsInSamples();
 
        return onsetPositions;
    }
 
    std::vector<AudioDescriptor> KrotosAudioBufferDSP::getDescriptorsTime(
            const std::vector<std::vector<float>>& timeDomainSlices, const std::vector<int>& onsetPositions)
    {
        AudioDescriptor grainDescription;
 
        std::vector<AudioDescriptor> descriptorsTime;
 
        for (int i = 0; i < onsetPositions.size(); i++)
        {
            // Update descriptors with analysis values
            grainDescription.audioIndex = onsetPositions.at(i); // grain Index = start time
 
            // Update descriptors with analysis values
            grainDescription.grainSize =
                    static_cast<float>(timeDomainSlices.at(i).size()); // grain Size = analysis Frame size
 
            descriptorsTime.push_back(grainDescription);
        }
        return descriptorsTime;
    }
 
    std::vector<std::vector<float>> KrotosAudioBufferDSP::mfccFeatureExtraction(
            std::vector<std::vector<float>>& timeDomainSlices, const std::vector<int>& onsetPositions)
    {
        // STFT parameters
        const int analysisFrameSize{2048};
        const int hopSize{1024};
        // STFT object
        auto m_stft = std::make_unique<ShortTimeFourierTransform>(
                analysisFrameSize, analysisFrameSize, hopSize, WindowType::Hann,
                ShortTimeFourierTransform::fftMode::freqMagOnly, static_cast<int>(getSourceSampleRate()));
 
        // freqDomain analysis framework object
        auto freqAnalysisFramework = std::make_unique<FrequencyDomainAnalysisFramework>(
                (analysisFrameSize), static_cast<int>(getSourceSampleRate()));
 
        const auto n_features = freqAnalysisFramework.get()->getNumberOfMelFrequencyCepstralCoefficients();
        std::vector<std::vector<float>> features;
        std::vector<float> mfcc(n_features, 0.0f);
 
        for (int i = 0; i < onsetPositions.size(); i++)
        {
            float* dataPtrs[1] = {timeDomainSlices.at(i).data()};
            AudioBuffer<float> bufferSlice(dataPtrs, 1, static_cast<int>(timeDomainSlices.at(i).size()));
            auto spectralFrames = m_stft.get()->stft(bufferSlice);
 
            for (int j = 0; j < spectralFrames.size(); j++)
            {
                // Pass each frame to the frequencyAnalysisFramework to analyse
                freqAnalysisFramework->setSpectralFrame(spectralFrames.at(j));
 
                // Get MFCC features and pass to PCA
                std::vector<float> mfccTemp = freqAnalysisFramework->getMFCC();
                // Sum them up
                transform(mfcc.begin(), mfcc.end(), mfccTemp.begin(), mfcc.begin(), std::plus<float>());
            }
 
            // Averaging each slice
            transform(mfcc.begin(), mfcc.end(), mfcc.begin(),
                      [=](float j) { return (j / static_cast<float>(spectralFrames.size())); });
            features.push_back(mfcc);
 
            fill(mfcc.begin(), mfcc.end(), 0.0f);
        }
        return features;
    }
 
    std::vector<std::vector<float>> KrotosAudioBufferDSP::temporalFeatureExtraction(
            std::vector<std::vector<float>>& timeDomainSlices)
    {
        std::vector<std::vector<float>> features;
 
        for (const auto& segment : timeDomainSlices)
        {
            float ss = 0.f;
            float temporal_centroid = 0.f;
 
            for (size_t i = 0; i < segment.size(); ++i)
            {
                const auto value = (segment[i] * segment[i]);
                temporal_centroid += (i * value);
                ss += value;
            }
            const auto level = 10.f * log10(std::max(ss / segment.size(), 1e-6f)); // dB
            temporal_centroid /= std::max(ss, 1e-5f);                              // [0, segment.size()]
            features.emplace_back(std::initializer_list<float>{temporal_centroid, level, 1.f, level});
        }
        return features;
    }
 
    std::vector<std::vector<float>> KrotosAudioBufferDSP::specCntrRMS_FeatureExtraction(
            std::vector<std::vector<float>>& timeDomainSlices)
    {
        std::vector<std::vector<float>> features;
        // Initialise the STFT parameters
        const int analysisFrameSize{2048};
        const int hopSize{1024};
 
        // Initialise STFT object
        auto m_stft = std::make_unique<ShortTimeFourierTransform>(
                analysisFrameSize, analysisFrameSize, hopSize, WindowType::Hann,
                ShortTimeFourierTransform::fftMode::freqMagOnly, static_cast<int>(getSourceSampleRate()));
 
        // Initialise TimeDomain analysis framework object
        auto timeAnalysisFramework = std::make_unique<TimeDomainAnalysisFramework>(
                analysisFrameSize, static_cast<int>(getSourceSampleRate()));
 
        // Initialise FreqDomain analysis framework object
        auto freqAnalysisFramework = std::make_unique<FrequencyDomainAnalysisFramework>(
                (analysisFrameSize), static_cast<int>(getSourceSampleRate()));
        freqAnalysisFramework.get()->setFrequencyVector(
                m_stft.get()->getBinsSTL(ShortTimeFourierTransform::FrequencyRange::Half));
 
        for (const auto& segment : timeDomainSlices)
        {
            //++++++++++++++++++++++++++ Perform Time Domain Analysis
            //+++++++++++++++++++++++++++++++++++++++++++++++++ Get RMS Pass
            // each frame to the timeAnalysisFramework to analyse
            timeAnalysisFramework->setSignalFrame(segment);
            // Update descriptors with analysis values
            float RMS = timeAnalysisFramework->getRMS();
 
            //++++++++++++++++++++++++++ Perform Frequency Domain Analysis
            //+++++++++++++++++++++++++++++++++++++++++++++ Retrieve all the
            // spectral frames from STFT for each onset segment
            AudioSampleBuffer segmentBuffer(1, static_cast<int>(segment.size()));
            segmentBuffer.copyFrom(0, 0, segment.data(), static_cast<int>(segment.size()));
            auto spectralFrames = m_stft.get()->stft(segmentBuffer);
 
            float centroid = 0.0f;
 
            for (const auto& spectralSegment : spectralFrames)
            {
                // Pass each frame to the frequencyAnalysisFramework to analyse
                freqAnalysisFramework->setSpectralFrame(spectralSegment);
 
                // Get centroids
                centroid += freqAnalysisFramework->getSpectralCentroid();
            }
 
            // Average centroids for this onsetSegment
            float avgCentroid = centroid / spectralFrames.size();
            // Update features
            features.emplace_back(std::initializer_list<float>{avgCentroid, RMS, 1.f, 1.f});
 
            segmentBuffer.clear();
        }
 
        return features;
    }
 
    std::vector<std::vector<float>> KrotosAudioBufferDSP::specFlatnessRMS_FeatureExtraction(
            std::vector<std::vector<float>>& timeDomainSlices)
    {
        std::vector<std::vector<float>> features;
        // Initialise the STFT parameters
        const int analysisFrameSize{2048};
        const int hopSize{1024};
 
        // Initialise STFT object
        auto m_stft = std::make_unique<ShortTimeFourierTransform>(
                analysisFrameSize, analysisFrameSize, hopSize, WindowType::Hann,
                ShortTimeFourierTransform::fftMode::freqMagOnly, static_cast<int>(getSourceSampleRate()));
 
        // Initialise TimeDomain analysis framework object
        auto timeAnalysisFramework = std::make_unique<TimeDomainAnalysisFramework>(
                analysisFrameSize, static_cast<int>(getSourceSampleRate()));
 
        // Initialise FreqDomain analysis framework object
        auto freqAnalysisFramework = std::make_unique<FrequencyDomainAnalysisFramework>(
                (analysisFrameSize), static_cast<int>(getSourceSampleRate()));
        freqAnalysisFramework.get()->setFrequencyVector(
                m_stft.get()->getBinsSTL(ShortTimeFourierTransform::FrequencyRange::Half));
 
        for (const auto& segment : timeDomainSlices)
        {
            //++++++++++++++++++++++++++ Perform Time Domain Analysis
            //+++++++++++++++++++++++++++++++++++++++++++++++++ Get RMS Pass
            // each frame to the timeAnalysisFramework to analyse
            timeAnalysisFramework->setSignalFrame(segment);
            // Update descriptors with analysis values
            float RMS = timeAnalysisFramework->getRMS();
 
            //++++++++++++++++++++++++++ Perform Frequency Domain Analysis
            //+++++++++++++++++++++++++++++++++++++++++++++ Retrieve all the
            // spectral frames from STFT for each onset segment
            AudioSampleBuffer segmentBuffer(1, static_cast<int>(segment.size()));
            segmentBuffer.copyFrom(0, 0, segment.data(), static_cast<int>(segment.size()));
            auto spectralFrames = m_stft.get()->stft(segmentBuffer);
 
            float centroid = 0.0f;
 
            for (const auto& spectralSegment : spectralFrames)
            {
                // Pass each frame to the frequencyAnalysisFramework to analyse
                freqAnalysisFramework->setSpectralFrame(spectralSegment);
 
                // Get centroids
                centroid += freqAnalysisFramework->getSpectralFlatness();
            }
 
            // Average centroids for this onsetSegment
            float avgCentroid = centroid / spectralFrames.size();
            // Update features
            features.emplace_back(std::initializer_list<float>{avgCentroid, RMS, 1.f, 1.f});
 
            segmentBuffer.clear();
        }
 
        return features;
    }
 
    std::vector<std::vector<float>> KrotosAudioBufferDSP::erbSpecCentroidRMS_FeatureExtraction(
            std::vector<std::vector<float>>& timeDomainSlices)
    {
        std::vector<std::vector<float>> features;
        // Initialise the analysis parameters
        const int analysisFrameSize{2048};
 
        // Initialise ERB object
        std::unique_ptr<ERB_FFTSpectrogram> m_erb = std::make_unique<ERB_FFTSpectrogram>();
        m_erb.get()->setSampleRate(getSourceSampleRate());
 
        // Initialise TimeDomain analysis framework object
        auto timeAnalysisFramework = std::make_unique<TimeDomainAnalysisFramework>(
                analysisFrameSize, static_cast<int>(getSourceSampleRate()));
 
        // Initialise FreqDomain analysis framework object
        auto freqAnalysisFramework = std::make_unique<FrequencyDomainAnalysisFramework>(
                (analysisFrameSize), static_cast<int>(getSourceSampleRate()));
        freqAnalysisFramework.get()->setFrequencyVector(m_erb.get()->getERBSpace());
 
        for (auto& segment : timeDomainSlices)
        {
            //++++++++++++++++++++++++++ Perform Time Domain Analysis
            //+++++++++++++++++++++++++++++++++++++++++++++++++ Get RMS Pass
            // each frame to the timeAnalysisFramework to analyse
            timeAnalysisFramework->setSignalFrame(segment);
            // Update descriptors with analysis values
            float RMS = timeAnalysisFramework->getRMS();
 
            //++++++++++++++++++++++++++ Perform Frequency Domain Analysis
            //+++++++++++++++++++++++++++++++++++++++++++++ Pass each segment to
            // the ERB object to transform
            auto erbFrames = m_erb.get()->filterSpectrum(segment);
 
            float centroid = 0.0f;
 
            for (const auto& spectralSegment : erbFrames)
            {
                // Pass each frame to the frequencyAnalysisFramework to analyse
                freqAnalysisFramework->setSpectralFrame(spectralSegment);
 
                // Get centroids
                centroid += freqAnalysisFramework->getSpectralCentroid();
            }
 
            // Average centroids for this onsetSegment
            float avgCentroid = centroid / erbFrames.size();
            // Update features
            features.emplace_back(std::initializer_list<float>{avgCentroid, RMS, 1.f, 1.f});
        }
 
        return features;
    }
 
    std::vector<std::vector<float>> KrotosAudioBufferDSP::erbSpecCentroidFlatness_FeatureExtraction(
            std::vector<std::vector<float>>& timeDomainSlices)
    {
        std::vector<std::vector<float>> features;
        // Initialise the analysis parameters
        const int analysisFrameSize{2048};
 
        // Initialise ERB object
        std::unique_ptr<ERB_FFTSpectrogram> m_erb = std::make_unique<ERB_FFTSpectrogram>();
        m_erb.get()->setSampleRate(getSourceSampleRate());
 
        // Initialise FreqDomain analysis framework object
        auto freqAnalysisFramework = std::make_unique<FrequencyDomainAnalysisFramework>(
                (analysisFrameSize), static_cast<int>(getSourceSampleRate()));
        freqAnalysisFramework.get()->setFrequencyVector(m_erb.get()->getERBSpace());
 
        for (auto& segment : timeDomainSlices)
        {
            //++++++++++++++++++++++++++ Perform Frequency Domain Analysis
            //+++++++++++++++++++++++++++++++++++++++++++++ Pass each segment to
            // the ERB object to transform
            auto erbFrames = m_erb.get()->filterSpectrum(segment);
 
            float centroid = 0.0f;
            float flatness = 0.0f;
 
            for (const auto& spectralSegment : erbFrames)
            {
                // Pass each frame to the frequencyAnalysisFramework to analyse
                freqAnalysisFramework->setSpectralFrame(spectralSegment);
 
                // Set vector of frequencies to calculate spectral feature on
 
                // Get centroids
                centroid += freqAnalysisFramework->getSpectralCentroid();
 
                // Get flatness
                flatness += freqAnalysisFramework->getSpectralFlatness();
            }
 
            // Average centroids for this onsetSegment
            float avgCentroid = centroid / erbFrames.size();
 
            // Average Flatness for this onsetSegment
            float avgFlatness = flatness / erbFrames.size();
 
            // Update features
            features.emplace_back(std::initializer_list<float>{avgCentroid, avgFlatness, 1.f, 1.f});
        }
 
        return features;
    }
 
    std::vector<std::vector<float>> KrotosAudioBufferDSP::pitchPeakRMSFeatureExtraction(
            std::vector<std::vector<float>>& timeDomainSlices)
    {
        std::vector<std::vector<float>> features;
 
        for (const auto& segment : timeDomainSlices)
        {
 
            // Careful here !! Works only for overlapping windows of same length
            auto timeAnalysisFramework = std::make_unique<TimeDomainAnalysisFramework>(
                    static_cast<int>(segment.size()), static_cast<int>(getSourceSampleRate()));
            //++++++++++++++++++++++++++ Perform Time Domain Analysis
            //+++++++++++++++++++++++++++++++++++++++++++++++++ Get RMS Pass
            // each frame to the timeAnalysisFramework to analyse
            timeAnalysisFramework->setSignalFrame(segment);
            // Update descriptors with analysis values
            float RMS = timeAnalysisFramework->getRMS();
            // Get Pitch Mcleod
            float pitch = timeAnalysisFramework->getPitchAutocorrelation();
            // Get Peak Energy
            float peakEnergy = timeAnalysisFramework->getPeakEnergy();
 
            // Update features
            features.emplace_back(std::initializer_list<float>{pitch, peakEnergy, RMS, 1.f});
 
            timeAnalysisFramework.release();
        }
 
        return features;
    }
 
    std::vector<std::vector<float>> KrotosAudioBufferDSP::harmonicPitchEstimation(
            std::vector<std::vector<float>>& timeDomainSlices)
    {
        // Place holder for Harmonic Signal Representation. At the moment useful only for debugging SWIPE Pitch
        // estimation algorithm.
 
        auto harmonicRep = std::make_unique<HarmonicRepresentation>(getSourceSampleRate());
 
        // TODO: Once porting to Eigen is completed use this to concatenate all matrices returned from
        //  harmonic signal representation
        //  Resize harmRep.value if necessary to accommodate the concatenated matrix
        /*
        if (harmRepValue.rows() == 0)
        {
            harmRepValue = concatenatedMatrix;
        }
        else
        {
            harmRepValue.conservativeResize(harmRepValue.rows() + concatenatedMatrix.rows(), Eigen::NoChange);
            harmRepValue.bottomRows(concatenatedMatrix.rows()) = concatenatedMatrix;
        }
        */
        // Call calculate pitch for each segment
        for (auto& timeSlice : timeDomainSlices)
        {
            auto harmonicPair = harmonicRep->processSignal(timeSlice);
        }
 
        // Return just the timeDomain signals, no feature extraction atm!!
        return timeDomainSlices;
    }
 
    void KrotosAudioBufferDSP::applyPCA(std::vector<std::vector<float>>& features, const size_t& n_components)
    {
        m_principalComponentAnalysis = std::make_unique<PCA>();
        for (const auto& feature : features)
        {
            m_principalComponentAnalysis->insert(feature);
        }
 
        m_principalComponentAnalysis->fit(n_components);
        for (size_t i = 0; i < features.size(); ++i)
        {
            features[i] = m_principalComponentAnalysis->getPrincipalComponents(i);
        }
    }
 
    void KrotosAudioBufferDSP::setFeaturesAndNormalise(const std::vector<std::vector<float>>& features,
                                                       std::vector<AudioDescriptor>& descriptorsTime)
    {
        size_t i = 0;
        for (const auto& feature : features)
        {
            descriptorsTime.at(i).principalX = feature.at(0);
            descriptorsTime.at(i).principalY = feature.at(1);
            descriptorsTime.at(i).principalZ = feature.at(2);
            descriptorsTime.at(i).principalQ = feature.at(3);
            ++i;
        }
        normaliseAudioDescriptorFeature(
                descriptorsTime, [](AudioDescriptor& feat) { return &feat.principalX; }, 0.08f);
        normaliseAudioDescriptorFeature(
                descriptorsTime, [](AudioDescriptor& feat) { return &feat.principalY; }, 0.08f);
        normaliseAndInvertAudioDescriptorFeature(descriptorsTime,
                                                 [](AudioDescriptor& feat) { return &feat.principalZ; });
        normaliseAudioDescriptorFeature(descriptorsTime, [](AudioDescriptor& feat) { return &feat.principalQ; });
 
        std::sort(descriptorsTime.begin(), descriptorsTime.end(),
                  [](AudioDescriptor& a, AudioDescriptor& b) { return a.principalZ > b.principalZ; });
    }
 
    void KrotosAudioBufferDSP::buildKNNIndex(const std::vector<AudioDescriptor>& descriptorsTime)
    {
        m_nnSearch = std::make_unique<krotos::KDTree>();
        for (auto& grain : descriptorsTime)
        {
            m_nnSearch->addDatasetItem(grain.principalX, grain.principalY);
        }
        m_nnSearch->buildIndex();
    }
 
    void KrotosAudioBufferDSP::buildKNNIndexWithZ(const std::vector<AudioDescriptor>& descriptorsTime)
    {
        m_nnSearch = std::make_unique<krotos::KDTree>();
        for (auto& grain : descriptorsTime)
        {
            m_nnSearch->addDatasetItem(grain.principalX, grain.principalY, grain.principalZ);
        }
        m_nnSearch->buildIndex();
    }
 
    void KrotosAudioBufferDSP::sortByZ(const std::vector<AudioDescriptor>& descriptorsTime)
    {
        // Creating a version sorted by Z to aid with back to front blob
        // drawing in the grain display
        // std::vector<AudioDescriptor> byZ = descriptorsTime;
        // std::sort(byZ.begin(), byZ.end(), [](AudioDescriptor& a,
        // AudioDescriptor& b) { return a.principalC > b.principalC; });
 
        if (descriptorsTime.size() > 0)
        {
            // Temporary everything sorted by Z for graphics
            m_grainDescriptionByFrequency = descriptorsTime;
            m_grainDescriptionByTime = descriptorsTime;
            m_grainDescriptionByZ = descriptorsTime;
        }
    }
 
    void KrotosAudioBufferDSP::cleanupAnalysis()
    {
        m_timeDomainSlices.clear();
        m_timeDomainSlices.shrink_to_fit();
        m_onsetPositions.clear();
        m_onsetPositions.shrink_to_fit();
        m_descriptorsTime.clear();
        m_descriptorsTime.shrink_to_fit();
        m_grainDescriptionByFrequency.clear();
        m_grainDescriptionByFrequency.shrink_to_fit();
        m_grainDescriptionByTime.clear();
        m_grainDescriptionByTime.shrink_to_fit();
        m_grainDescriptionByZ.clear();
        m_grainDescriptionByZ.shrink_to_fit();
    }
 
    void KrotosAudioBufferDSP::generalScheme()
    {
        if (threadShouldExit())
            return;
 
        if (this->size() <= 4)
            return; // won't fail after 1 successful load? discussed w/sandy
        if (this->getSourceSampleRate() == 0.0f)
            return; // edge case of loaded file thats a missing path
 
        // Average Buffer to mono
        std::vector<float> bufferVector = averageBufferToMono();
 
        m_progressTracker.setNumStages(5);
 
        // Clear vectors of onsetPositions and Slices
        m_timeDomainSlices.clear();
        m_onsetPositions.clear();
        m_descriptorsTime.clear();
 
        if (threadShouldExit())
            return;
 
        // Perform Segmentation according to method
        m_progressTracker.stage("Segment");
        switch (m_segmentationMethod)
        {
        case krotos::KrotosAudioBufferDSP::SegmentationMethod::SegmentationNone: {
            // Return whole buffer
            m_timeDomainSlices.push_back(bufferVector);
            m_onsetPositions.push_back(0);
            break;
        }
        case krotos::KrotosAudioBufferDSP::SegmentationMethod::STFT: {
            // Initialise the STFT parameters
            auto exponent =
                    static_cast<float>(roundToInt(jmap<float>(m_AnalysisCoefficients.coeff0, 0.f, 1.f, 0.f, 4.f)));
            int analysisFrameSize = static_cast<int>(powf(2.0f, exponent)) * 512;
            float hopFactor = m_AnalysisCoefficients.coeff1;
            if (hopFactor <= 0.1f)
                hopFactor = 0.1f;
 
            int hopSizeSamples = static_cast<int>(static_cast<float>(analysisFrameSize) * hopFactor);
 
            m_onsetPositions = chunk(bufferVector, analysisFrameSize, hopSizeSamples);
            m_timeDomainSlices = segmentChunks(m_onsetPositions, bufferVector, analysisFrameSize);
            break;
        }
        case krotos::KrotosAudioBufferDSP::SegmentationMethod::EnvOnset: {
            m_onsetPositions = envelopeOnsetDetection(bufferVector, getSourceSampleRate());
            m_timeDomainSlices = segmentOnsetSlices(m_onsetPositions, bufferVector);
            break;
        }
        case krotos::KrotosAudioBufferDSP::SegmentationMethod::OverlapWindow: {
            const auto window_length = static_cast<size_t>(getSourceSampleRate()); // 1 second audio clips
            const auto hop_length = window_length / 2;                             // ...that overlap
            m_onsetPositions = chunk(bufferVector, window_length, hop_length);
            m_timeDomainSlices = segmentChunks(m_onsetPositions, bufferVector, window_length);
            break;
        }
        case krotos::KrotosAudioBufferDSP::SegmentationMethod::SuperFlux: {
            // Contains slices of the buffer produced by the onset positions
            m_onsetPositions = superFluxOnsetDetection(getSourceSampleRate());
            m_timeDomainSlices = segmentOnsetSlices(m_onsetPositions, bufferVector);
            break;
        }
        default: {
            jassertfalse;
            break;
        }
        }
 
        if (threadShouldExit())
            return;
 
        // Feature extraction results
        std::vector<std::vector<float>> features;
 
        // Perform Feature Extraction according to method
        m_progressTracker.stage("Feature Extraction");
        switch (m_featureMethod)
        {
        case krotos::KrotosAudioBufferDSP::FeatureExtrMethod::FeatureExtrMethodNone: {
            m_grainDescriptionByFrequency.clear();
            m_grainDescriptionByTime.clear();
            m_grainDescriptionByZ.clear();
            break;
        }
        case krotos::KrotosAudioBufferDSP::FeatureExtrMethod::MFCC_PCA: {
            features = mfccFeatureExtraction(m_timeDomainSlices, m_onsetPositions);
            applyPCA(features, 4);
            break;
        }
        case krotos::KrotosAudioBufferDSP::FeatureExtrMethod::Centroid_Level: {
            features = temporalFeatureExtraction(m_timeDomainSlices);
            break;
        }
        case krotos::KrotosAudioBufferDSP::FeatureExtrMethod::SpCentroid_RMS: {
            features = specCntrRMS_FeatureExtraction(m_timeDomainSlices);
            break;
        }
        case krotos::KrotosAudioBufferDSP::FeatureExtrMethod::SpFlatness_RMS: {
            features = specFlatnessRMS_FeatureExtraction(m_timeDomainSlices);
            break;
        }
        case krotos::KrotosAudioBufferDSP::FeatureExtrMethod::ERBSpCentroid_RMS: {
            features = erbSpecCentroidRMS_FeatureExtraction(m_timeDomainSlices);
            break;
        }
        case krotos::KrotosAudioBufferDSP::FeatureExtrMethod::ERBSpCentroid_ERBSpFlatness: {
            features = erbSpecCentroidFlatness_FeatureExtraction(m_timeDomainSlices);
            break;
        }
        case krotos::KrotosAudioBufferDSP::FeatureExtrMethod::Harmonic_PitchEstimation: {
            features = harmonicPitchEstimation(m_timeDomainSlices);
            break;
        }
        default: {
            jassertfalse;
            break;
        }
        }
        // Get time descriptors
        m_descriptorsTime = getDescriptorsTime(m_timeDomainSlices, m_onsetPositions);
 
        m_progressTracker.stage("Normalise Features");
        setFeaturesAndNormalise(features, m_descriptorsTime);
        if (threadShouldExit())
            return;
 
        m_progressTracker.stage("Build KNN Index");
        if (!m_descriptorsTime.empty())
            buildKNNIndex(m_descriptorsTime);
        if (threadShouldExit())
            return;
 
        m_progressTracker.stage("Sort By Z");
        sortByZ(m_descriptorsTime);
        if (threadShouldExit())
            return;
 
        m_progressTracker.end("Analysis Complete"); // Call this when you are done - message
                                                    // probably so briefly on screen it wont
                                                    // be readable
 
        validate(); // Call this at the very end of analysis, when we are guaranteed the results are valid
    }
 
    static bool compareByAudioIndex(const AudioDescriptor& a, const AudioDescriptor& b)
    {
        return a.audioIndex < b.audioIndex;
    }
 
    static bool compareByAudioFrequency(const AudioDescriptor& a, const AudioDescriptor& b)
    {
        return a.frequency < b.frequency;
    }
 
    AudioDescriptor& KrotosAudioBufferDSP::audioIndexToDescriptor(int audioIndex)
    {
        const auto result = std::lower_bound(m_grainDescriptionByTime.begin(), m_grainDescriptionByTime.end(),
                                             AudioDescriptor{0, 0, audioIndex, 0}, &compareByAudioIndex);
 
        if (result == m_grainDescriptionByTime.begin())
        {
            return m_grainDescriptionByTime[0];
        }
        else
        {
            const auto retval = result - 1;
 
            if (retval >= m_grainDescriptionByTime.end())
            {
                return m_grainDescriptionByTime[0];
            }
            else
            {
                return *retval;
            }
        }
    }
 
    AudioDescriptor& KrotosAudioBufferDSP::audioFrequencyToDescriptor(float frequency)
    {
        const auto result = std::lower_bound(m_grainDescriptionByFrequency.begin(), m_grainDescriptionByFrequency.end(),
                                             AudioDescriptor{frequency, 0, 0, 0}, &compareByAudioFrequency);
 
        if (result == m_grainDescriptionByFrequency.begin())
        {
            return m_grainDescriptionByFrequency[0];
        }
        else
        {
            const auto retval = result - 1;
 
            if (retval >= m_grainDescriptionByFrequency.end())
            {
                return m_grainDescriptionByFrequency[m_grainDescriptionByFrequency.size() - 1];
            }
            else
            {
                return *retval;
            }
        }
    }
 
    inline void KrotosAudioBufferDSP::clampGrainDescriptionByTimeIndex(size_t& index)
    {
        if (index >= m_grainDescriptionByTime.size())
            index = m_grainDescriptionByTime.size() - 1;
    }
 
    inline StereoSample KrotosAudioBufferDSP::getSampleFromGrainPhase(double grainPhase)
    {
        if (!m_grainDescriptionByTime.size())
        {
            jassertfalse; // You called this method with an empty grainDescriptionByTime vector
            return StereoSample{0.f, 0.f};
        }
        auto grain = size_t(grainPhase);
        double phase = grainPhase - double(grain);
        clampGrainDescriptionByTimeIndex(grain);
        return getInterpolatedSample(static_cast<double>(m_grainDescriptionByTime[grain].audioIndex) +
                                     (static_cast<double>(m_grainDescriptionByTime[grain].grainSize) * phase));
    }
 
    inline double KrotosAudioBufferDSP::getFrequencyFromGrainPhase(double grainPhase)
    {
        auto grain = size_t(grainPhase);
        double phase = grainPhase - static_cast<double>(grain);
        auto nextGrain = grain + 1;
        clampGrainDescriptionByTimeIndex(grain);
        clampGrainDescriptionByTimeIndex(nextGrain);
        return juce::jmap<double>(phase, 0.0, 1.0, static_cast<double>(m_grainDescriptionByTime[grain].frequency),
                                  static_cast<double>(m_grainDescriptionByTime[nextGrain].frequency));
    }
 
    AudioDescriptor& KrotosAudioBufferDSP::audioPercentToDescriptor(float audioPercent)
    {
        return audioIndexToDescriptor(int(float(getNumSamples()) * audioPercent));
    }
 
    AnalysisCoefficients& KrotosAudioBufferDSP::getAnalysisCoefficients() { return m_AnalysisCoefficients; }
 
} // namespace krotos