Improve sustained transfer: ARQ window=8, reduce LDPC retries, fix file reassembly

ARQ window (connection.cpp):
- Increase OFDM selective repeat window from 4 to 8 frames
- Keeps pipeline full during retransmissions

LDPC retry budget (frame_v2.cpp):
- Reduce from 44 to 9 attempts per CW (4 factor + 5 perturbation)
- Removed Phases 2-6 (clip, scale, hard perturbations)
- 5× faster per failed frame → decoder stays near real-time
- Peak backlog reduced from 9.8s to 3.3s
- Track perturbation usage; skip false positive recovery if perturbation was used
- Remove 3-bit/4-bit suspect recovery (false CRC match rates too high)

File transfer out-of-order handling (file_transfer.cpp/hpp):
- Buffer out-of-order chunks with offset-keyed map
- Drain buffered chunks when gap is filled
- Fixes file transfer failure with selective repeat ARQ window > 1

Light sync threshold (streaming_decoder.cpp):
- Connected mode: 0.55 (was 0.72, tested 0.45 which was too low)
- 0.45 accepted too many false syncs causing LDPC false positives
- Adaptive relaxation after 5 consecutive rejections (floor 0.45)

Test results (10KB file, SNR=20):
- Good fading R1/2: 80s, 1020 bps, 32 retx — passes, CRC verified
- Moderate fading R1/2: 78s, 1048 bps, 45 retx — passes (was failing)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: secup

src/gui/modem/streaming_decoder.cpp

@@ -549,24 +549,30 @@ void StreamingDecoder::searchForSync() {
     const float snr_hint = last_snr_.load();
     // Narrowband LTS has ~35% of wideband energy (21 vs 59 carriers) → lower correlation peak
     bool is_narrowband = (mode_ == protocol::WaveformMode::OFDM_NARROW);
-    float light_sync_min_confidence = is_coherent ? 0.90f : (is_narrowband ? 0.50f : 0.72f);
-    float weak_sync_floor = is_coherent ? 0.85f : (is_narrowband ? 0.40f : 0.55f);
-    if (!is_coherent) {
-        // OTA HF can produce valid LTS peaks in the 0.55-0.65 range during
-        // fades. Start conservative, but avoid hard-locking to 0.70.
-        if (fading_hint >= 1.00f || snr_hint < 10.0f) {
-            light_sync_min_confidence = 0.62f;
-        } else if (fading_hint >= 0.70f || snr_hint < 14.0f) {
-            light_sync_min_confidence = 0.65f;
-        } else if (fading_hint >= 0.50f || snr_hint < 18.0f) {
-            light_sync_min_confidence = 0.68f;
-        }
-
-        if (connected_ && sync_reject_streak_ >= 8) {
-            float extra_relax = std::min(0.12f,
-                                         0.015f * static_cast<float>(sync_reject_streak_ - 7));
-            light_sync_min_confidence = std::max(0.56f, light_sync_min_confidence - extra_relax);
-        }
+    // LTS sync thresholds.
+    // True LTS peaks: 0.85-0.99 (clean). Data autocorrelation noise: 0.20-0.55.
+    // Threshold 0.55 for connected wideband rejects most noise while catching real LTS.
+    // Testing showed 0.45 accepted too many false syncs → LDPC false positives.
+    float light_sync_min_confidence;
+    float weak_sync_floor;
+    if (is_coherent) {
+        light_sync_min_confidence = 0.90f;
+        weak_sync_floor = 0.85f;
+    } else if (is_narrowband) {
+        light_sync_min_confidence = 0.50f;
+        weak_sync_floor = 0.40f;
+    } else if (connected_) {
+        light_sync_min_confidence = 0.55f;
+        weak_sync_floor = 0.45f;
+    } else {
+        light_sync_min_confidence = 0.65f;
+        weak_sync_floor = 0.55f;
+    }
+
+    if (!is_coherent && connected_ && sync_reject_streak_ >= 5) {
+        float extra_relax = std::min(0.10f,
+                                     0.02f * static_cast<float>(sync_reject_streak_ - 4));
+        light_sync_min_confidence = std::max(0.45f, light_sync_min_confidence - extra_relax);
     }
 
     if (connected_ && waveform_->supportsDataPreamble()) {

src/protocol/connection.cpp

@@ -981,10 +981,11 @@ void Connection::enterConnected() {
                   timeout_ms / 1000.0f, data_frame_ms, ack_frame_ms,
                   modulationToString(data_modulation_), codeRateToString(data_code_rate_));
     } else {
-        // Keep OFDM in-flight burst shorter to reduce ACK-lag hole amplification
-        // on fading channels. A window of 4 matches burst-interleave grouping and
-        // has shown better control-path stability than 8 for file transfer.
-        arq_.setWindowSize(4);
+        // Window=8 keeps pipeline full during retransmissions. Previously window=4
+        // caused stalls when a base frame failed — the pipeline blocked for 4.5s timeout.
+        // With CPE correction and pre-CFO correction, frame loss rate is low enough
+        // that the larger window improves throughput without overwhelming the RX.
+        arq_.setWindowSize(8);
         arq_.setMaxRetries(15);     // More attempts compensate for ACK loss on fading
         arq_.setSackDelay(120);     // Short coalescing delay for ACK/SACK control traffic
 

src/protocol/file_transfer.cpp

@@ -389,26 +389,39 @@ bool FileTransferController::processFileData(const Bytes& payload, bool more_dat
     const uint8_t* data = payload.data() + 5;
     size_t data_len = payload.size() - 5;
 
-    // ARQ normally delivers in-order, so offset should match current size.
-    // Be defensive against duplicate/late frames or rare header false-positives.
+    // With Selective Repeat ARQ (window > 1), chunks can arrive out of order.
+    // Buffer out-of-order chunks and insert them when the gap is filled.
     uint32_t expected_offset = static_cast<uint32_t>(rx_data_.size());
-    if (offset != expected_offset) {
-        if (offset < expected_offset) {
-            LOG_MODEM(WARN,
-                      "FileTransfer: Ignoring duplicate/overlap chunk offset=%u len=%zu (have=%zu)",
-                      offset, data_len, rx_data_.size());
-            return true;
-        }
+    if (offset < expected_offset) {
+        LOG_MODEM(DEBUG,
+                  "FileTransfer: Ignoring duplicate/overlap chunk offset=%u len=%zu (have=%zu)",
+                  offset, data_len, rx_data_.size());
+        return true;
+    }
 
-        // Gap: wait for missing data instead of appending out-of-order bytes.
-        LOG_MODEM(WARN,
-                  "FileTransfer: Gap detected offset=%u len=%zu (expected=%u), waiting for retransmit",
-                  offset, data_len, expected_offset);
+    if (offset > expected_offset) {
+        // Out-of-order: buffer for later insertion
+        rx_pending_chunks_[offset] = Bytes(data, data + data_len);
+        LOG_MODEM(INFO,
+                  "FileTransfer: Buffered out-of-order chunk offset=%u len=%zu (expected=%u, pending=%zu)",
+                  offset, data_len, expected_offset, rx_pending_chunks_.size());
         return true;
     }
 
+    // In-order: append directly
     rx_data_.insert(rx_data_.end(), data, data + data_len);
 
+    // Drain any buffered chunks that are now in sequence
+    while (!rx_pending_chunks_.empty()) {
+        uint32_t next_expected = static_cast<uint32_t>(rx_data_.size());
+        auto it = rx_pending_chunks_.find(next_expected);
+        if (it == rx_pending_chunks_.end()) break;
+        rx_data_.insert(rx_data_.end(), it->second.begin(), it->second.end());
+        LOG_MODEM(INFO, "FileTransfer: Drained buffered chunk offset=%u len=%zu (total=%zu)",
+                  next_expected, it->second.size(), rx_data_.size());
+        rx_pending_chunks_.erase(it);
+    }
+
     notifyProgress();
 
     const bool compressed = (rx_flags_ & FileFlags::COMPRESSED) != 0;
@@ -526,6 +539,7 @@ void FileTransferController::resetRxState() {
     rx_filepath_.clear();
     rx_filename_.clear();
     rx_data_.clear();
+    rx_pending_chunks_.clear();
     rx_expected_size_ = 0;
     rx_expected_crc_ = 0;
     rx_flags_ = 0;

src/protocol/file_transfer.hpp

@@ -4,6 +4,7 @@
 #include <fstream>
 #include <functional>
 #include <string>
+#include <map>
 #include <cstdint>
 
 namespace ultra {
@@ -153,6 +154,7 @@ class FileTransferController {
     uint32_t rx_expected_size_ = 0;  // Original uncompressed size
     uint32_t rx_expected_crc_ = 0;
     uint8_t rx_flags_ = 0;     // FileFlags from FILE_START
+    std::map<uint32_t, Bytes> rx_pending_chunks_;  // Out-of-order chunks buffered by offset
 
     // Callbacks
     ProgressCallback on_progress_;

src/protocol/frame_v2.cpp

@@ -1354,6 +1354,8 @@ CodewordStatus decodeFixedFrame(const std::vector<float>& interleaved_soft, Code
     decoder.setMinSumFactor(0.9375f);
     size_t bytes_per_cw = getBytesPerCodeword(rate);
 
+    int perturbation_cw_count = 0;  // How many CWs needed perturbation retry
+
     for (int cw = 0; cw < FIXED_FRAME_CODEWORDS; ++cw) {
         auto cw_bits = cw_soft_bits[cw];
 
@@ -1375,6 +1377,7 @@ CodewordStatus decodeFixedFrame(const std::vector<float>& interleaved_soft, Code
         auto decoded = decoder.decodeSoft(cw_bits);
         bool success = decoder.lastDecodeSuccess();
         int iterations = decoder.lastIterations();
+        bool used_perturbation = false;  // Track if this CW needed perturbation retry
 
         // Multi-strategy LDPC retry when decode fails:
         // Uses decoder diversity (varying min-sum factor) + LLR perturbation
@@ -1407,19 +1410,17 @@ CodewordStatus decodeFixedFrame(const std::vector<float>& interleaved_soft, Code
                 decoder.setMinSumFactor(0.9375f);  // restore default
             }
 
-            // Phase 1: Perturbation with decoder diversity (15 attempts)
-            // Alternate min-sum factor between attempts for maximum diversity.
-            // Different seeds × different factors explore the solution space broadly.
+            // Phase 1: Perturbation with decoder diversity (5 attempts)
+            // With ARQ, fast failure + retransmit beats slow recovery.
+            // Excessive perturbation (was 44 attempts across 6 phases) caused:
+            //   - 200ms per failed frame → decoder falls behind real-time
+            //   - High LDPC false positive rate (random noise → wrong codewords)
+            //   - 5-10s audio backlog → sync detection degradation
+            // Reduced to 5 perturbation attempts (was 34) + 4 factor retries = 9 total.
             if (!success) {
-                static constexpr float sigmas1[] = {
-                    0.3f, 0.7f, 0.3f, 1.0f, 0.5f, 1.5f, 0.3f, 2.0f,
-                    0.5f, 0.7f, 1.0f, 2.5f, 0.3f, 1.5f, 0.5f
-                };
-                static constexpr float factors1[] = {
-                    0.75f, 0.625f, 0.875f, 0.75f, 0.625f, 0.75f, 0.5f, 0.625f,
-                    0.875f, 0.75f, 0.625f, 0.875f, 0.75f, 0.5f, 0.625f
-                };
-                for (int retry = 0; retry < 15 && !success; retry++) {
+                static constexpr float sigmas1[] = {0.3f, 0.7f, 1.0f, 1.5f, 2.0f};
+                static constexpr float factors1[] = {0.75f, 0.625f, 0.875f, 0.75f, 0.625f};
+                for (int retry = 0; retry < 5 && !success; retry++) {
                     decoder.setMinSumFactor(factors1[retry]);
                     std::mt19937 rng(data_hash + retry * 997 + retry * 31);
                     std::normal_distribution<float> noise(0.0f, sigmas1[retry]);
@@ -1431,113 +1432,18 @@ CodewordStatus decodeFixedFrame(const std::vector<float>& interleaved_soft, Code
                     if (decoder.lastDecodeSuccess()) {
                         success = true;
                         iterations = decoder.lastIterations();
+                        used_perturbation = true;
                         LOG_MODEM(INFO, "CW[%d]: RETRY OK (perturb σ=%.1f f=%.3f, iters=%d)", cw, sigmas1[retry], factors1[retry], iterations);
                     }
                 }
                 decoder.setMinSumFactor(0.875f);
             }
-
-            // Phase 2: Clip ±10 + perturbation (5 attempts)
-            if (!success) {
-                static constexpr float sigmas2[] = {0.3f, 0.8f, 1.5f, 2.5f, 4.0f};
-                for (int retry = 0; retry < 5 && !success; retry++) {
-                    decoder.setMinSumFactor(retry % 2 == 0 ? 0.625f : 0.875f);
-                    std::mt19937 rng(data_hash + (retry + 15) * 997 + 12345);
-                    std::normal_distribution<float> noise(0.0f, sigmas2[retry]);
-                    auto clipped = cw_bits;
-                    for (float& llr : clipped) {
-                        llr = std::max(-10.0f, std::min(10.0f, llr));
-                        llr += noise(rng);
-                    }
-                    decoded = decoder.decodeSoft(clipped);
-                    if (decoder.lastDecodeSuccess()) {
-                        success = true;
-                        iterations = decoder.lastIterations();
-                        LOG_MODEM(INFO, "CW[%d]: RETRY OK (clip10+perturb σ=%.1f, iters=%d)", cw, sigmas2[retry], iterations);
-                    }
-                }
-                decoder.setMinSumFactor(0.875f);
-            }
-
-            // Phase 3: Scale 0.5× + perturbation (3 attempts)
-            if (!success) {
-                static constexpr float sigmas3[] = {0.5f, 1.5f, 3.0f};
-                for (int retry = 0; retry < 3 && !success; retry++) {
-                    std::mt19937 rng(data_hash + (retry + 20) * 997 + 54321);
-                    std::normal_distribution<float> noise(0.0f, sigmas3[retry]);
-                    auto scaled = cw_bits;
-                    for (float& llr : scaled) {
-                        llr = llr * 0.5f + noise(rng);
-                    }
-                    decoded = decoder.decodeSoft(scaled);
-                    if (decoder.lastDecodeSuccess()) {
-                        success = true;
-                        iterations = decoder.lastIterations();
-                        LOG_MODEM(INFO, "CW[%d]: RETRY OK (scale50+perturb σ=%.1f, iters=%d)", cw, sigmas3[retry], iterations);
-                    }
-                }
-            }
-
-            // Phase 4: Clip ±6 + perturbation (3 attempts)
-            if (!success) {
-                static constexpr float sigmas4[] = {0.5f, 1.5f, 3.0f};
-                for (int retry = 0; retry < 3 && !success; retry++) {
-                    std::mt19937 rng(data_hash + (retry + 23) * 997 + 99999);
-                    std::normal_distribution<float> noise(0.0f, sigmas4[retry]);
-                    auto clipped = cw_bits;
-                    for (float& llr : clipped) {
-                        llr = std::max(-6.0f, std::min(6.0f, llr));
-                        llr += noise(rng);
-                    }
-                    decoded = decoder.decodeSoft(clipped);
-                    if (decoder.lastDecodeSuccess()) {
-                        success = true;
-                        iterations = decoder.lastIterations();
-                        LOG_MODEM(INFO, "CW[%d]: RETRY OK (clip6+perturb σ=%.1f, iters=%d)", cw, sigmas4[retry], iterations);
-                    }
-                }
-            }
-
-            // Phase 5: Hard decision + perturbation (5 attempts)
-            if (!success) {
-                static constexpr float sigmas5[] = {0.0f, 0.2f, 0.5f, 1.0f, 1.5f};
-                for (int retry = 0; retry < 5 && !success; retry++) {
-                    std::mt19937 rng(data_hash + (retry + 26) * 997 + 33333);
-                    std::normal_distribution<float> noise(0.0f, sigmas5[retry]);
-                    auto hard = cw_bits;
-                    for (float& llr : hard) {
-                        llr = (llr >= 0) ? 1.0f : -1.0f;
-                        llr += noise(rng);
-                    }
-                    decoded = decoder.decodeSoft(hard);
-                    if (decoder.lastDecodeSuccess()) {
-                        success = true;
-                        iterations = decoder.lastIterations();
-                        LOG_MODEM(INFO, "CW[%d]: RETRY OK (hard+perturb σ=%.1f, iters=%d)", cw, sigmas5[retry], iterations);
-                    }
-                }
-            }
-
-            // Phase 6: Scale 0.25× + perturbation (3 attempts)
-            if (!success) {
-                static constexpr float sigmas6[] = {0.3f, 1.0f, 2.0f};
-                for (int retry = 0; retry < 3 && !success; retry++) {
-                    std::mt19937 rng(data_hash + (retry + 31) * 997 + 77777);
-                    std::normal_distribution<float> noise(0.0f, sigmas6[retry]);
-                    auto scaled = cw_bits;
-                    for (float& llr : scaled) {
-                        llr = llr * 0.25f + noise(rng);
-                    }
-                    decoded = decoder.decodeSoft(scaled);
-                    if (decoder.lastDecodeSuccess()) {
-                        success = true;
-                        iterations = decoder.lastIterations();
-                        LOG_MODEM(INFO, "CW[%d]: RETRY OK (scale25+perturb σ=%.1f, iters=%d)", cw, sigmas6[retry], iterations);
-                    }
-                }
-            }
+            // Phases 2-6 REMOVED (2026-03-15): excessive perturbation caused false
+            // positives and decoder backlog. ARQ handles frame loss more efficiently.
         }
 
+        if (used_perturbation && success) perturbation_cw_count++;
+
         LOG_MODEM(INFO, "CW[%d]: %s (iters=%d, llr_avg=%.2f, |llr|_avg=%.2f)",
                   cw, success ? "OK" : "FAIL", iterations, llr_avg, llr_abs_avg);
 
@@ -1569,9 +1475,23 @@ CodewordStatus decodeFixedFrame(const std::vector<float>& interleaved_soft, Code
         }
 
         if (!frame_valid) {
-            LOG_MODEM(WARN, "LDPC false positive detected: all CWs decoded but frame invalid");
+            LOG_MODEM(WARN, "LDPC false positive detected: all CWs decoded but frame invalid (perturbed_cws=%d)",
+                      perturbation_cw_count);
             bool recovered = false;
 
+            // If any CW used perturbation retry, the false positive is almost certainly
+            // from the random noise injection finding a wrong-but-valid LDPC codeword.
+            // Skip expensive bit-flip recovery — it can't fix random garbage and risks
+            // producing wrong "recovered" data that passes CRC by coincidence.
+            if (perturbation_cw_count > 0) {
+                LOG_MODEM(WARN, "LDPC false positive: %d CWs used perturbation, skipping recovery",
+                          perturbation_cw_count);
+                for (int cw = 0; cw < FIXED_FRAME_CODEWORDS; ++cw) {
+                    status.decoded[cw] = false;
+                }
+                return status;
+            }
+
             // Helper: verify assembled frame without logging
             auto verifyFrame = [](const Bytes& assembled) -> bool {
                 if (assembled.empty()) return false;