Method sampleNow

src/gui/NetworkDiagnosticsDialog.cpp:2441–2552

}

void NetworkDiagnosticsHistory::sampleNow()
{
    NetworkDiagnosticsSample sample;
    const qint64 nowMs = QDateTime::currentMSecsSinceEpoch();
    const double elapsedSeconds = std::max(0.001, (nowMs - m_lastSampleMs) / 1000.0);
    sample.timestampMs = nowMs;
    sample.rttMs = m_model->lastPingRtt();

    static constexpr PanadapterStream::StreamCategory cats[] = {
        PanadapterStream::CatAudio, PanadapterStream::CatFFT,
        PanadapterStream::CatWaterfall, PanadapterStream::CatMeter
    };

    for (PanadapterStream::StreamCategory cat : cats) {
        PanadapterStream::CategoryStats cs = m_model->categoryStats(cat);
        const qint64 delta = std::max<qint64>(0, cs.bytes - m_lastCatBytes[cat]);
        m_lastCatBytes[cat] = cs.bytes;
        const double rateKbps = kbpsFromBytes(delta, elapsedSeconds);
        if (cat == PanadapterStream::CatAudio) {
            sample.audioKbps = rateKbps;
            sample.audioLossPct = lossPercent(cs);
        } else if (cat == PanadapterStream::CatFFT) {
            sample.fftKbps = rateKbps;
            sample.fftLossPct = lossPercent(cs);
        } else if (cat == PanadapterStream::CatWaterfall) {
            sample.waterfallKbps = rateKbps;
            sample.waterfallLossPct = lossPercent(cs);
        } else if (cat == PanadapterStream::CatMeter) {
            sample.meterKbps = rateKbps;
            sample.meterLossPct = lossPercent(cs);
        }
    }

    {
        PanadapterStream::CategoryStats cs = m_model->categoryStats(PanadapterStream::CatDAX);
        const qint64 delta = std::max<qint64>(0, cs.bytes - m_lastCatBytes[PanadapterStream::CatDAX]);
        m_lastCatBytes[PanadapterStream::CatDAX] = cs.bytes;
        sample.daxKbps = kbpsFromBytes(delta, elapsedSeconds);
        sample.daxLossPct = lossPercent(cs);
    }

    const qint64 curRx = m_model->rxBytes();
    sample.rxKbps = kbpsFromBytes(std::max<qint64>(0, curRx - m_lastRxBytes), elapsedSeconds);
    m_lastRxBytes = curRx;
    const qint64 curTx = m_model->txBytes();
    sample.txKbps = kbpsFromBytes(std::max<qint64>(0, curTx - m_lastTxBytes), elapsedSeconds);
    m_lastTxBytes = curTx;

    sample.packetLossPct = m_model->packetLossPercent();

    if (m_audio) {
        const int sampleRate = m_audio->rxBufferSampleRate();
        const quint64 underruns = m_audio->rxBufferUnderrunCount();
        quint64 underrunDelta = 0;
        if (underruns >= m_lastAudioUnderrunCount) {
            underrunDelta = underruns - m_lastAudioUnderrunCount;
        }
        m_lastAudioUnderrunCount = underruns;