computePCMTimeDomainFeatures()

void fl::audio::detector::Vocal::computePCMTimeDomainFeatures ( span< const i16 > pcm )

private

Definition at line 295 of file vocal.cpp.hpp.

                                                            {
    // Fused single-pass computation of envelope jitter + shimmer AND
    // zero-crossing CV. Previously two separate PCM traversals; now one.
    // Saves ~2-3 us by eliminating redundant PCM reads and cache misses.
    const int n = static_cast<int>(pcm.size());
    if (n < 44) {
        mEnvelopeJitter = 0.0f;
        mZeroCrossingCV = 0.0f;
        return;
    }
 
    const float normFactor = 1.0f / 32768.0f;
    const int halfWin = fl::max(2, mSampleRate / 4000); // ~11 samples at 44100
    const int winSize = 2 * halfWin + 1;
    const float invWinSize = 1.0f / static_cast<float>(winSize);
 
    // Seed the sliding window sum
    float windowSum = 0.0f;
    for (int j = 0; j < winSize && j < n; ++j) {
        windowSum += fl::abs(static_cast<float>(pcm[j])) * normFactor;
    }
 
    // Envelope jitter accumulators
    float sumEnv = 0.0f;
    float sumDev = 0.0f;
    int count = 0;
    float sumPeaks = 0.0f;
    float sumSqPeaks = 0.0f;
    int numCycles = 0;
    float currentPeak = 0.0f;
    bool wasPositive = pcm[halfWin] >= 0;
 
    // Zero-crossing CV accumulators (fused into same loop)
    int prevCrossing = -1;
    int numIntervals = 0;
    float sumIntervals = 0.0f;
    float sumSqIntervals = 0.0f;
 
    for (int i = halfWin; i < n - halfWin; ++i) {
        float absVal = fl::abs(static_cast<float>(pcm[i])) * normFactor;
        float smoothed = windowSum * invWinSize;
 
        sumEnv += smoothed;
        sumDev += fl::abs(absVal - smoothed);
        ++count;
 
        // Shimmer + zero-crossing detection (shared)
        currentPeak = fl::max(currentPeak, absVal);
        bool isPositive = pcm[i] >= 0;
        if (isPositive != wasPositive) {
            // Shimmer: track peaks between zero crossings
            if (currentPeak > 0.01f) {
                sumPeaks += currentPeak;
                sumSqPeaks += currentPeak * currentPeak;
                ++numCycles;
            }
            currentPeak = 0.0f;
 
            // ZC CV: track interval statistics
            if (prevCrossing >= 0) {
                float interval = static_cast<float>(i - prevCrossing);
                sumIntervals += interval;
                sumSqIntervals += interval * interval;
                ++numIntervals;
            }
            prevCrossing = i;
        }
        wasPositive = isPositive;
 
        // Slide window
        if (i + 1 < n - halfWin) {
            windowSum -= fl::abs(static_cast<float>(pcm[i - halfWin])) * normFactor;
            windowSum += fl::abs(static_cast<float>(pcm[i + halfWin + 1])) * normFactor;
        }
    }
 
    // --- Envelope jitter result ---
    if (sumEnv < 1e-6f || count == 0) {
        mEnvelopeJitter = 0.0f;
    } else {
        float envelopeJitter = (sumDev / static_cast<float>(count))
                             / (sumEnv / static_cast<float>(count));
 
        float shimmer = 0.0f;
        if (numCycles >= 3) {
            float meanPeak = sumPeaks / static_cast<float>(numCycles);
            if (meanPeak > 0.01f) {
                float variance = sumSqPeaks / static_cast<float>(numCycles)
                               - meanPeak * meanPeak;
                if (variance < 0.0f) variance = 0.0f;
                shimmer = fl::sqrtf(variance) / meanPeak;
            }
        }
        mEnvelopeJitter = envelopeJitter + shimmer * 0.5f;
    }
 
    // --- Zero-crossing CV result ---
    if (numIntervals < 2) {
        mZeroCrossingCV = 0.0f;
    } else {
        float mean = sumIntervals / static_cast<float>(numIntervals);
        if (mean < 1e-6f) {
            mZeroCrossingCV = 0.0f;
        } else {
            float variance = sumSqIntervals / static_cast<float>(numIntervals)
                           - mean * mean;
            if (variance < 0.0f) variance = 0.0f;
            mZeroCrossingCV = fl::sqrtf(variance) / mean;
        }
    }
}

References fl::abs(), fl::max(), mEnvelopeJitter, mSampleRate, mZeroCrossingCV, fl::span< T, Extent >::size(), and fl::sqrtf().

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function: