Method feedDaxAudio

src/core/VirtualAudioBridge.cpp:267–347

}

void VirtualAudioBridge::feedDaxAudio(int channel, const QByteArray& pcm)
{
    // This slot may run on PanadapterStream's network thread via
    // Qt::DirectConnection — keep it lock-free and free of Qt-thread-affine
    // calls.  The silence-timer stop and ring-buffer readPos snap that used
    // to live here have moved to feedSilenceToAllChannels (GUI-thread tick),
    // which observes m_lastAudioMs to decide when to self-stop.
    if (channel < 1 || channel > NUM_CHANNELS) return;

    auto* block = m_blocks[channel - 1];
    if (!block) return;

    // Note "real audio just arrived" so the GUI-thread silence timer can
    // stop itself on its next tick.  No locks, no Qt API touched here.
    m_lastAudioMs.store(QDateTime::currentMSecsSinceEpoch(),
                        std::memory_order_relaxed);

    // Input: float32 stereo PCM @ 24 kHz from the radio (native DAX rate).
    //        After the float32 migration (502b934, b0c49d7), both PCC_IF_NARROW
    //        and PCC_IF_NARROW_REDUCED emit float32 stereo from PanadapterStream.
    // Output: float32 stereo @ 24 kHz into the ring buffer — direct 1:1 copy.
    // HAL plugin also runs at 24 kHz, so no resampling needed.
    const auto* samples = reinterpret_cast<const float*>(pcm.constData());
    const int numSamples = pcm.size() / static_cast<int>(sizeof(float));  // total float count (L,R,L,R,...)

    const float chGain = m_channelGain[channel - 1].load(std::memory_order_relaxed);
    auto& stats = m_rxTiming[channel - 1];
    if (!stats.windowElapsed.isValid())
        stats.windowElapsed.start();

    uint32_t wp = block->writePos.load(std::memory_order_relaxed);

    for (int i = 0; i < numSamples; ++i) {
        block->ringBuffer[wp % DaxShmBlock::RING_SIZE] = samples[i] * chGain;
        ++wp;
    }

    block->writePos.store(wp, std::memory_order_release);
    stats.writtenSamples += static_cast<uint64_t>(numSamples);

    uint32_t currentRp = block->readPos.load(std::memory_order_acquire);
    uint32_t backlogSamples = wp - currentRp;
    stats.peakBacklogSamples = std::max(stats.peakBacklogSamples, backlogSamples);

    if (backlogSamples > DaxShmBlock::RING_SIZE)
        ++stats.overrunEvents;

    if (backlogSamples > kRxMaxBacklogSamples) {
        const uint32_t newRp = wp - kRxTargetBacklogSamples;
        if (newRp > currentRp) {
            const uint32_t trimmedSamples = newRp - currentRp;
            block->readPos.store(newRp, std::memory_order_release);
            currentRp = newRp;
            backlogSamples = wp - currentRp;

            stats.trimmedSamples += trimmedSamples;
            ++stats.trimEvents;