kopia lustrzana https://github.com/f4exb/sdrangel
533 wiersze
23 KiB
C++
533 wiersze
23 KiB
C++
///////////////////////////////////////////////////////////////////////////////////
|
|
// Copyright (C) 2016 Edouard Griffiths, F4EXB //
|
|
// //
|
|
// 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 //
|
|
// //
|
|
// 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 <QDebug>
|
|
#include <cassert>
|
|
#include <cstring>
|
|
#include <cmath>
|
|
#include <lz4.h>
|
|
#include "sdrdaemonfecbuffer.h"
|
|
|
|
|
|
const int SDRdaemonFECBuffer::m_sampleSize = 2;
|
|
const int SDRdaemonFECBuffer::m_iqSampleSize = 2 * m_sampleSize;
|
|
|
|
SDRdaemonFECBuffer::SDRdaemonFECBuffer(uint32_t throttlems) :
|
|
m_frameHead(0),
|
|
m_decoderIndexHead(nbDecoderSlots/2),
|
|
m_curNbBlocks(0),
|
|
m_minNbBlocks(256),
|
|
m_curNbRecovery(0),
|
|
m_maxNbRecovery(0),
|
|
m_framesDecoded(true),
|
|
m_throttlemsNominal(throttlems),
|
|
m_readIndex(0),
|
|
m_readBuffer(0),
|
|
m_readSize(0),
|
|
m_bufferLenSec(0.0f),
|
|
m_nbReads(0),
|
|
m_nbWrites(0),
|
|
m_balCorrection(0),
|
|
m_balCorrLimit(0)
|
|
{
|
|
m_currentMeta.init();
|
|
m_framesNbBytes = nbDecoderSlots * sizeof(BufferFrame);
|
|
m_wrDeltaEstimate = m_framesNbBytes / 2;
|
|
m_readNbBytes = 1;
|
|
m_paramsCM256.BlockBytes = sizeof(ProtectedBlock); // never changes
|
|
m_paramsCM256.OriginalCount = m_nbOriginalBlocks; // never changes
|
|
|
|
if (!m_cm256.isInitialized()) {
|
|
m_cm256_OK = false;
|
|
qDebug() << "SDRdaemonFECBuffer::SDRdaemonFECBuffer: cannot initialize CM256 library";
|
|
} else {
|
|
m_cm256_OK = true;
|
|
}
|
|
}
|
|
|
|
SDRdaemonFECBuffer::~SDRdaemonFECBuffer()
|
|
{
|
|
if (m_readBuffer) {
|
|
delete[] m_readBuffer;
|
|
}
|
|
}
|
|
|
|
void SDRdaemonFECBuffer::initDecodeAllSlots()
|
|
{
|
|
for (int i = 0; i < nbDecoderSlots; i++)
|
|
{
|
|
m_decoderSlots[i].m_blockCount = 0;
|
|
m_decoderSlots[i].m_originalCount = 0;
|
|
m_decoderSlots[i].m_recoveryCount = 0;
|
|
m_decoderSlots[i].m_decoded = false;
|
|
m_decoderSlots[i].m_metaRetrieved = false;
|
|
memset((void *) m_decoderSlots[i].m_originalBlocks, 0, m_nbOriginalBlocks * sizeof(ProtectedBlock));
|
|
memset((void *) m_decoderSlots[i].m_recoveryBlocks, 0, m_nbOriginalBlocks * sizeof(ProtectedBlock));
|
|
}
|
|
}
|
|
|
|
void SDRdaemonFECBuffer::initDecodeSlot(int slotIndex)
|
|
{
|
|
// collect stats before voiding the slot
|
|
|
|
m_curNbBlocks = m_decoderSlots[slotIndex].m_blockCount;
|
|
m_curNbRecovery = m_decoderSlots[slotIndex].m_recoveryCount;
|
|
m_avgNbBlocks(m_curNbBlocks);
|
|
m_avgNbRecovery(m_curNbRecovery);
|
|
m_framesDecoded = m_framesDecoded && m_decoderSlots[slotIndex].m_decoded;
|
|
|
|
if (m_curNbBlocks < m_minNbBlocks) {
|
|
m_minNbBlocks = m_curNbBlocks;
|
|
}
|
|
|
|
if (m_curNbRecovery > m_maxNbRecovery) {
|
|
m_maxNbRecovery = m_curNbRecovery;
|
|
}
|
|
|
|
// void the slot
|
|
|
|
m_decoderSlots[slotIndex].m_blockCount = 0;
|
|
m_decoderSlots[slotIndex].m_originalCount = 0;
|
|
m_decoderSlots[slotIndex].m_recoveryCount = 0;
|
|
m_decoderSlots[slotIndex].m_decoded = false;
|
|
m_decoderSlots[slotIndex].m_metaRetrieved = false;
|
|
memset((void *) m_decoderSlots[slotIndex].m_originalBlocks, 0, m_nbOriginalBlocks * sizeof(ProtectedBlock));
|
|
memset((void *) m_decoderSlots[slotIndex].m_recoveryBlocks, 0, m_nbOriginalBlocks * sizeof(ProtectedBlock));
|
|
}
|
|
|
|
void SDRdaemonFECBuffer::initReadIndex()
|
|
{
|
|
m_readIndex = ((m_decoderIndexHead + (nbDecoderSlots/2)) % nbDecoderSlots) * sizeof(BufferFrame);
|
|
m_wrDeltaEstimate = m_framesNbBytes / 2;
|
|
m_nbReads = 0;
|
|
m_nbWrites = 0;
|
|
}
|
|
|
|
void SDRdaemonFECBuffer::rwCorrectionEstimate(int slotIndex)
|
|
{
|
|
if (m_nbReads >= 40) // check every ~1s as tick is ~50ms
|
|
{
|
|
int targetPivotSlot = (slotIndex + (nbDecoderSlots/2)) % nbDecoderSlots; // slot at half buffer opposite of current write slot
|
|
int targetPivotIndex = targetPivotSlot * sizeof(BufferFrame); // buffer index corresponding to start of above slot
|
|
int normalizedReadIndex = (m_readIndex < targetPivotIndex ? m_readIndex + nbDecoderSlots * sizeof(BufferFrame) : m_readIndex)
|
|
- (targetPivotSlot * sizeof(BufferFrame)); // normalize read index so it is positive and zero at start of pivot slot
|
|
int dBytes;
|
|
int rwDelta = (m_nbReads * m_readNbBytes) - (m_nbWrites * sizeof(BufferFrame));
|
|
|
|
if (normalizedReadIndex < (nbDecoderSlots/ 2) * sizeof(BufferFrame)) // read leads
|
|
{
|
|
dBytes = - normalizedReadIndex - rwDelta;
|
|
}
|
|
else // read lags
|
|
{
|
|
dBytes = (nbDecoderSlots * sizeof(BufferFrame)) - normalizedReadIndex - rwDelta;
|
|
}
|
|
|
|
m_balCorrection = (m_balCorrection / 4) + (dBytes / (int) (m_iqSampleSize * m_nbReads)); // correction is in number of samples. Alpha = 0.25
|
|
|
|
if (m_balCorrection < -m_balCorrLimit) {
|
|
m_balCorrection = -m_balCorrLimit;
|
|
} else if (m_balCorrection > m_balCorrLimit) {
|
|
m_balCorrection = m_balCorrLimit;
|
|
}
|
|
|
|
float rwRatio = (float) (m_nbWrites * sizeof(BufferFrame)) / (float) (m_nbReads * m_readNbBytes);
|
|
|
|
// qDebug() << "SDRdaemonFECBuffer::rwCorrectionEstimate: "
|
|
// << " m_nbReads: " << m_nbReads
|
|
// << " m_nbWrites: " << m_nbWrites
|
|
// << " rwDelta: " << rwDelta
|
|
// << " targetPivotSlot: " << targetPivotSlot
|
|
// << " targetPivotIndex: " << targetPivotIndex
|
|
// << " m_readIndex: " << m_readIndex
|
|
// << " normalizedReadIndex: " << normalizedReadIndex
|
|
// << " dBytes: " << dBytes
|
|
// << " m_balCorrection: " << m_balCorrection;
|
|
|
|
//m_balCorrection = dBytes / (int) (m_iqSampleSize * m_nbReads);
|
|
m_nbReads = 0;
|
|
m_nbWrites = 0;
|
|
}
|
|
}
|
|
|
|
void SDRdaemonFECBuffer::checkSlotData(int slotIndex)
|
|
{
|
|
int pseudoWriteIndex = slotIndex * sizeof(BufferFrame);
|
|
m_wrDeltaEstimate = pseudoWriteIndex - m_readIndex;
|
|
m_nbWrites++;
|
|
|
|
if (!m_decoderSlots[slotIndex].m_decoded)
|
|
{
|
|
qDebug() << "SDRdaemonFECBuffer::checkSlotData: incomplete frame:"
|
|
<< " m_blockCount: " << m_decoderSlots[slotIndex].m_blockCount
|
|
<< " m_recoveryCount: " << m_decoderSlots[slotIndex].m_recoveryCount;
|
|
}
|
|
|
|
// copy retrieved data to main buffer
|
|
memcpy((void *) &m_frames[slotIndex].m_blocks[0], (const void *) &m_decoderSlots[slotIndex].m_originalBlocks[1], (m_nbOriginalBlocks - 1)*sizeof(ProtectedBlock));
|
|
}
|
|
|
|
void SDRdaemonFECBuffer::writeData(char *array, uint32_t length)
|
|
{
|
|
SuperBlock *superBlock = (SuperBlock *) array;
|
|
int frameIndex = superBlock->header.frameIndex;
|
|
int decoderIndex = frameIndex % nbDecoderSlots;
|
|
|
|
// frame break
|
|
|
|
if (m_frameHead == -1) // initial state
|
|
{
|
|
m_decoderIndexHead = decoderIndex; // new decoder slot head
|
|
m_frameHead = frameIndex;
|
|
initReadIndex(); // reset read index
|
|
initDecodeAllSlots(); // initialize all slots
|
|
}
|
|
else if (m_frameHead != frameIndex) // frame break => new frame starts
|
|
{
|
|
m_decoderIndexHead = decoderIndex; // new decoder slot head
|
|
m_frameHead = frameIndex; // new frame head
|
|
checkSlotData(decoderIndex); // check slot before re-init
|
|
rwCorrectionEstimate(decoderIndex);
|
|
initDecodeSlot(decoderIndex); // collect stats and re-initialize current slot
|
|
}
|
|
|
|
// Block processing
|
|
|
|
if (m_decoderSlots[decoderIndex].m_blockCount < m_nbOriginalBlocks) // not enough blocks to decode -> store data
|
|
{
|
|
int blockIndex = superBlock->header.blockIndex;
|
|
int blockCount = m_decoderSlots[decoderIndex].m_blockCount;
|
|
int recoveryCount = m_decoderSlots[decoderIndex].m_recoveryCount;
|
|
m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[blockCount].Index = blockIndex;
|
|
|
|
if (blockIndex == 0) // first block with meta
|
|
{
|
|
m_decoderSlots[decoderIndex].m_metaRetrieved = true;
|
|
}
|
|
|
|
if (blockIndex < m_nbOriginalBlocks) // original data
|
|
{
|
|
m_decoderSlots[decoderIndex].m_originalBlocks[blockIndex] = superBlock->protectedBlock;
|
|
m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[blockCount].Block = (void *) &m_decoderSlots[decoderIndex].m_originalBlocks[blockIndex];
|
|
m_decoderSlots[decoderIndex].m_originalCount++;
|
|
}
|
|
else // recovery data
|
|
{
|
|
m_decoderSlots[decoderIndex].m_recoveryBlocks[recoveryCount] = superBlock->protectedBlock;
|
|
m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[blockCount].Block = (void *) &m_decoderSlots[decoderIndex].m_recoveryBlocks[recoveryCount];
|
|
m_decoderSlots[decoderIndex].m_recoveryCount++;
|
|
}
|
|
}
|
|
|
|
m_decoderSlots[decoderIndex].m_blockCount++;
|
|
|
|
if (m_decoderSlots[decoderIndex].m_blockCount == m_nbOriginalBlocks) // ready to decode
|
|
{
|
|
m_decoderSlots[decoderIndex].m_decoded = true;
|
|
|
|
if (m_cm256_OK && (m_decoderSlots[decoderIndex].m_recoveryCount > 0)) // recovery data used => need to decode FEC
|
|
{
|
|
m_paramsCM256.BlockBytes = sizeof(ProtectedBlock); // never changes
|
|
m_paramsCM256.OriginalCount = m_nbOriginalBlocks; // never changes
|
|
|
|
if (m_decoderSlots[decoderIndex].m_metaRetrieved) {
|
|
m_paramsCM256.RecoveryCount = m_currentMeta.m_nbFECBlocks;
|
|
} else {
|
|
m_paramsCM256.RecoveryCount = m_decoderSlots[decoderIndex].m_recoveryCount;
|
|
}
|
|
|
|
if (m_cm256.cm256_decode(m_paramsCM256, m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks)) // CM256 decode
|
|
{
|
|
qDebug() << "SDRdaemonFECBuffer::writeData: decode CM256 error:"
|
|
<< " m_originalCount: " << m_decoderSlots[decoderIndex].m_originalCount
|
|
<< " m_recoveryCount: " << m_decoderSlots[decoderIndex].m_recoveryCount;
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "SDRdaemonFECBuffer::writeData: decode CM256 success:"
|
|
<< " m_originalCount: " << m_decoderSlots[decoderIndex].m_originalCount
|
|
<< " m_recoveryCount: " << m_decoderSlots[decoderIndex].m_recoveryCount;
|
|
|
|
for (int ir = 0; ir < m_decoderSlots[decoderIndex].m_recoveryCount; ir++) // restore missing blocks
|
|
{
|
|
int recoveryIndex = m_nbOriginalBlocks - m_decoderSlots[decoderIndex].m_recoveryCount + ir;
|
|
int blockIndex = m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[recoveryIndex].Index;
|
|
|
|
if (blockIndex == 0) // first block with meta
|
|
{
|
|
m_decoderSlots[decoderIndex].m_metaRetrieved = true;
|
|
}
|
|
|
|
qDebug() << "SDRdaemonFECBuffer::writeData: recovered block #" << blockIndex
|
|
<< " i[0]: " << m_decoderSlots[decoderIndex].m_recoveryBlocks[ir].samples[0].i
|
|
<< " q[0]: " << m_decoderSlots[decoderIndex].m_recoveryBlocks[ir].samples[0].q
|
|
<< " i[1]: " << m_decoderSlots[decoderIndex].m_recoveryBlocks[ir].samples[1].i
|
|
<< " q[1]: " << m_decoderSlots[decoderIndex].m_recoveryBlocks[ir].samples[1].q
|
|
<< " i[2]: " << m_decoderSlots[decoderIndex].m_recoveryBlocks[ir].samples[2].i
|
|
<< " q[2]: " << m_decoderSlots[decoderIndex].m_recoveryBlocks[ir].samples[2].q;
|
|
|
|
|
|
|
|
} // restore missing blocks
|
|
} // CM256 decode
|
|
} // revovery
|
|
|
|
if (m_decoderSlots[decoderIndex].m_metaRetrieved) // block zero with its meta data has been received
|
|
{
|
|
MetaDataFEC *metaData = (MetaDataFEC *) &m_decoderSlots[decoderIndex].m_originalBlocks[0];
|
|
|
|
if (!(*metaData == m_currentMeta))
|
|
{
|
|
int sampleRate = metaData->m_sampleRate;
|
|
|
|
if (sampleRate > 0) {
|
|
m_bufferLenSec = (float) m_framesNbBytes / (float) (sampleRate * m_iqSampleSize);
|
|
m_balCorrLimit = sampleRate / 1000; // +/- 1 ms correction max per read
|
|
m_readNbBytes = (sampleRate * m_iqSampleSize) / 20;
|
|
}
|
|
|
|
printMeta("SDRdaemonFECBuffer::writeData: new meta", metaData); // print for change other than timestamp
|
|
}
|
|
|
|
m_currentMeta = *metaData; // renew current meta
|
|
} // check block 0
|
|
} // decode
|
|
}
|
|
|
|
void SDRdaemonFECBuffer::writeData0(char *array, uint32_t length)
|
|
{
|
|
// assert(length == m_udpPayloadSize);
|
|
//
|
|
// bool dataAvailable = false;
|
|
// SuperBlock *superBlock = (SuperBlock *) array;
|
|
// int frameIndex = superBlock->header.frameIndex;
|
|
// int decoderIndex = frameIndex % nbDecoderSlots;
|
|
// int blockIndex = superBlock->header.blockIndex;
|
|
//
|
|
//// qDebug() << "SDRdaemonFECBuffer::writeData:"
|
|
//// << " frameIndex: " << frameIndex
|
|
//// << " decoderIndex: " << decoderIndex
|
|
//// << " blockIndex: " << blockIndex;
|
|
//
|
|
// if (m_frameHead == -1) // initial state
|
|
// {
|
|
// m_decoderIndexHead = decoderIndex; // new decoder slot head
|
|
// m_frameHead = frameIndex;
|
|
// initReadIndex(); // reset read index
|
|
// initDecodeAllSlots(); // initialize all slots
|
|
// }
|
|
// else
|
|
// {
|
|
// int frameDelta = m_frameHead - frameIndex;
|
|
//
|
|
// if (frameDelta < 0)
|
|
// {
|
|
// if (-frameDelta < nbDecoderSlots) // new frame head not too new
|
|
// {
|
|
// //qDebug() << "SDRdaemonFECBuffer::writeData: new frame head (1): " << frameIndex << ":" << frameDelta << ":" << decoderIndex;
|
|
// m_decoderIndexHead = decoderIndex; // new decoder slot head
|
|
// m_frameHead = frameIndex;
|
|
// checkSlotData(decoderIndex);
|
|
// dataAvailable = true;
|
|
// initDecodeSlot(decoderIndex); // collect stats and re-initialize current slot
|
|
// }
|
|
// else if (-frameDelta <= 65536 - nbDecoderSlots) // loss of sync start over
|
|
// {
|
|
// //qDebug() << "SDRdaemonFECBuffer::writeData: loss of sync start over (1)" << frameIndex << ":" << frameDelta << ":" << decoderIndex;
|
|
// m_decoderIndexHead = decoderIndex; // new decoder slot head
|
|
// m_frameHead = frameIndex;
|
|
// initReadIndex(); // reset read index
|
|
// initDecodeAllSlots(); // re-initialize all slots
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// if (frameDelta > 65536 - nbDecoderSlots) // new frame head not too new
|
|
// {
|
|
// //qDebug() << "SDRdaemonFECBuffer::writeData: new frame head (2): " << frameIndex << ":" << frameDelta << ":" << decoderIndex;
|
|
// m_decoderIndexHead = decoderIndex; // new decoder slot head
|
|
// m_frameHead = frameIndex;
|
|
// checkSlotData(decoderIndex);
|
|
// dataAvailable = true;
|
|
// initDecodeSlot(decoderIndex); // collect stats and re-initialize current slot
|
|
// }
|
|
// else if (frameDelta >= nbDecoderSlots) // loss of sync start over
|
|
// {
|
|
// //qDebug() << "SDRdaemonFECBuffer::writeData: loss of sync start over (2)" << frameIndex << ":" << frameDelta << ":" << decoderIndex;
|
|
// m_decoderIndexHead = decoderIndex; // new decoder slot head
|
|
// m_frameHead = frameIndex;
|
|
// initReadIndex(); // reset read index
|
|
// initDecodeAllSlots(); // re-initialize all slots
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// // decoderIndex should now be correctly set
|
|
//
|
|
// int blockHead = m_decoderSlots[decoderIndex].m_blockCount;
|
|
// int recoveryHead = m_decoderSlots[decoderIndex].m_recoveryCount;
|
|
//
|
|
// if (blockHead < m_nbOriginalBlocks) // not enough blocks to decode -> store data
|
|
// {
|
|
// if (blockIndex == 0) // first block with meta
|
|
// {
|
|
//// ProtectedBlockZero *blockZero = (ProtectedBlockZero *) &superBlock->protectedBlock;
|
|
//// m_decoderSlots[decoderIndex].m_blockZero = *blockZero;
|
|
// m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[blockHead].Block = (void *) &m_decoderSlots[decoderIndex].m_blockZero;
|
|
// m_decoderSlots[decoderIndex].m_metaRetrieved = true;
|
|
// }
|
|
// else if (blockIndex < m_nbOriginalBlocks) // normal block
|
|
// {
|
|
// m_frames[decoderIndex].m_blocks[blockIndex - 1] = superBlock->protectedBlock;
|
|
// m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[blockHead].Block = (void *) &m_frames[decoderIndex].m_blocks[blockIndex - 1];
|
|
// }
|
|
// else // redundancy block
|
|
// {
|
|
// m_decoderSlots[decoderIndex].m_recoveryBlocks[recoveryHead] = superBlock->protectedBlock;
|
|
// m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[blockHead].Block = (void *) &m_decoderSlots[decoderIndex].m_recoveryBlocks[recoveryHead];
|
|
// m_decoderSlots[decoderIndex].m_recoveryCount++;
|
|
// }
|
|
//
|
|
// m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[blockHead].Index = blockIndex;
|
|
// m_decoderSlots[decoderIndex].m_blockCount++;
|
|
// }
|
|
// else if (!m_decoderSlots[decoderIndex].m_decoded) // ready to decode
|
|
// {
|
|
// if (m_decoderSlots[decoderIndex].m_recoveryCount > 0) // recovery data used
|
|
// {
|
|
// if (m_decoderSlots[decoderIndex].m_metaRetrieved) // block zero with its meta data has been received
|
|
// {
|
|
//// m_paramsCM256.RecoveryCount = m_decoderSlots[decoderIndex].m_blockZero.m_metaData.m_nbFECBlocks;
|
|
// }
|
|
// else
|
|
// {
|
|
// m_paramsCM256.RecoveryCount = m_currentMeta.m_nbFECBlocks; // take last stored value for number of FEC blocks
|
|
// }
|
|
//
|
|
// if (cm256_decode(m_paramsCM256, m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks)) // failure to decode
|
|
// {
|
|
// qDebug() << "SDRdaemonFECBuffer::writeData: CM256 decode error:"
|
|
// << " BlockBytes: " << m_paramsCM256.BlockBytes
|
|
// << " OriginalCount: " << m_paramsCM256.OriginalCount
|
|
// << " RecoveryCount: " << m_paramsCM256.RecoveryCount
|
|
// << " m_recoveryCount: " << m_decoderSlots[decoderIndex].m_recoveryCount;
|
|
// }
|
|
// else // success to decode
|
|
// {
|
|
// int nbOriginalBlocks = m_decoderSlots[decoderIndex].m_blockCount - m_decoderSlots[decoderIndex].m_recoveryCount;
|
|
//
|
|
// qDebug() << "SDRdaemonFECBuffer::writeData: CM256 decode success:"
|
|
// << " nbOriginalBlocks: " << nbOriginalBlocks
|
|
// << " m_recoveryCount: " << m_decoderSlots[decoderIndex].m_recoveryCount;
|
|
//
|
|
// for (int ir = 0; ir < m_decoderSlots[decoderIndex].m_recoveryCount; ir++) // recover lost blocks
|
|
// {
|
|
// int blockIndex = m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[nbOriginalBlocks+ir].Index;
|
|
//
|
|
// if (blockIndex == 0)
|
|
// {
|
|
//// ProtectedBlockZero *recoveredBlockZero = (ProtectedBlockZero *) &m_decoderSlots[decoderIndex].m_recoveryBlocks[ir];
|
|
//// printMeta("SDRdaemonFECBuffer::writeData: recovered meta", &recoveredBlockZero->m_metaData);
|
|
// // FEC does not work
|
|
//// m_decoderSlots[decoderIndex].m_blockZero.m_metaData = recoveredBlockZero->m_metaData;
|
|
//// m_decoderSlots[decoderIndex].m_metaRetrieved = true;
|
|
// }
|
|
// else
|
|
// {
|
|
// m_frames[decoderIndex].m_blocks[blockIndex - 1] = m_decoderSlots[decoderIndex].m_recoveryBlocks[ir];
|
|
// }
|
|
//
|
|
// qDebug() << "SDRdaemonFECBuffer::writeData:"
|
|
// << " recovered block #" << blockIndex
|
|
// << " i[0]: " << m_decoderSlots[decoderIndex].m_recoveryBlocks[ir].samples[0].i
|
|
// << " q[0]: " << m_decoderSlots[decoderIndex].m_recoveryBlocks[ir].samples[0].q;
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// //printMeta("SDRdaemonFECBuffer::writeData", &m_decoderSlots[decoderIndex].m_blockZero.m_metaData);
|
|
//
|
|
//// if (m_decoderSlots[decoderIndex].m_metaRetrieved) // meta data has been retrieved (direct or recovery)
|
|
//// {
|
|
//// if (!(m_decoderSlots[decoderIndex].m_blockZero.m_metaData == m_currentMeta))
|
|
//// {
|
|
//// int sampleRate = m_decoderSlots[decoderIndex].m_blockZero.m_metaData.m_sampleRate;
|
|
////
|
|
//// if (sampleRate > 0) {
|
|
//// m_bufferLenSec = (float) m_framesNbBytes / (float) sampleRate;
|
|
//// }
|
|
////
|
|
//// printMeta("SDRdaemonFECBuffer::writeData: new meta", &m_decoderSlots[decoderIndex].m_blockZero.m_metaData); // print for change other than timestamp
|
|
//// }
|
|
////
|
|
//// m_currentMeta = m_decoderSlots[decoderIndex].m_blockZero.m_metaData; // renew current meta
|
|
//// }
|
|
////
|
|
// m_decoderSlots[decoderIndex].m_decoded = true;
|
|
// }
|
|
}
|
|
|
|
uint8_t *SDRdaemonFECBuffer::readData(int32_t length)
|
|
{
|
|
uint8_t *buffer = (uint8_t *) m_frames;
|
|
uint32_t readIndex = m_readIndex;
|
|
|
|
m_nbReads++;
|
|
|
|
if (m_readIndex + length < m_framesNbBytes) // ends before buffer bound
|
|
{
|
|
m_readIndex += length;
|
|
return &buffer[readIndex];
|
|
}
|
|
else if (m_readIndex + length == m_framesNbBytes) // ends at buffer bound
|
|
{
|
|
m_readIndex = 0;
|
|
return &buffer[readIndex];
|
|
}
|
|
else // ends after buffer bound
|
|
{
|
|
if (length > m_readSize) // reallocate composition buffer if necessary
|
|
{
|
|
if (m_readBuffer) {
|
|
delete[] m_readBuffer;
|
|
}
|
|
|
|
m_readBuffer = new uint8_t[length];
|
|
m_readSize = length;
|
|
}
|
|
|
|
std::memcpy((void *) m_readBuffer, (const void *) &buffer[m_readIndex], m_framesNbBytes - m_readIndex); // copy end of buffer
|
|
length -= m_framesNbBytes - m_readIndex;
|
|
std::memcpy((void *) &m_readBuffer[m_framesNbBytes - m_readIndex], (const void *) buffer, length); // copy start of buffer
|
|
m_readIndex = length;
|
|
return m_readBuffer;
|
|
}
|
|
}
|
|
|
|
void SDRdaemonFECBuffer::printMeta(const QString& header, MetaDataFEC *metaData)
|
|
{
|
|
qDebug() << header << ": "
|
|
<< "|" << metaData->m_centerFrequency
|
|
<< ":" << metaData->m_sampleRate
|
|
<< ":" << (int) (metaData->m_sampleBytes & 0xF)
|
|
<< ":" << (int) metaData->m_sampleBits
|
|
<< ":" << (int) metaData->m_nbOriginalBlocks
|
|
<< ":" << (int) metaData->m_nbFECBlocks
|
|
<< "|" << metaData->m_tv_sec
|
|
<< ":" << metaData->m_tv_usec
|
|
<< "|";
|
|
}
|