Method process

src/core/ClientTube.cpp:205–288

}

void ClientTube::process(float* interleaved, int frames, int channels) noexcept
{
    if (frames <= 0) return;
    if (channels != 1 && channels != 2) return;

    recacheIfDirty();
    const bool enabled = m_atomics.enabled.load(std::memory_order_acquire);

    float inPeakLin  = 0.0f;
    float outPeakLin = 0.0f;
    float maxDriveLin = 0.0f;

    const float baseDrive    = m_cached.baseDriveLin;
    const float outputLin    = m_cached.outputLin;
    const float dryWet       = m_cached.dryWet;
    const float envAmount    = m_cached.envAmount;
    const float attackCoeff  = m_cached.attackCoeff;
    const float releaseCoeff = m_cached.releaseCoeff;
    const float toneCoef     = m_cached.toneCoeff;
    const float tone         = m_cached.tone;

    for (int f = 0; f < frames; ++f) {
        const float dryL = interleaved[f * channels];
        const float dryR = (channels == 2)
            ? interleaved[f * channels + 1] : dryL;

        const float inAbs = std::max(std::fabs(dryL), std::fabs(dryR));
        if (inAbs > inPeakLin) inPeakLin = inAbs;

        // Envelope follower for dynamic drive.
        const float alpha = (inAbs > m_envLin) ? attackCoeff : releaseCoeff;
        m_envLin += alpha * (inAbs - m_envLin);

        // Effective drive: baseDrive * (1 + envAmount * envLin).
        //   envAmount = 0        → static drive (no modulation)
        //   envAmount = +1       → at full-scale input, drive × 2
        //   envAmount = -1       → at full-scale input, drive × 0
        // Clamped to [0.1, 10] so an aggressive negative envelope at
        // a loud level doesn't zero the drive entirely.
        const float envMod  = 1.0f + envAmount * m_envLin;
        const float drive   = std::clamp(baseDrive * envMod, 0.1f, 10.0f);
        if (drive > maxDriveLin) maxDriveLin = drive;

        // Per-channel tone pre-filter (simple one-pole LP with HP
        // blend).  m_toneState holds the LP output; the shaper sees
        // dry blended toward HP (tone > 0) or LP (tone < 0).
        auto shapeChan = [&](float x, float& state) {
            state += toneCoef * (x - state);
            const float lp = state;
            const float hp = x - state;
            const float shaped = (tone >= 0.0f)
                ? x + tone * (hp - x * 0.5f)      // brighten
                : x + (-tone) * (lp - x * 0.5f);  // darken
            return shape(shaped * drive);
        };

        const float wetL = shapeChan(dryL, m_toneStateL);
        const float wetR = (channels == 2)