You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
597 lines
21 KiB
597 lines
21 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2018-2019 Edouard Griffiths, F4EXB <f4exb06@gmail.com> // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program is distributed in the hope that it will be useful, // |
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
// GNU General Public License V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include <algorithm> |
|
|
|
#include <SoapySDR/Formats.hpp> |
|
#include <SoapySDR/Errors.hpp> |
|
|
|
#include "dsp/samplesourcefifo.h" |
|
|
|
#include "soapysdroutputthread.h" |
|
|
|
SoapySDROutputThread::SoapySDROutputThread(SoapySDR::Device* dev, unsigned int nbTxChannels, QObject* parent) : |
|
QThread(parent), |
|
m_running(false), |
|
m_dev(dev), |
|
m_sampleRate(0), |
|
m_nbChannels(nbTxChannels), |
|
m_interpolatorType(InterpolatorFloat), |
|
m_packets(0), |
|
m_underflows(0), |
|
m_errors(0), |
|
m_consecutiveErrors(0) |
|
{ |
|
qDebug("SoapySDROutputThread::SoapySDROutputThread"); |
|
m_channels = new Channel[nbTxChannels]; |
|
} |
|
|
|
SoapySDROutputThread::~SoapySDROutputThread() |
|
{ |
|
qDebug("SoapySDROutputThread::~SoapySDROutputThread"); |
|
|
|
if (m_running) { |
|
stopWork(); |
|
} |
|
|
|
delete[] m_channels; |
|
} |
|
|
|
void SoapySDROutputThread::startWork() |
|
{ |
|
if (m_running) { |
|
return; |
|
} |
|
|
|
// Reset diagnostic counters for new session |
|
m_packets = 0; |
|
m_underflows = 0; |
|
m_errors = 0; |
|
m_consecutiveErrors = 0; |
|
|
|
m_startWaitMutex.lock(); |
|
start(); |
|
|
|
while(!m_running) { |
|
m_startWaiter.wait(&m_startWaitMutex, 100); |
|
} |
|
|
|
m_startWaitMutex.unlock(); |
|
} |
|
|
|
void SoapySDROutputThread::stopWork() |
|
{ |
|
if (!m_running) { |
|
return; |
|
} |
|
|
|
m_running = false; |
|
wait(); |
|
} |
|
|
|
void SoapySDROutputThread::run() |
|
{ |
|
m_running = true; |
|
m_startWaiter.wakeAll(); |
|
|
|
unsigned int nbFifos = getNbFifos(); |
|
|
|
if ((m_nbChannels > 0) && (nbFifos > 0)) |
|
{ |
|
// build channels list |
|
std::vector<std::size_t> channels(m_nbChannels); |
|
std::iota(channels.begin(), channels.end(), 0); // Fill with 0, 1, ..., m_nbChannels-1. |
|
|
|
//initialize the sample rate for all channels |
|
qDebug("SoapySDROutputThread::run: m_sampleRate: %u", m_sampleRate); |
|
for (const auto &it : channels) { |
|
m_dev->setSampleRate(SOAPY_SDR_TX, it, m_sampleRate); |
|
} |
|
if (m_nbChannels > 1) { |
|
// Do NOT set ch1 gain — B210's global TX gain is shared between channels. |
|
// Setting ch1 gain overrides ch0's configured gain from REST API. |
|
double txFreq = m_dev->getFrequency(SOAPY_SDR_TX, 0); |
|
m_dev->setFrequency(SOAPY_SDR_TX, 1, txFreq); |
|
} |
|
|
|
// Determine sample format to be used |
|
double fullScale(0.0); |
|
std::string format = m_dev->getNativeStreamFormat(SOAPY_SDR_TX, channels.front(), fullScale); |
|
|
|
qDebug("SoapySDROutputThread::run: format: %s fullScale: %f", format.c_str(), fullScale); |
|
qCritical("SoapySDROutput: fmt=[%s] len=%zu fs=%.15f cb=%d ch=%zu", |
|
format.c_str(), format.size(), fullScale, m_interpolatorType, channels.size()); |
|
|
|
if ((format == "CS8") && (fullScale == 128.0)) { // 8 bit signed - native |
|
m_interpolatorType = Interpolator8; |
|
} else if ((format == "CS16") && (fullScale == 2048.0)) { // 12 bit signed - native |
|
m_interpolatorType = Interpolator12; |
|
} else if ((format == "CS16") && (fullScale >= 2049.0)) { // 16 bit signed - native |
|
m_interpolatorType = Interpolator16; |
|
} else { // for other types make a conversion to float |
|
m_interpolatorType = InterpolatorFloat; |
|
format = "CF32"; |
|
} |
|
|
|
qCritical("SoapySDROutput: final fmt=[%s] cb=%d", format.c_str(), m_interpolatorType); |
|
|
|
unsigned int elemSize = SoapySDR::formatToSize(format); // sample (I+Q) size in bytes |
|
SoapySDR::Stream *stream = m_dev->setupStream(SOAPY_SDR_TX, format, channels); |
|
|
|
//allocate buffers for the stream read/write |
|
const unsigned int numElems = m_dev->getStreamMTU(stream); // number of samples (I+Q) |
|
std::vector<std::vector<char>> buffMem(m_nbChannels, std::vector<char>(elemSize*numElems)); |
|
std::vector<void *> buffs(m_nbChannels); |
|
|
|
for (std::size_t i = 0; i < m_nbChannels; i++) { |
|
buffs[i] = buffMem[i].data(); |
|
} |
|
|
|
// Activate stream at thread start (untimed). USRPOutputThread |
|
// never uses has_time_spec — match that behavior. HAS_TIME on |
|
// first write stalls UHD waiting for the future timestamp which |
|
// fills the TX ring buffer → writeStream timeouts → USB transport |
|
// corruption → LIBUSB_ERROR_NOT_FOUND. |
|
m_dev->activateStream(stream); |
|
// Gain applied by SoapySDROutput::start() after thread is active. |
|
// Do NOT set gain here — setGain before stream activation is a |
|
// no-op on SoapyUHD/B210, and reading back returns 0. |
|
int writeFlags(0); |
|
long long timeNs(0); |
|
long timeoutUs = 10000; // 10ms max block per writeStream |
|
|
|
{ |
|
double actFreq = m_dev->getFrequency(SOAPY_SDR_TX, channels[0]); |
|
double actGain = m_dev->getGain(SOAPY_SDR_TX, channels[0]); |
|
double actSR = m_dev->getSampleRate(SOAPY_SDR_TX, channels[0]); |
|
qCritical("SoapySDROutputThread::run: ch0 freq=%.0f gain=%.1f SR=%.0f", |
|
actFreq, actGain, actSR); |
|
if (channels.size() > 1) { |
|
double actFreq1 = m_dev->getFrequency(SOAPY_SDR_TX, channels[1]); |
|
double actGain1 = m_dev->getGain(SOAPY_SDR_TX, channels[1]); |
|
qCritical("SoapySDROutputThread::run: ch1 freq=%.0f gain=%.1f", |
|
actFreq1, actGain1); |
|
} |
|
} |
|
|
|
qDebug("SoapySDROutputThread::run: numElems: %u elemSize: %u timeoutUs: %ld", |
|
numElems, elemSize, timeoutUs); |
|
qDebug("SoapySDROutputThread::run: start running loop"); |
|
|
|
while (m_running) |
|
{ |
|
// Zero buffers before fill — prevents stale data |
|
for (auto& buf : buffMem) { |
|
std::fill(buf.begin(), buf.end(), 0); |
|
} |
|
|
|
// Fill buffers from FIFO |
|
if (m_nbChannels > 1) { |
|
callbackMO(buffs, numElems); |
|
} else { |
|
switch (m_interpolatorType) { |
|
case Interpolator8: |
|
callbackSO8((qint8*) buffs[0], numElems); |
|
break; |
|
case Interpolator12: |
|
callbackSO12((qint16*) buffs[0], numElems); |
|
break; |
|
case Interpolator16: |
|
callbackSO16((qint16*) buffs[0], numElems); |
|
break; |
|
case InterpolatorFloat: |
|
default: |
|
callbackSOIF((float*) buffs[0], numElems); |
|
break; |
|
} |
|
} |
|
|
|
// Idle-skip: when FIFO is empty, sleep and retry. |
|
// Matches USRPOutputThread behavior. |
|
bool hasNonZero = false; |
|
for (unsigned int i = 0; i < m_nbChannels && !hasNonZero; i++) { |
|
const char* p = buffMem[i].data(); |
|
const char* end = p + std::min<size_t>(16, buffMem[i].size()); |
|
while (p < end) { |
|
if (*p++ != 0) { hasNonZero = true; break; } |
|
} |
|
} |
|
|
|
if (!hasNonZero) { |
|
QThread::usleep(100); |
|
continue; |
|
} |
|
int ret = m_dev->writeStream(stream, buffs.data(), numElems, writeFlags, timeNs, timeoutUs); |
|
|
|
if (ret == SOAPY_SDR_TIMEOUT) |
|
{ |
|
m_underflows++; |
|
qWarning("SoapySDROutputThread::run: timeout: flags: %d timeNs: %lld timeoutUs: %ld", writeFlags, timeNs, timeoutUs); |
|
} |
|
else if (ret == SOAPY_SDR_OVERFLOW) |
|
{ |
|
m_underflows++; |
|
qWarning("SoapySDROutputThread::run: overflow: flags: %d timeNs: %lld timeoutUs: %ld", writeFlags, timeNs, timeoutUs); |
|
} |
|
else if (ret < 0) |
|
{ |
|
m_errors++; |
|
qCritical("SoapySDROutputThread::run: Unexpected write stream error: %s", SoapySDR::errToStr(ret)); |
|
break; |
|
} |
|
else if (ret > 0) |
|
{ |
|
m_packets++; |
|
} |
|
|
|
} |
|
|
|
qDebug("SoapySDROutputThread::run: stop running loop"); |
|
m_dev->deactivateStream(stream); |
|
m_dev->closeStream(stream); |
|
|
|
} |
|
else |
|
{ |
|
qWarning("SoapySDROutputThread::run: no channels or FIFO allocated. Aborting"); |
|
} |
|
|
|
m_running = false; |
|
} |
|
|
|
unsigned int SoapySDROutputThread::getNbFifos() |
|
{ |
|
unsigned int fifoCount = 0; |
|
|
|
for (unsigned int i = 0; i < m_nbChannels; i++) |
|
{ |
|
if (m_channels[i].m_sampleFifo) { |
|
fifoCount++; |
|
} |
|
} |
|
|
|
return fifoCount; |
|
} |
|
|
|
void SoapySDROutputThread::setLog2Interpolation(unsigned int channel, unsigned int log2_interp) |
|
{ |
|
if (channel < m_nbChannels) { |
|
m_channels[channel].m_log2Interp = log2_interp; |
|
} |
|
} |
|
|
|
unsigned int SoapySDROutputThread::getLog2Interpolation(unsigned int channel) const |
|
{ |
|
if (channel < m_nbChannels) { |
|
return m_channels[channel].m_log2Interp; |
|
} else { |
|
return 0; |
|
} |
|
} |
|
|
|
void SoapySDROutputThread::setFifo(unsigned int channel, SampleSourceFifo *sampleFifo) |
|
{ |
|
if (channel < m_nbChannels) { |
|
m_channels[channel].m_sampleFifo = sampleFifo; |
|
} |
|
} |
|
|
|
SampleSourceFifo *SoapySDROutputThread::getFifo(unsigned int channel) |
|
{ |
|
if (channel < m_nbChannels) { |
|
return m_channels[channel].m_sampleFifo; |
|
} else { |
|
return 0; |
|
} |
|
} |
|
|
|
void SoapySDROutputThread::callbackMO(std::vector<void *>& buffs, qint32 samplesPerChannel) |
|
{ |
|
for(unsigned int ichan = 0; ichan < m_nbChannels; ichan++) |
|
{ |
|
if (m_channels[ichan].m_sampleFifo) |
|
{ |
|
switch (m_interpolatorType) |
|
{ |
|
case Interpolator8: |
|
callbackSO8((qint8*) buffs[ichan], samplesPerChannel, ichan); |
|
break; |
|
case Interpolator12: |
|
callbackSO12((qint16*) buffs[ichan], samplesPerChannel, ichan); |
|
break; |
|
case Interpolator16: |
|
callbackSO16((qint16*) buffs[ichan], samplesPerChannel, ichan); |
|
break; |
|
case InterpolatorFloat: |
|
default: |
|
callbackSOIF((float*) buffs[ichan], samplesPerChannel, ichan); |
|
break; |
|
} |
|
} |
|
else // no FIFO for this channel means channel is unused: fill with zeros |
|
{ |
|
switch (m_interpolatorType) |
|
{ |
|
case Interpolator8: |
|
std::fill((qint8*) buffs[ichan], (qint8*) buffs[ichan] + 2*samplesPerChannel, 0); |
|
break; |
|
case Interpolator12: |
|
case Interpolator16: |
|
std::fill((qint16*) buffs[ichan], (qint16*) buffs[ichan] + 2*samplesPerChannel, 0); |
|
break; |
|
case InterpolatorFloat: |
|
default: |
|
std::fill((float*) buffs[ichan], (float*) buffs[ichan] + 2*samplesPerChannel, 0.0f); |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Interpolate according to specified log2 (ex: log2=4 => decim=16). len is a number of samples (not a number of I or Q) |
|
|
|
void SoapySDROutputThread::callbackSO8(qint8* buf, qint32 len, unsigned int channel) |
|
{ |
|
if (m_channels[channel].m_sampleFifo) |
|
{ |
|
SampleVector& data = m_channels[channel].m_sampleFifo->getData(); |
|
unsigned int iPart1Begin, iPart1End, iPart2Begin, iPart2End; |
|
m_channels[channel].m_sampleFifo->read(len/(1<<m_channels[channel].m_log2Interp), iPart1Begin, iPart1End, iPart2Begin, iPart2End); |
|
|
|
if (iPart1Begin != iPart1End) { |
|
callbackPart8(buf, data, iPart1Begin, iPart1End, channel); |
|
} |
|
|
|
unsigned int shift = (iPart1End - iPart1Begin)*(1<<m_channels[channel].m_log2Interp); |
|
|
|
if (iPart2Begin != iPart2End) { |
|
callbackPart8(buf + 2*shift, data, iPart2Begin, iPart2End, channel); |
|
} |
|
} |
|
else |
|
{ |
|
std::fill(buf, buf+2*len, 0); |
|
} |
|
} |
|
|
|
void SoapySDROutputThread::callbackPart8(qint8* buf, SampleVector& data, unsigned int iBegin, unsigned int iEnd, unsigned int channel) |
|
{ |
|
SampleVector::iterator beginRead = data.begin() + iBegin; |
|
int len = 2*(iEnd - iBegin)*(1<<m_channels[channel].m_log2Interp); |
|
|
|
if (m_channels[channel].m_log2Interp == 0) |
|
{ |
|
m_channels[channel].m_interpolators8.interpolate1(&beginRead, buf, len); |
|
} |
|
else |
|
{ |
|
switch (m_channels[channel].m_log2Interp) |
|
{ |
|
case 1: |
|
m_channels[channel].m_interpolators8.interpolate2_cen(&beginRead, buf, len); |
|
break; |
|
case 2: |
|
m_channels[channel].m_interpolators8.interpolate4_cen(&beginRead, buf, len); |
|
break; |
|
case 3: |
|
m_channels[channel].m_interpolators8.interpolate8_cen(&beginRead, buf, len); |
|
break; |
|
case 4: |
|
m_channels[channel].m_interpolators8.interpolate16_cen(&beginRead, buf, len); |
|
break; |
|
case 5: |
|
m_channels[channel].m_interpolators8.interpolate32_cen(&beginRead, buf, len); |
|
break; |
|
case 6: |
|
m_channels[channel].m_interpolators8.interpolate64_cen(&beginRead, buf, len); |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
} |
|
|
|
void SoapySDROutputThread::callbackSO12(qint16* buf, qint32 len, unsigned int channel) |
|
{ |
|
if (m_channels[channel].m_sampleFifo) |
|
{ |
|
SampleVector& data = m_channels[channel].m_sampleFifo->getData(); |
|
unsigned int iPart1Begin, iPart1End, iPart2Begin, iPart2End; |
|
m_channels[channel].m_sampleFifo->read(len/(1<<m_channels[channel].m_log2Interp), iPart1Begin, iPart1End, iPart2Begin, iPart2End); |
|
|
|
if (iPart1Begin != iPart1End) { |
|
callbackPart12(buf, data, iPart1Begin, iPart1End, channel); |
|
} |
|
|
|
unsigned int shift = (iPart1End - iPart1Begin)*(1<<m_channels[channel].m_log2Interp); |
|
|
|
if (iPart2Begin != iPart2End) { |
|
callbackPart12(buf + 2*shift, data, iPart2Begin, iPart2End, channel); |
|
} |
|
} |
|
else |
|
{ |
|
std::fill(buf, buf+2*len, 0); |
|
} |
|
} |
|
|
|
void SoapySDROutputThread::callbackPart12(qint16* buf, SampleVector& data, unsigned int iBegin, unsigned int iEnd, unsigned int channel) |
|
{ |
|
SampleVector::iterator beginRead = data.begin() + iBegin; |
|
int len = 2*(iEnd - iBegin)*(1<<m_channels[channel].m_log2Interp); |
|
|
|
if (m_channels[channel].m_log2Interp == 0) |
|
{ |
|
m_channels[channel].m_interpolators12.interpolate1(&beginRead, buf, len); |
|
} |
|
else |
|
{ |
|
switch (m_channels[channel].m_log2Interp) |
|
{ |
|
case 1: |
|
m_channels[channel].m_interpolators12.interpolate2_cen(&beginRead, buf, len); |
|
break; |
|
case 2: |
|
m_channels[channel].m_interpolators12.interpolate4_cen(&beginRead, buf, len); |
|
break; |
|
case 3: |
|
m_channels[channel].m_interpolators12.interpolate8_cen(&beginRead, buf, len); |
|
break; |
|
case 4: |
|
m_channels[channel].m_interpolators12.interpolate16_cen(&beginRead, buf, len); |
|
break; |
|
case 5: |
|
m_channels[channel].m_interpolators12.interpolate32_cen(&beginRead, buf, len); |
|
break; |
|
case 6: |
|
m_channels[channel].m_interpolators12.interpolate64_cen(&beginRead, buf, len); |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
} |
|
|
|
void SoapySDROutputThread::callbackSO16(qint16* buf, qint32 len, unsigned int channel) |
|
{ |
|
if (m_channels[channel].m_sampleFifo) |
|
{ |
|
SampleVector& data = m_channels[channel].m_sampleFifo->getData(); |
|
unsigned int iPart1Begin, iPart1End, iPart2Begin, iPart2End; |
|
m_channels[channel].m_sampleFifo->read(len/(1<<m_channels[channel].m_log2Interp), iPart1Begin, iPart1End, iPart2Begin, iPart2End); |
|
|
|
if (iPart1Begin != iPart1End) { |
|
callbackPart16(buf, data, iPart1Begin, iPart1End, channel); |
|
} |
|
|
|
unsigned int shift = (iPart1End - iPart1Begin)*(1<<m_channels[channel].m_log2Interp); |
|
|
|
if (iPart2Begin != iPart2End) { |
|
callbackPart16(buf + 2*shift, data, iPart2Begin, iPart2End, channel); |
|
} |
|
} |
|
else |
|
{ |
|
std::fill(buf, buf+2*len, 0); |
|
} |
|
} |
|
|
|
void SoapySDROutputThread::callbackPart16(qint16* buf, SampleVector& data, unsigned int iBegin, unsigned int iEnd, unsigned int channel) |
|
{ |
|
SampleVector::iterator beginRead = data.begin() + iBegin; |
|
int len = 2*(iEnd - iBegin)*(1<<m_channels[channel].m_log2Interp); |
|
|
|
if (m_channels[channel].m_log2Interp == 0) |
|
{ |
|
m_channels[channel].m_interpolators16.interpolate1(&beginRead, buf, len); |
|
} |
|
else |
|
{ |
|
switch (m_channels[channel].m_log2Interp) |
|
{ |
|
case 1: |
|
m_channels[channel].m_interpolators16.interpolate2_cen(&beginRead, buf, len); |
|
break; |
|
case 2: |
|
m_channels[channel].m_interpolators16.interpolate4_cen(&beginRead, buf, len); |
|
break; |
|
case 3: |
|
m_channels[channel].m_interpolators16.interpolate8_cen(&beginRead, buf, len); |
|
break; |
|
case 4: |
|
m_channels[channel].m_interpolators16.interpolate16_cen(&beginRead, buf, len); |
|
break; |
|
case 5: |
|
m_channels[channel].m_interpolators16.interpolate32_cen(&beginRead, buf, len); |
|
break; |
|
case 6: |
|
m_channels[channel].m_interpolators16.interpolate64_cen(&beginRead, buf, len); |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
} |
|
|
|
void SoapySDROutputThread::callbackSOIF(float* buf, qint32 len, unsigned int channel) |
|
{ |
|
if (m_channels[channel].m_sampleFifo) |
|
{ |
|
SampleVector& data = m_channels[channel].m_sampleFifo->getData(); |
|
unsigned int iPart1Begin, iPart1End, iPart2Begin, iPart2End; |
|
m_channels[channel].m_sampleFifo->read(len/(1<<m_channels[channel].m_log2Interp), iPart1Begin, iPart1End, iPart2Begin, iPart2End); |
|
|
|
if (iPart1Begin != iPart1End) { |
|
callbackPartF(buf, data, iPart1Begin, iPart1End, channel); |
|
} |
|
|
|
unsigned int shift = (iPart1End - iPart1Begin)*(1<<m_channels[channel].m_log2Interp); |
|
|
|
if (iPart2Begin != iPart2End) { |
|
callbackPartF(buf + 2*shift, data, iPart2Begin, iPart2End, channel); |
|
} |
|
} |
|
else |
|
{ |
|
std::fill(buf, buf+2*len, 0.0f); |
|
} |
|
} |
|
|
|
void SoapySDROutputThread::callbackPartF(float* buf, SampleVector& data, unsigned int iBegin, unsigned int iEnd, unsigned int channel) |
|
{ |
|
SampleVector::iterator beginRead = data.begin() + iBegin; |
|
int len = 2*(iEnd - iBegin)*(1<<m_channels[channel].m_log2Interp); |
|
|
|
if (m_channels[channel].m_log2Interp == 0) |
|
{ |
|
m_channels[channel].m_interpolatorsIF.interpolate1(&beginRead, buf, len); |
|
} |
|
else |
|
{ |
|
switch (m_channels[channel].m_log2Interp) |
|
{ |
|
case 1: |
|
m_channels[channel].m_interpolatorsIF.interpolate2_cen(&beginRead, buf, len); |
|
break; |
|
case 2: |
|
m_channels[channel].m_interpolatorsIF.interpolate4_cen(&beginRead, buf, len); |
|
break; |
|
case 3: |
|
m_channels[channel].m_interpolatorsIF.interpolate8_cen(&beginRead, buf, len); |
|
break; |
|
case 4: |
|
m_channels[channel].m_interpolatorsIF.interpolate16_cen(&beginRead, buf, len); |
|
break; |
|
case 5: |
|
m_channels[channel].m_interpolatorsIF.interpolate32_cen(&beginRead, buf, len); |
|
break; |
|
case 6: |
|
m_channels[channel].m_interpolatorsIF.interpolate64_cen(&beginRead, buf, len); |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
} |
|
|
|
void SoapySDROutputThread::getStreamStatus(bool& active, quint64& packets, quint32& underflows, quint32& errors) |
|
{ |
|
active = m_packets > 0; |
|
packets = m_packets; |
|
underflows = m_underflows; |
|
errors = m_errors; |
|
}
|
|
|