mirror of
https://github.com/f4exb/sdrangel.git
synced 2025-11-04 05:30:32 -05:00
228 lines
10 KiB
C++
228 lines
10 KiB
C++
///////////////////////////////////////////////////////////////////////////////////
|
|
// Copyright (C) 2016-2021 Edouard Griffiths, F4EXB <f4exb06@gmail.com> //
|
|
// Copyright (C) 2019 Davide Gerhard <rainbow@irh.it> //
|
|
// //
|
|
// 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/>. //
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef PLUGINS_SAMPLESOURCE_REMOTEINPUT_REMOTEINPUTBUFFER_H_
|
|
#define PLUGINS_SAMPLESOURCE_REMOTEINPUT_REMOTEINPUTBUFFER_H_
|
|
|
|
#include <QString>
|
|
#include <QDebug>
|
|
|
|
#include <cstdlib>
|
|
|
|
#include "cm256cc/cm256.h"
|
|
|
|
#include "channel/remotedatablock.h"
|
|
#include "util/movingaverage.h"
|
|
|
|
|
|
#define REMOTEINPUT_UDPSIZE 512 // UDP payload size
|
|
#define REMOTEINPUT_NBORIGINALBLOCKS 128 // number of sample blocks per frame excluding FEC blocks
|
|
|
|
class RemoteInputBuffer
|
|
{
|
|
public:
|
|
RemoteInputBuffer();
|
|
~RemoteInputBuffer();
|
|
|
|
// Sizing
|
|
void setNbDecoderSlots(int nbDecoderSlots);
|
|
static int getBufferFrameSize() { return sizeof(BufferFrame); }
|
|
void setBufferLenSec(const RemoteMetaDataFEC& metaData);
|
|
|
|
// R/W operations
|
|
void writeData(char *array); //!< Write data into buffer.
|
|
uint8_t *readData(int32_t length); //!< Read data from buffer
|
|
|
|
// meta data
|
|
const RemoteMetaDataFEC& getCurrentMeta() const { return m_currentMeta; }
|
|
|
|
// samples timestamp
|
|
uint32_t getTVOutSec() const { return m_tvOut_sec; }
|
|
uint32_t getTVOutUsec() const { return m_tvOut_usec; }
|
|
uint64_t getTVOutMSec() const { return (m_tvOut_sec * 1000LL) + (m_tvOut_usec/ 1000LL); }
|
|
|
|
// stats
|
|
|
|
int getCurNbBlocks() const { return m_curNbBlocks; }
|
|
int getCurOriginalBlocks() const { return m_curOriginalBlocks; }
|
|
int getCurNbRecovery() const { return m_curNbRecovery; }
|
|
float getAvgNbBlocks() const { return m_avgNbBlocks; }
|
|
float getAvgOriginalBlocks() const { return m_avgOrigBlocks; }
|
|
float getAvgNbRecovery() const { return m_avgNbRecovery; }
|
|
|
|
int getMinNbBlocks()
|
|
{
|
|
int minNbBlocks = m_minNbBlocks;
|
|
m_minNbBlocks = 256;
|
|
return minNbBlocks;
|
|
}
|
|
|
|
int getMinOriginalBlocks()
|
|
{
|
|
int minOriginalBlocks = m_minOriginalBlocks;
|
|
m_minOriginalBlocks = 128;
|
|
return minOriginalBlocks;
|
|
}
|
|
|
|
int getMaxNbRecovery()
|
|
{
|
|
int maxNbRecovery = m_maxNbRecovery;
|
|
m_maxNbRecovery = 0;
|
|
return maxNbRecovery;
|
|
}
|
|
|
|
bool allFramesDecoded()
|
|
{
|
|
bool framesDecoded = m_framesDecoded;
|
|
m_framesDecoded = true;
|
|
return framesDecoded;
|
|
}
|
|
|
|
float getBufferLengthInSecs() const { return m_bufferLenSec; }
|
|
int32_t getRWBalanceCorrection() const { return m_balCorrection; }
|
|
|
|
/** Get buffer gauge value in % of buffer size ([-50:50])
|
|
* [-50:0] : write leads or read lags
|
|
* [0:50] : read leads or write lags
|
|
*/
|
|
inline int32_t getBufferGauge() const
|
|
{
|
|
if (m_framesNbBytes)
|
|
{
|
|
int32_t val = (m_wrDeltaEstimate * 100) / (int32_t) m_framesNbBytes;
|
|
int32_t ret = val < 0 ? -val - 50 : 50 -val;
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
return 0; // default position
|
|
}
|
|
}
|
|
|
|
private:
|
|
int m_nbDecoderSlots;
|
|
int m_framesSize;
|
|
|
|
#pragma pack(push, 1)
|
|
struct BufferFrame
|
|
{
|
|
RemoteProtectedBlock m_blocks[RemoteNbOrginalBlocks - 1];
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
struct DecoderSlot
|
|
{
|
|
RemoteProtectedBlock m_blockZero; //!< First block of a frame. Has meta data.
|
|
RemoteProtectedBlock m_originalBlocks[RemoteNbOrginalBlocks]; //!< Original blocks retrieved directly or by later FEC
|
|
RemoteProtectedBlock m_recoveryBlocks[RemoteNbOrginalBlocks]; //!< Recovery blocks (FEC blocks) with max size
|
|
CM256::cm256_block m_cm256DescriptorBlocks[RemoteNbOrginalBlocks]; //!< CM256 decoder descriptors (block addresses and block indexes)
|
|
int m_blockCount; //!< number of blocks received for this frame
|
|
int m_originalCount; //!< number of original blocks received
|
|
int m_recoveryCount; //!< number of recovery blocks received
|
|
bool m_decoded; //!< true if decoded
|
|
bool m_metaRetrieved; //!< true if meta data (block zero) was retrieved
|
|
DecoderSlot() {}
|
|
};
|
|
|
|
RemoteMetaDataFEC m_currentMeta; //!< Stored current meta data
|
|
CM256::cm256_encoder_params m_paramsCM256; //!< CM256 decoder parameters block
|
|
DecoderSlot *m_decoderSlots; //!< CM256 decoding control/buffer slots
|
|
BufferFrame *m_frames; //!< Samples buffer
|
|
int m_framesNbBytes; //!< Number of bytes in samples buffer
|
|
int m_decoderIndexHead; //!< index of the current head frame slot in decoding slots
|
|
int m_frameHead; //!< index of the current head frame sent
|
|
int m_curNbBlocks; //!< (stats) instantaneous number of blocks received
|
|
int m_minNbBlocks; //!< (stats) minimum number of blocks received since last poll
|
|
int m_curOriginalBlocks; //!< (stats) instantanous number of original blocks received
|
|
int m_minOriginalBlocks; //!< (stats) minimum number of original blocks received since last poll
|
|
int m_curNbRecovery; //!< (stats) instantaneous number of recovery blocks used
|
|
int m_maxNbRecovery; //!< (stats) maximum number of recovery blocks used since last poll
|
|
MovingAverageUtil<int, int, 10> m_avgNbBlocks; //!< (stats) average number of blocks received
|
|
MovingAverageUtil<int, int, 10> m_avgOrigBlocks; //!< (stats) average number of original blocks received
|
|
MovingAverageUtil<int, int, 10> m_avgNbRecovery; //!< (stats) average number of recovery blocks used
|
|
bool m_framesDecoded; //!< [stats] true if all frames were decoded since last poll
|
|
int m_readIndex; //!< current byte read index in frames buffer
|
|
int m_wrDeltaEstimate; //!< Sampled estimate of write to read indexes difference
|
|
uint32_t m_tvOut_sec; //!< Estimated returned samples timestamp (seconds)
|
|
uint32_t m_tvOut_usec; //!< Estimated returned samples timestamp (microseconds)
|
|
int m_readNbBytes; //!< Nominal number of bytes per read (50ms)
|
|
|
|
uint8_t* m_readBuffer; //!< Read buffer to hold samples when looping back to beginning of raw buffer
|
|
int m_readSize; //!< Read buffer size
|
|
|
|
float m_bufferLenSec;
|
|
|
|
int m_nbReads; //!< Number of buffer reads since start of auto R/W balance correction period
|
|
int m_nbWrites; //!< Number of buffer writes since start of auto R/W balance correction period
|
|
int m_balCorrection; //!< R/W balance correction in number of samples
|
|
int m_balCorrLimit; //!< Correction absolute value limit in number of samples
|
|
CM256 m_cm256; //!< CM256 library
|
|
bool m_cm256_OK; //!< CM256 library initialized OK
|
|
|
|
inline RemoteProtectedBlock* storeOriginalBlock(int slotIndex, int blockIndex, const RemoteProtectedBlock& protectedBlock)
|
|
{
|
|
if (blockIndex == 0) {
|
|
// m_decoderSlots[slotIndex].m_originalBlocks[0] = protectedBlock;
|
|
// return &m_decoderSlots[slotIndex].m_originalBlocks[0];
|
|
m_decoderSlots[slotIndex].m_blockZero = protectedBlock;
|
|
return &m_decoderSlots[slotIndex].m_blockZero;
|
|
} else {
|
|
// m_decoderSlots[slotIndex].m_originalBlocks[blockIndex] = protectedBlock;
|
|
// return &m_decoderSlots[slotIndex].m_originalBlocks[blockIndex];
|
|
m_frames[slotIndex].m_blocks[blockIndex - 1] = protectedBlock;
|
|
return &m_frames[slotIndex].m_blocks[blockIndex - 1];
|
|
}
|
|
}
|
|
|
|
inline RemoteProtectedBlock& getOriginalBlock(int slotIndex, int blockIndex)
|
|
{
|
|
if (blockIndex == 0) {
|
|
// return m_decoderSlots[slotIndex].m_originalBlocks[0];
|
|
return m_decoderSlots[slotIndex].m_blockZero;
|
|
} else {
|
|
// return m_decoderSlots[slotIndex].m_originalBlocks[blockIndex];
|
|
return m_frames[slotIndex].m_blocks[blockIndex - 1];
|
|
}
|
|
}
|
|
|
|
inline RemoteMetaDataFEC *getMetaData(int slotIndex)
|
|
{
|
|
// return (MetaDataFEC *) &m_decoderSlots[slotIndex].m_originalBlocks[0];
|
|
return (RemoteMetaDataFEC *) &m_decoderSlots[slotIndex].m_blockZero;
|
|
}
|
|
|
|
inline void resetOriginalBlocks(int slotIndex)
|
|
{
|
|
// memset((void *) m_decoderSlots[slotIndex].m_originalBlocks, 0, m_nbOriginalBlocks * sizeof(ProtectedBlock));
|
|
memset((void *) &m_decoderSlots[slotIndex].m_blockZero, 0, sizeof(RemoteProtectedBlock));
|
|
memset((void *) m_frames[slotIndex].m_blocks, 0, (RemoteNbOrginalBlocks - 1) * sizeof(RemoteProtectedBlock));
|
|
}
|
|
|
|
void initDecodeAllSlots();
|
|
void initReadIndex();
|
|
void rwCorrectionEstimate(int slotIndex);
|
|
void checkSlotData(int slotIndex);
|
|
void initDecodeSlot(int slotIndex);
|
|
|
|
static void printMeta(const QString& header, RemoteMetaDataFEC *metaData);
|
|
};
|
|
|
|
|
|
|
|
#endif /* PLUGINS_SAMPLESOURCE_REMOTEINPUT_REMOTEINPUTBUFFER_H_ */
|