NF0T
diff --git a/‎CMakeLists.txt‎
Lines changed: 3 additions & 1 deletion b/‎CMakeLists.txt‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎src/core/AudioEngine.cpp‎
Lines changed: 32 additions & 2 deletions b/‎src/core/AudioEngine.cpp‎
Lines changed: 32 additions & 2 deletions
diff --git a/‎src/core/ClientComp.cpp‎
Lines changed: 67 additions & 2 deletions b/‎src/core/ClientComp.cpp‎
Lines changed: 67 additions & 2 deletions
diff --git a/‎src/core/ClientComp.h‎
Lines changed: 27 additions & 1 deletion b/‎src/core/ClientComp.h‎
Lines changed: 27 additions & 1 deletion
diff --git a/‎src/core/ClientDeEss.cpp‎
Lines changed: 47 additions & 9 deletions b/‎src/core/ClientDeEss.cpp‎
Lines changed: 47 additions & 9 deletions
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.20)
-project(AetherSDR VERSION 26.5.2.1 LANGUAGES C CXX)
+project(AetherSDR VERSION 26.5.3 LANGUAGES C CXX)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -437,6 +437,7 @@ set(CORE_SOURCES
     src/core/ClientPudu.cpp
     src/core/ClientPuduMonitor.cpp
     src/core/ClientReverb.cpp
+    src/core/ClientPhaseRotator.cpp
     src/core/ClientFinalLimiter.cpp
     src/core/ClientTxTestTone.cpp
     src/core/ClientQuindarTone.cpp
@@ -1310,6 +1311,7 @@ set_target_properties(client_eq_smoothing_test PROPERTIES AUTOMOC ON)
 add_executable(client_comp_test
     tests/client_comp_test.cpp
     src/core/ClientComp.cpp
+    src/core/ClientPhaseRotator.cpp
 )
 target_include_directories(client_comp_test PRIVATE src)
 
 
@@ -1779,7 +1779,12 @@ void AudioEngine::applyClientEqTxFloat32(QByteArray& float32)
 
 void AudioEngine::applyClientCompTxInt16(QByteArray& int16stereo)
 {
-    if (!m_clientCompTx || !m_clientCompTx->isEnabled()) return;
+    if (!m_clientCompTx) return;
+    const bool compOn   = m_clientCompTx->isEnabled();
+    const bool driveOn  = m_clientCompTx->driveDb() > 0.0f;
+    const bool phaseOn  = m_clientCompTx->phaseRotatorStages() > 0;
+    const bool limOn    = m_clientCompTx->limiterEnabled();
+    if (!compOn && !driveOn && !phaseOn && !limOn) return;
     if (int16stereo.isEmpty()) return;
 
     const int samples = int16stereo.size() / static_cast<int>(sizeof(int16_t));
@@ -1802,7 +1807,16 @@ void AudioEngine::applyClientCompTxInt16(QByteArray& int16stereo)
 
 void AudioEngine::applyClientCompTxFloat32(QByteArray& float32)
 {
-    if (!m_clientCompTx || !m_clientCompTx->isEnabled()) return;
+    if (!m_clientCompTx) return;
+    // Drive and Phase (#2887) and the brickwall limiter inside the comp
+    // are useful even when the comp curve itself is bypassed, so the
+    // dispatch only short-circuits when none of the four sub-stages
+    // need to run.
+    const bool compOn   = m_clientCompTx->isEnabled();
+    const bool driveOn  = m_clientCompTx->driveDb() > 0.0f;
+    const bool phaseOn  = m_clientCompTx->phaseRotatorStages() > 0;
+    const bool limOn    = m_clientCompTx->limiterEnabled();
+    if (!compOn && !driveOn && !phaseOn && !limOn) return;
     if (float32.isEmpty()) return;
     const int samples  = float32.size() / static_cast<int>(sizeof(float));
     const int channels = (samples % 2 == 0) ? 2 : 1;
@@ -2608,6 +2622,10 @@ void AudioEngine::loadClientCompSettings()
         s.value("ClientCompTxLimEnabled", "True").toString() == "True");
     m_clientCompTx->setLimiterCeilingDb(
         s.value("ClientCompTxLimCeilingDb", "-1.0").toFloat());
+    m_clientCompTx->setDriveDb(
+        s.value("ClientCompTxDriveDb", "0.0").toFloat());
+    m_clientCompTx->setPhaseRotatorStages(
+        s.value("ClientCompTxPhaseRotatorStages", "0").toInt());
 
     // Load the generalised chain — stored as a comma-separated list of
     // stage names (e.g. "Gate,Eq,DeEss,Comp,Tube,Enh").  Migrate from
@@ -2661,6 +2679,10 @@ void AudioEngine::saveClientCompSettings() const
     s.setValue("ClientCompTxLimEnabled",  toBool(m_clientCompTx->limiterEnabled()));
     s.setValue("ClientCompTxLimCeilingDb",
                QString::number(m_clientCompTx->limiterCeilingDb()));
+    s.setValue("ClientCompTxDriveDb",
+               QString::number(m_clientCompTx->driveDb()));
+    s.setValue("ClientCompTxPhaseRotatorStages",
+               QString::number(m_clientCompTx->phaseRotatorStages()));
     // Chain stages persist as a comma-separated name list — already
     // written live by setTxChainStages() but re-emitted here so a
     // saveClientCompSettings() call dumps everything in sync.
@@ -2841,6 +2863,8 @@ void AudioEngine::loadClientDeEssSettings()
         s.value("ClientDeEssTxAttackMs", "1.0").toFloat());
     m_clientDeEssTx->setReleaseMs(
         s.value("ClientDeEssTxReleaseMs", "100.0").toFloat());
+    m_clientDeEssTx->setSlopeStages(
+        s.value("ClientDeEssTxSlopeStages", "2").toInt());
 }
 
 void AudioEngine::saveClientDeEssSettings() const
@@ -2862,6 +2886,8 @@ void AudioEngine::saveClientDeEssSettings() const
         QString::number(m_clientDeEssTx->attackMs()));
     s.setValue("ClientDeEssTxReleaseMs",
         QString::number(m_clientDeEssTx->releaseMs()));
+    s.setValue("ClientDeEssTxSlopeStages",
+        QString::number(m_clientDeEssTx->slopeStages()));
 }
 
 void AudioEngine::loadClientDeEssRxSettings()
@@ -2882,6 +2908,8 @@ void AudioEngine::loadClientDeEssRxSettings()
         s.value("ClientDeEssRxAttackMs", "1.0").toFloat());
     m_clientDeEssRx->setReleaseMs(
         s.value("ClientDeEssRxReleaseMs", "100.0").toFloat());
+    m_clientDeEssRx->setSlopeStages(
+        s.value("ClientDeEssRxSlopeStages", "2").toInt());
 }
 
 void AudioEngine::saveClientDeEssRxSettings() const
@@ -2903,6 +2931,8 @@ void AudioEngine::saveClientDeEssRxSettings() const
         QString::number(m_clientDeEssRx->attackMs()));
     s.setValue("ClientDeEssRxReleaseMs",
         QString::number(m_clientDeEssRx->releaseMs()));
+    s.setValue("ClientDeEssRxSlopeStages",
+        QString::number(m_clientDeEssRx->slopeStages()));
 }
 
 void AudioEngine::loadClientTubeSettings()
 
@@ -1,5 +1,7 @@
 #include "ClientComp.h"
 
+#include "ClientPhaseRotator.h"
+
 #include <algorithm>
 #include <cmath>
 
@@ -28,14 +30,27 @@ float coeffFromMs(float ms, double sampleRate) noexcept
 
 } // namespace
 
-ClientComp::ClientComp() = default;
+ClientComp::ClientComp()
+    : m_phaseRotator(std::make_unique<ClientPhaseRotator>())
+{
+    // Phase rotator stays internally "always enabled" — its stages
+    // count gates whether it does anything (0 = pass-through). Drive
+    // is owned by ClientComp; the rotator runs unconditionally and is
+    // followed by the drive gain before the comp curve sees the signal.
+    m_phaseRotator->setEnabled(true);
+    m_phaseRotator->setStages(0);
+}
+
+ClientComp::~ClientComp() = default;
 
 void ClientComp::prepare(double sampleRate)
 {
     m_sampleRate = sampleRate;
     m_envLin     = 0.0f;
     m_limEnvLin  = 0.0f;
 
+    if (m_phaseRotator) m_phaseRotator->prepare(sampleRate);
+
     // Bump version so recacheIfDirty rebuilds coefficients on first block.
     m_atomics.version.fetch_add(1, std::memory_order_release);
     recacheIfDirty();
@@ -122,6 +137,24 @@ void ClientComp::setLimiterCeilingDb(float db) noexcept
 float ClientComp::limiterCeilingDb() const noexcept
 { return m_atomics.limCeilingDb.load(std::memory_order_relaxed); }
 
+void ClientComp::setDriveDb(float db) noexcept
+{
+    m_atomics.driveDb.store(std::clamp(db, 0.0f, 18.0f),
+                            std::memory_order_relaxed);
+    m_atomics.version.fetch_add(1, std::memory_order_release);
+}
+float ClientComp::driveDb() const noexcept
+{ return m_atomics.driveDb.load(std::memory_order_relaxed); }
+
+void ClientComp::setPhaseRotatorStages(int stages) noexcept
+{
+    m_atomics.phaseRotatorStages.store(std::clamp(stages, 0, 6),
+                                       std::memory_order_relaxed);
+    m_atomics.version.fetch_add(1, std::memory_order_release);
+}
+int ClientComp::phaseRotatorStages() const noexcept
+{ return m_atomics.phaseRotatorStages.load(std::memory_order_relaxed); }
+
 void ClientComp::reset() noexcept
 {
     m_envLin = 0.0f;
@@ -162,6 +195,13 @@ void ClientComp::recacheIfDirty() noexcept
     // Limiter ballistics: very fast attack, moderately fast release.
     m_cached.limAttackCoeff  = coeffFromMs(0.1f, m_sampleRate);
     m_cached.limReleaseCoeff = coeffFromMs(50.0f, m_sampleRate);
+
+    m_cached.driveLin = dbToLin(
+        m_atomics.driveDb.load(std::memory_order_relaxed));
+    m_cached.phaseRotatorStages =
+        m_atomics.phaseRotatorStages.load(std::memory_order_relaxed);
+    if (m_phaseRotator)
+        m_phaseRotator->setStages(m_cached.phaseRotatorStages);
 }
 
 float ClientComp::staticCurveGainDb(float envDb) const noexcept
@@ -198,6 +238,24 @@ void ClientComp::process(float* interleaved, int frames, int channels) noexcept
     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)
@@ -230,7 +288,14 @@ void ClientComp::process(float* interleaved, int frames, int channels) noexcept
             const float envDb = linToDb(std::max(m_envLin, 1e-6f));
             const float gainDb = staticCurveGainDb(envDb);
             if (gainDb < worstGrDb) worstGrDb = gainDb;
-            gainLin = dbToLin(gainDb) * makeup;
+            // Auto-makeup tracks Drive (#2887). Without this, dialing
+            // Drive up makes the comp do more GR than the fixed Makeup
+            // can compensate, and net RMS DROPS. Linking the post-curve
+            // gain to Drive matches the broadcast-Optimod model: Drive
+            // pushes more material into the curve AND adds equal gain
+            // back at the output, so the user's fixed Makeup setting
+            // stays a clean "post-everything trim" knob.
+            gainLin = dbToLin(gainDb) * makeup * m_cached.driveLin;
         }
         l *= gainLin;
         r *= gainLin;
 
@@ -2,9 +2,12 @@
 
 #include <atomic>
 #include <cstdint>
+#include <memory>
 
 namespace AetherSDR {
 
+class ClientPhaseRotator;
+
 // Client-side TX dynamics processor — the foundation of the Pro-XL-style
 // compression chain (#1661).  Phase 1 scope: core feed-forward compressor
 // with soft-knee static curve + attack/release envelope follower, plus a
@@ -22,7 +25,7 @@ namespace AetherSDR {
 class ClientComp {
 public:
     ClientComp();
-    ~ClientComp() = default;
+    ~ClientComp();
 
     ClientComp(const ClientComp&)            = delete;
     ClientComp& operator=(const ClientComp&) = delete;
@@ -54,6 +57,20 @@ class ClientComp {
     void  setLimiterCeilingDb(float db) noexcept;
     float limiterCeilingDb() const noexcept;
 
+    // Pre-comp Drive (#2887). Linear gain in dB applied BEFORE the
+    // compressor sees the signal. Pushes more material across the
+    // threshold so the comp engages harder, raising RMS while the
+    // existing limiter holds peaks. 0 dB = bypass.
+    void  setDriveDb(float db) noexcept;          // 0 .. 18 dB
+    float driveDb() const noexcept;
+
+    // Pre-comp phase rotator (#2887). Cascade of N second-order all-pass
+    // filters at staggered audio centres — symmetrizes asymmetric voice
+    // peaks so the harder compression and downstream limiting don't
+    // sound trashy. 0 = off (bypass), 4 = broadcast default, 6 = max.
+    void  setPhaseRotatorStages(int stages) noexcept;
+    int   phaseRotatorStages() const noexcept;
+
     // Audio thread — process in place.  channels must be 1 or 2.
     void process(float* interleaved, int frames, int channels) noexcept;
 
@@ -82,6 +99,8 @@ class ClientComp {
         std::atomic<float>    makeupDb{0.0f};
         std::atomic<bool>     limEnabled{true};
         std::atomic<float>    limCeilingDb{-1.0f};
+        std::atomic<float>    driveDb{0.0f};
+        std::atomic<int>      phaseRotatorStages{0};
         std::atomic<uint64_t> version{0};
     };
 
@@ -96,6 +115,8 @@ class ClientComp {
         float limCeilingLin{0.891f};       // 10^(-1/20)
         float limAttackCoeff{0.0f};
         float limReleaseCoeff{0.0f};
+        float driveLin{1.0f};              // 10^(driveDb / 20)
+        int   phaseRotatorStages{0};
     };
 
     // Meter snapshots — atomic stores on the audio thread after each
@@ -124,6 +145,11 @@ class ClientComp {
     // the peak (average of log|sin|), which is wrong for a peak compressor.
     float    m_envLin{0.0f};
     float    m_limEnvLin{0.0f};       // limiter envelope (linear)
+
+    // Pre-compressor phase rotator (#2887). Owned here so the comp's
+    // Drive + Phase + threshold + ratio + ceiling all act as a single
+    // PAPR-reducing block on the chain's COMP card.
+    std::unique_ptr<ClientPhaseRotator> m_phaseRotator;
 };
 
 } // namespace AetherSDR
@@ -131,11 +131,22 @@ void ClientDeEss::setReleaseMs(float ms) noexcept
 float ClientDeEss::releaseMs() const noexcept
 { return m_atomics.releaseMs.load(std::memory_order_relaxed); }
 
+void ClientDeEss::setSlopeStages(int stages) noexcept
+{
+    m_atomics.slopeStages.store(std::clamp(stages, 1, kMaxSlopeStages),
+                                std::memory_order_relaxed);
+    m_atomics.version.fetch_add(1, std::memory_order_release);
+}
+int ClientDeEss::slopeStages() const noexcept
+{ return m_atomics.slopeStages.load(std::memory_order_relaxed); }
+
 void ClientDeEss::reset() noexcept
 {
     m_envLin = 0.0f;
-    m_bpL = {};
-    m_bpR = {};
+    for (int i = 0; i < kMaxSlopeStages; ++i) {
+        m_bpL[i] = {};
+        m_bpR[i] = {};
+    }
 }
 
 float ClientDeEss::inputPeakDb() const noexcept
@@ -164,6 +175,9 @@ void ClientDeEss::recacheIfDirty() noexcept
         m_atomics.attackMs.load(std::memory_order_relaxed), m_sampleRate);
     m_cached.releaseCoeff = coeffFromMs(
         m_atomics.releaseMs.load(std::memory_order_relaxed), m_sampleRate);
+    m_cached.slopeStages = std::clamp(
+        m_atomics.slopeStages.load(std::memory_order_relaxed),
+        1, kMaxSlopeStages);
 }
 
 float ClientDeEss::staticCurveGainDb(float envDb) const noexcept
@@ -203,11 +217,22 @@ void ClientDeEss::process(float* interleaved, int frames, int channels) noexcept
         const float inAbs = std::max(std::fabs(l), std::fabs(r));
         if (inAbs > inPeakLin) inPeakLin = inAbs;
 
-        // Sidechain: run the full signal through the bandpass filter
-        // per channel.  The filters stay live even when disabled so
-        // their state is warm if the user toggles enable.
-        const float scL = processBiquad(l, bp, m_bpL);
-        const float scR = (channels == 2) ? processBiquad(r, bp, m_bpR) : scL;
+        // Sidechain: cascade N bandpass biquads per channel where N
+        // is the user-selectable slope-stage count (1..kMaxSlopeStages).
+        // Each stage adds 12 dB/oct of rolloff, so the de-esser
+        // notch can be dialled from broad (1 stage, 12 dB/oct) to
+        // surgical (4 stages, 48 dB/oct). Filters stay live even
+        // when disabled so their state is warm if the user toggles
+        // enable.
+        float scL = l;
+        float scR = (channels == 2) ? r : l;
+        const int stages = m_cached.slopeStages;
+        for (int s = 0; s < stages; ++s) {
+            scL = processBiquad(scL, bp, m_bpL[s]);
+            if (channels == 2)
+                scR = processBiquad(scR, bp, m_bpR[s]);
+        }
+        if (channels != 2) scR = scL;
         const float scAbs = std::max(std::fabs(scL), std::fabs(scR));
         if (scAbs > scPeakLin) scPeakLin = scAbs;
 
@@ -223,8 +248,21 @@ void ClientDeEss::process(float* interleaved, int frames, int channels) noexcept
             gainLin = dbToLin(gainDb);
         }
 
-        l *= gainLin;
-        r *= gainLin;
+        // Split-band de-essing: only attenuate the sibilant band
+        // (the bandpass output), leave lows + mids untouched. The
+        // bandpass is a constant-0-dB-peak filter, so subtracting
+        // bp*(1-gain) from the full signal reduces only the 4-8 kHz
+        // slice by the gain amount. The original broadband-attenuate
+        // implementation pulled the whole signal down on sibilance,
+        // crashing RMS during S-heavy phrases.
+        //   output = full + bp * (gain - 1)
+        // gain = 1  → output = full       (no change, perfect pass-through)
+        // gain = 0.5→ output = full - 0.5*bp (HF band reduced by 6 dB)
+        if (enabled && gainLin < 0.9999f) {
+            const float scGainDelta = gainLin - 1.0f;
+            l += scL * scGainDelta;
+            r += scR * scGainDelta;
+        }
         interleaved[f * channels] = l;
         if (channels == 2) interleaved[f * channels + 1] = r;
     }