Method process

src/core/ClientComp.cpp:233–344

}

void ClientComp::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);

    // Pre-comp PAPR shaping (#2887). The rotator runs first to
    // symmetrize asymmetric voice peaks; the drive gain then pushes
    // more material across the threshold so the existing comp curve
    // engages harder and the brickwall limiter below contains the
    // resulting hot peaks. These run independent of the comp's enabled
    // flag — they're a useful pair even when the comp curve itself is
    // bypassed (Drive + Limiter alone is the simplest broadcast PAPR
    // setup). Their work happens *before* the input peak meter so the
    // GR readout reflects the comp's workload at the boosted level.
    if (m_cached.phaseRotatorStages > 0 && m_phaseRotator) {
        m_phaseRotator->process(interleaved, frames, channels);
    }
    if (m_cached.driveLin != 1.0f) {
        const float gain = m_cached.driveLin;
        const int n = frames * channels;
        for (int i = 0; i < n; ++i) interleaved[i] *= gain;
    }

    float inPeakLin  = 0.0f;
    float outPeakLin = 0.0f;
    float worstGrDb  = 0.0f;  // most negative (largest reduction)
    float worstLimGrDb = 0.0f;  // limiter-only GR, most negative
    bool  limFired   = false;

    const float attackCoeff  = m_cached.attackCoeff;
    const float releaseCoeff = m_cached.releaseCoeff;
    const float makeup       = m_cached.makeupLin;
    const float limCeiling   = m_cached.limCeilingLin;
    const float limAttack    = m_cached.limAttackCoeff;
    const float limRelease   = m_cached.limReleaseCoeff;

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

        const float inAbs = std::max(std::fabs(l), std::fabs(r));
        if (inAbs > inPeakLin) inPeakLin = inAbs;

        // Compressor gain (only applied if enabled).  Linear-domain peak
        // envelope: smoothed |x| with asymmetric attack/release, converted
        // to dB once to feed the static curve.  This tracks the actual
        // peak amplitude of the signal (unlike a dB-domain filter that
        // would average log|x| and read ~4 dB below peak on a sine).
        float gainLin = 1.0f;
        if (enabled) {
            const float alpha = (inAbs > m_envLin) ? attackCoeff : releaseCoeff;
            m_envLin += alpha * (inAbs - m_envLin);
            const float envDb = linToDb(std::max(m_envLin, 1e-6f));
            const float gainDb = staticCurveGainDb(envDb);
            if (gainDb < worstGrDb) worstGrDb = gainDb;