classify()

SoundState animartrix_ring::SoundOrchestrator::classify ( fl::u32 nowMs )

private

Definition at line 101 of file sound_orchestrator.cpp.

                                                  {
    if (!mProcessor) return SoundState::Silence;
 
    const bool isSilent = mProcessor->isSilent();
 
    // Silence has its own asymmetric hysteresis (enter slow, exit fast) so a
    // single audio sample can wake us up promptly but a brief gap won't drop
    // us into ambient mode mid-song.
    if (isSilent) {
        if (mSilentSinceMs == 0) mSilentSinceMs = nowMs;
        mNonSilentSinceMs = 0;
    } else {
        if (mNonSilentSinceMs == 0) mNonSilentSinceMs = nowMs;
        mSilentSinceMs = 0;
    }
 
    // --- raw signals ---
    const float tempoConf = mProcessor->getTempoConfidence();
    const float beatConf  = mProcessor->getBeatConfidence();
 
    // Silence-exit gate: when we're currently in Silence, require the
    // configured silenceExitMs of *contiguous* non-silent audio before we
    // even consider leaving. Without this, mNonSilentSinceMs would be
    // tracked but never consulted, so a single non-silent frame would
    // immediately bounce us out -- defeating the asymmetric silence
    // hysteresis documented on OrchestratorConfig.
    const bool silenceReleased =
        !isSilent &&
        mNonSilentSinceMs != 0 &&
        (nowMs - mNonSilentSinceMs) >= mCfg.silenceExitMs;
 
    // --- determine the candidate (instantaneous) state ---
    SoundState instant;
    if (isSilent && mSilentSinceMs && (nowMs - mSilentSinceMs) >= mCfg.silenceEnterMs) {
        instant = SoundState::Silence;
    } else if (mState == SoundState::Silence && !silenceReleased) {
        // Hold Silence until the non-silent run reaches silenceExitMs.
        instant = SoundState::Silence;
    } else if (!isSilent &&
               tempoConf >= mCfg.tempoConfidenceEnter &&
               beatConf  >= mCfg.beatConfidenceEnter) {
        instant = SoundState::BpmLocked;
    } else if (mState == SoundState::BpmLocked &&
               (tempoConf >= mCfg.tempoConfidenceExit &&
                beatConf  >= mCfg.beatConfidenceExit)) {
        // Stay locked: we're below "enter" but above "exit" thresholds.
        instant = SoundState::BpmLocked;
    } else if (mState == SoundState::Silence && isSilent) {
        instant = SoundState::Silence;
    } else {
        instant = SoundState::Disorganized;
    }
 
    // --- hysteresis: candidate must hold for classifierHysteresisMs AND
    //     current state must have served minDwellMs before we accept the switch.
    if (instant != mState) {
        if (instant != mCandidate) {
            mCandidate = instant;
            mCandidateSinceMs = nowMs;
        }
        const fl::u32 candidateHeld = nowMs - mCandidateSinceMs;
        const fl::u32 stateHeld     = nowMs - mStateEnteredAtMs;
        if (candidateHeld >= mCfg.classifierHysteresisMs &&
            stateHeld     >= mCfg.minDwellMs) {
            return instant;
        }
        return mState; // not yet -- hold current state
    }
 
    // Candidate matches current state; reset candidate tracker.
    mCandidate = mState;
    mCandidateSinceMs = nowMs;
    return mState;
}

References animartrix_ring::BpmLocked, animartrix_ring::Disorganized, isSilent, mCandidate, mCandidateSinceMs, mCfg, mNonSilentSinceMs, mProcessor, mSilentSinceMs, mState, mStateEnteredAtMs, and animartrix_ring::Silence.

Referenced by tick().

Here is the caller graph for this function: