detectDownbeat()

bool fl::audio::detector::Downbeat::detectDownbeat ( u32 timestamp, float accent )

private

Definition at line 220 of file downbeat.cpp.hpp.

                                                         {
    // Downbeat detection strategy:
    // 1. Check if we're at the expected measure boundary
    // 2. Check if accent is strong enough
    // 3. Check if pattern matches metric grouping
 
    // If we haven't detected any downbeats yet, consider this one
    if (mLastDownbeatTime == 0) {
        // Use accent strength for initial confidence instead of fixed 0.5
        // This provides a better estimate based on actual audio characteristics
        float meanAccent = 1.0f;
        if (!mBeatAccents.empty()) {
            float sum = 0.0f;
            for (size i = 0; i < mBeatAccents.size(); i++) {
                sum += mBeatAccents[i];
            }
            meanAccent = sum / static_cast<float>(mBeatAccents.size());
        }
 
        // Calculate accent-based confidence
        // If we have accent history, use it; otherwise use raw accent with moderate confidence
        float accentConfidence = meanAccent > 0.0f
            ? fl::clamp(accent / (meanAccent * mAccentThreshold), 0.0f, 1.0f)
            : fl::clamp(accent * 0.5f, 0.3f, 0.7f);  // Raw accent scaled to 30-70% range
 
        mConfidence = accentConfidence;
        return true;
    }
 
    // Calculate expected downbeat position
    u32 timeSinceDownbeat = timestamp - mLastDownbeatTime;
    float beatInterval = mBeatDetector->getBPM() > 0.0f
        ? (60000.0f / mBeatDetector->getBPM())
        : 500.0f;
    float expectedMeasureDuration = beatInterval * static_cast<float>(mBeatsPerMeasure);
 
    // Check if we're near expected measure boundary
    float timingError = fl::abs(static_cast<float>(timeSinceDownbeat) - expectedMeasureDuration);
    float maxTimingError = beatInterval * 0.4f;  // Allow 40% timing error
    bool nearMeasureBoundary = (timingError < maxTimingError);
 
    // Check if accent is strong enough
    float meanAccent = 1.0f;
    if (!mBeatAccents.empty()) {
        float sum = 0.0f;
        for (size i = 0; i < mBeatAccents.size(); i++) {
            sum += mBeatAccents[i];
        }
        meanAccent = sum / static_cast<float>(mBeatAccents.size());
    }
 
    bool strongAccent = (accent > meanAccent * mAccentThreshold);
 
    // Check if we're at the beat counter boundary
    bool atBeatCounterBoundary = (mBeatsSinceDownbeat >= mBeatsPerMeasure - 1);
 
    // Calculate confidence
    float timingConfidence = 1.0f - (timingError / (beatInterval * 2.0f));
    timingConfidence = fl::clamp(timingConfidence, 0.0f, 1.0f);
 
    float accentConfidence = meanAccent > 0.0f
        ? fl::clamp(accent / (meanAccent * mAccentThreshold), 0.0f, 1.0f)
        : 0.5f;
 
    // Adaptive weighting: favor accent when at beat boundary (structural downbeat)
    // This improves recall for first downbeat after warm-up
    float accentWeight = atBeatCounterBoundary ? 0.7f : 0.5f;
    float timingWeight = atBeatCounterBoundary ? 0.3f : 0.5f;
    mConfidence = (timingConfidence * timingWeight) + (accentConfidence * accentWeight);
 
    // Additional confidence boost for structural downbeats (at beat boundary)
    // This compensates for timing uncertainties in the first few measures
    if (atBeatCounterBoundary && mConfidence < 0.6f) {
        mConfidence = fl::max(mConfidence, 0.55f);  // Ensure minimum confidence at boundaries
    }
 
    // Determine if this is a downbeat
    bool isDownbeat = false;
 
    if (atBeatCounterBoundary) {
        // We're at expected measure boundary - high likelihood of downbeat
        isDownbeat = true;
    } else if (nearMeasureBoundary && strongAccent) {
        // Early/late downbeat with strong accent
        isDownbeat = (mConfidence >= mConfidenceThreshold);
    } else if (strongAccent && mBeatsSinceDownbeat == 0) {
        // Strong accent on first beat (might be downbeat)
        isDownbeat = (mConfidence >= mConfidenceThreshold);
    }
 
    return isDownbeat;
}

References fl::abs(), fl::clamp(), isDownbeat(), mAccentThreshold, fl::max(), mBeatAccents, mBeatDetector, mBeatsPerMeasure, mBeatsSinceDownbeat, mConfidence, mConfidenceThreshold, and mLastDownbeatTime.

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function: