VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2024-09-28 15:56:33 -04:00
Code Issues Projects Releases Wiki Activity

SDRDaemonSource: use global SDR data blocks definitions

Browse Source
This commit is contained in:
f4exb 2018-09-13 09:18:58 +02:00
parent e78ee1b946
commit 0a2329ffe7
4 changed files with 45 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
plugins/samplesource/sdrdaemonsource/sdrdaemonsourcebuffer.cpp
View File

@ -50,8 +50,8 @@ SDRdaemonSourceBuffer::SDRdaemonSourceBuffer() :
m_tvOut_sec = 0;
m_tvOut_usec = 0;
m_readNbBytes = 1;
m_paramsCM256.BlockBytes = sizeof(ProtectedBlock); // never changes
m_paramsCM256.OriginalCount = m_nbOriginalBlocks; // never changes
m_paramsCM256.BlockBytes = sizeof(SDRDaemonProtectedBlock); // never changes
m_paramsCM256.OriginalCount = SDRDaemonNbOrginalBlocks; // never changes
if (!m_cm256.isInitialized()) {
m_cm256_OK = false;
@ -81,7 +81,7 @@ void SDRdaemonSourceBuffer::initDecodeAllSlots()
m_decoderSlots[i].m_decoded = false;
m_decoderSlots[i].m_metaRetrieved = false;
resetOriginalBlocks(i);
memset((void *) m_decoderSlots[i].m_recoveryBlocks, 0, m_nbOriginalBlocks * sizeof(ProtectedBlock));
memset((void *) m_decoderSlots[i].m_recoveryBlocks, 0, SDRDaemonNbOrginalBlocks * sizeof(SDRDaemonProtectedBlock));
}
}
@ -118,7 +118,7 @@ void SDRdaemonSourceBuffer::initDecodeSlot(int slotIndex)
m_decoderSlots[slotIndex].m_metaRetrieved = false;
resetOriginalBlocks(slotIndex);
memset((void *) m_decoderSlots[slotIndex].m_recoveryBlocks, 0, m_nbOriginalBlocks * sizeof(ProtectedBlock));
memset((void *) m_decoderSlots[slotIndex].m_recoveryBlocks, 0, SDRDaemonNbOrginalBlocks * sizeof(SDRDaemonProtectedBlock));
}
void SDRdaemonSourceBuffer::initReadIndex()
@ -189,8 +189,8 @@ void SDRdaemonSourceBuffer::checkSlotData(int slotIndex)
void SDRdaemonSourceBuffer::writeData(char *array)
{
SuperBlock *superBlock = (SuperBlock *) array;
int frameIndex = superBlock->header.frameIndex;
SDRDaemonSuperBlock *superBlock = (SDRDaemonSuperBlock *) array;
int frameIndex = superBlock->m_header.m_frameIndex;
int decoderIndex = frameIndex % nbDecoderSlots;
// frame break
@ -213,9 +213,9 @@ void SDRdaemonSourceBuffer::writeData(char *array)
// Block processing
if (m_decoderSlots[decoderIndex].m_blockCount < m_nbOriginalBlocks) // not enough blocks to decode -> store data
if (m_decoderSlots[decoderIndex].m_blockCount < SDRDaemonNbOrginalBlocks) // not enough blocks to decode -> store data
{
int blockIndex = superBlock->header.blockIndex;
int blockIndex = superBlock->m_header.m_blockIndex;
int blockCount = m_decoderSlots[decoderIndex].m_blockCount;
int recoveryCount = m_decoderSlots[decoderIndex].m_recoveryCount;
m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[blockCount].Index = blockIndex;
@ -225,14 +225,14 @@ void SDRdaemonSourceBuffer::writeData(char *array)
m_decoderSlots[decoderIndex].m_metaRetrieved = true;
}
if (blockIndex < m_nbOriginalBlocks) // original data
if (blockIndex < SDRDaemonNbOrginalBlocks) // original data
{
m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[blockCount].Block = (void *) storeOriginalBlock(decoderIndex, blockIndex, superBlock->protectedBlock);
m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[blockCount].Block = (void *) storeOriginalBlock(decoderIndex, blockIndex, superBlock->m_protectedBlock);
m_decoderSlots[decoderIndex].m_originalCount++;
}
else // recovery data
{
m_decoderSlots[decoderIndex].m_recoveryBlocks[recoveryCount] = superBlock->protectedBlock;
m_decoderSlots[decoderIndex].m_recoveryBlocks[recoveryCount] = superBlock->m_protectedBlock;
m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[blockCount].Block = (void *) &m_decoderSlots[decoderIndex].m_recoveryBlocks[recoveryCount];
m_decoderSlots[decoderIndex].m_recoveryCount++;
}
@ -240,14 +240,14 @@ void SDRdaemonSourceBuffer::writeData(char *array)
m_decoderSlots[decoderIndex].m_blockCount++;
if (m_decoderSlots[decoderIndex].m_blockCount == m_nbOriginalBlocks) // ready to decode
if (m_decoderSlots[decoderIndex].m_blockCount == SDRDaemonNbOrginalBlocks) // 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
m_paramsCM256.BlockBytes = sizeof(SDRDaemonProtectedBlock); // never changes
m_paramsCM256.OriginalCount = SDRDaemonNbOrginalBlocks; // never changes
if (m_decoderSlots[decoderIndex].m_metaRetrieved) {
m_paramsCM256.RecoveryCount = m_currentMeta.m_nbFECBlocks;
@ -269,13 +269,13 @@ void SDRdaemonSourceBuffer::writeData(char *array)
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 recoveryIndex = SDRDaemonNbOrginalBlocks - m_decoderSlots[decoderIndex].m_recoveryCount + ir;
int blockIndex = m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[recoveryIndex].Index;
ProtectedBlock *recoveredBlock = (ProtectedBlock *) m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[recoveryIndex].Block;
SDRDaemonProtectedBlock *recoveredBlock = (SDRDaemonProtectedBlock *) m_decoderSlots[decoderIndex].m_cm256DescriptorBlocks[recoveryIndex].Block;
if (blockIndex == 0) // first block with meta
{
MetaDataFEC *metaData = (MetaDataFEC *) recoveredBlock;
SDRDaemonMetaDataFEC *metaData = (SDRDaemonMetaDataFEC *) recoveredBlock;
boost::crc_32_type crc32;
crc32.process_bytes(metaData, 20);
@ -300,7 +300,7 @@ void SDRdaemonSourceBuffer::writeData(char *array)
if (m_decoderSlots[decoderIndex].m_metaRetrieved) // block zero with its meta data has been received
{
MetaDataFEC *metaData = getMetaData(decoderIndex);
SDRDaemonMetaDataFEC *metaData = getMetaData(decoderIndex);
if (!(*metaData == m_currentMeta))
{
@ -435,7 +435,7 @@ uint8_t *SDRdaemonSourceBuffer::readData(int32_t length)
}
}
void SDRdaemonSourceBuffer::printMeta(const QString& header, MetaDataFEC *metaData)
void SDRdaemonSourceBuffer::printMeta(const QString& header, SDRDaemonMetaDataFEC *metaData)
{
qDebug() << header << ": "
<< "|" << metaData->m_centerFrequency

90
plugins/samplesource/sdrdaemonsource/sdrdaemonsourcebuffer.h
View File

@ -22,6 +22,7 @@
#include <cstdlib>
#include "cm256.h"
#include "util/movingaverage.h"
#include "channel/sdrdaemondatablock.h"
#define SDRDAEMONSOURCE_UDPSIZE 512 // UDP payload size
@ -31,54 +32,6 @@
class SDRdaemonSourceBuffer
{
public:
#pragma pack(push, 1)
struct MetaDataFEC
{
uint32_t m_centerFrequency; //!< 4 center frequency in kHz
uint32_t m_sampleRate; //!< 8 sample rate in Hz
uint8_t m_sampleBytes; //!< 9 MSB(4): indicators, LSB(4) number of bytes per sample
uint8_t m_sampleBits; //!< 10 number of effective bits per sample
uint8_t m_nbOriginalBlocks; //!< 11 number of blocks with original (protected) data
uint8_t m_nbFECBlocks; //!< 12 number of blocks carrying FEC
uint32_t m_tv_sec; //!< 16 seconds of timestamp at start time of super-frame processing
uint32_t m_tv_usec; //!< 20 microseconds of timestamp at start time of super-frame processing
uint32_t m_crc32; //!< 24 CRC32 of the above
bool operator==(const MetaDataFEC& rhs)
{
return (memcmp((const char *) this, (const char *) &rhs, 12) == 0); // Only the 12 first bytes are relevant
}
void init()
{
memset((char *) this, 0, sizeof(MetaDataFEC));
m_sampleBits = 16; // assume 16 bits samples to start with
m_sampleBytes = 2;
}
};
struct Header
{
uint16_t frameIndex;
uint8_t blockIndex;
uint8_t filler;
uint32_t filler2;
};
static const int framesSize = SDRDAEMONSOURCE_NBDECODERSLOTS * (SDRDAEMONSOURCE_NBORIGINALBLOCKS - 1) * (SDRDAEMONSOURCE_UDPSIZE - sizeof(Header));
struct ProtectedBlock
{
uint8_t buf[SDRDAEMONSOURCE_UDPSIZE - sizeof(Header)];
};
struct SuperBlock
{
Header header;
ProtectedBlock protectedBlock;
};
#pragma pack(pop)
SDRdaemonSourceBuffer();
~SDRdaemonSourceBuffer();
@ -88,7 +41,7 @@ public:
uint8_t *readData(int32_t length); //!< Read data from buffer
// meta data
const MetaDataFEC& getCurrentMeta() const { return m_currentMeta; }
const SDRDaemonMetaDataFEC& getCurrentMeta() const { return m_currentMeta; }
// samples timestamp
uint32_t getTVOutSec() const { return m_tvOut_sec; }
@ -152,8 +105,7 @@ public:
}
}
static const int m_udpPayloadSize = SDRDAEMONSOURCE_UDPSIZE;
static const int m_nbOriginalBlocks = SDRDAEMONSOURCE_NBORIGINALBLOCKS;
static const int framesSize = SDRDAEMONSOURCE_NBDECODERSLOTS * (SDRDaemonNbOrginalBlocks - 1) * SDRDaemonNbBytesPerBlock;
private:
static const int nbDecoderSlots = SDRDAEMONSOURCE_NBDECODERSLOTS;
@ -161,24 +113,24 @@ private:
#pragma pack(push, 1)
struct BufferFrame
{
ProtectedBlock m_blocks[m_nbOriginalBlocks - 1];
SDRDaemonProtectedBlock m_blocks[SDRDaemonNbOrginalBlocks - 1];
};
#pragma pack(pop)
struct DecoderSlot
{
ProtectedBlock m_blockZero; //!< First block of a frame. Has meta data.
ProtectedBlock m_originalBlocks[m_nbOriginalBlocks]; //!< Original blocks retrieved directly or by later FEC
ProtectedBlock m_recoveryBlocks[m_nbOriginalBlocks]; //!< Recovery blocks (FEC blocks) with max size
CM256::cm256_block m_cm256DescriptorBlocks[m_nbOriginalBlocks]; //!< 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
SDRDaemonProtectedBlock m_blockZero; //!< First block of a frame. Has meta data.
SDRDaemonProtectedBlock m_originalBlocks[SDRDaemonNbOrginalBlocks]; //!< Original blocks retrieved directly or by later FEC
SDRDaemonProtectedBlock m_recoveryBlocks[SDRDaemonNbOrginalBlocks]; //!< Recovery blocks (FEC blocks) with max size
CM256::cm256_block m_cm256DescriptorBlocks[SDRDaemonNbOrginalBlocks]; //!< 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
};
MetaDataFEC m_currentMeta; //!< Stored current meta data
SDRDaemonMetaDataFEC m_currentMeta; //!< Stored current meta data
CM256::cm256_encoder_params m_paramsCM256; //!< CM256 decoder parameters block
DecoderSlot m_decoderSlots[nbDecoderSlots]; //!< CM256 decoding control/buffer slots
BufferFrame m_frames[nbDecoderSlots]; //!< Samples buffer
@ -213,7 +165,7 @@ private:
CM256 m_cm256; //!< CM256 library
bool m_cm256_OK; //!< CM256 library initialized OK
inline ProtectedBlock* storeOriginalBlock(int slotIndex, int blockIndex, const ProtectedBlock& protectedBlock)
inline SDRDaemonProtectedBlock* storeOriginalBlock(int slotIndex, int blockIndex, const SDRDaemonProtectedBlock& protectedBlock)
{
if (blockIndex == 0) {
// m_decoderSlots[slotIndex].m_originalBlocks[0] = protectedBlock;
@ -228,7 +180,7 @@ private:
}
}
inline ProtectedBlock& getOriginalBlock(int slotIndex, int blockIndex)
inline SDRDaemonProtectedBlock& getOriginalBlock(int slotIndex, int blockIndex)
{
if (blockIndex == 0) {
// return m_decoderSlots[slotIndex].m_originalBlocks[0];
@ -239,17 +191,17 @@ private:
}
}
inline MetaDataFEC *getMetaData(int slotIndex)
inline SDRDaemonMetaDataFEC *getMetaData(int slotIndex)
{
// return (MetaDataFEC *) &m_decoderSlots[slotIndex].m_originalBlocks[0];
return (MetaDataFEC *) &m_decoderSlots[slotIndex].m_blockZero;
return (SDRDaemonMetaDataFEC *) &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(ProtectedBlock));
memset((void *) m_frames[slotIndex].m_blocks, 0, (m_nbOriginalBlocks - 1) * sizeof(ProtectedBlock));
memset((void *) &m_decoderSlots[slotIndex].m_blockZero, 0, sizeof(SDRDaemonProtectedBlock));
memset((void *) m_frames[slotIndex].m_blocks, 0, (SDRDaemonNbOrginalBlocks - 1) * sizeof(SDRDaemonProtectedBlock));
}
void initDecodeAllSlots();
@ -258,7 +210,7 @@ private:
void checkSlotData(int slotIndex);
void initDecodeSlot(int slotIndex);
static void printMeta(const QString& header, MetaDataFEC *metaData);
static void printMeta(const QString& header, SDRDaemonMetaDataFEC *metaData);
};

8
plugins/samplesource/sdrdaemonsource/sdrdaemonsourceudphandler.cpp
View File

@ -56,7 +56,7 @@ SDRdaemonSourceUDPHandler::SDRdaemonSourceUDPHandler(SampleSinkFifo *sampleFifo,
m_throttleToggle(false),
m_autoCorrBuffer(true)
{
m_udpBuf = new char[SDRdaemonSourceBuffer::m_udpPayloadSize];
m_udpBuf = new char[SDRDaemonUdpSize];
#ifdef USE_INTERNAL_TIMER
#warning "Uses internal timer"
@ -167,7 +167,7 @@ void SDRdaemonSourceUDPHandler::dataReadyRead()
qint64 pendingDataSize = m_dataSocket->pendingDatagramSize();
m_udpReadBytes += m_dataSocket->readDatagram(&m_udpBuf[m_udpReadBytes], pendingDataSize, &m_remoteAddress, 0);
if (m_udpReadBytes == SDRdaemonSourceBuffer::m_udpPayloadSize) {
if (m_udpReadBytes == SDRDaemonUdpSize) {
processData();
m_udpReadBytes = 0;
}
@ -177,7 +177,7 @@ void SDRdaemonSourceUDPHandler::dataReadyRead()
void SDRdaemonSourceUDPHandler::processData()
{
m_sdrDaemonBuffer.writeData(m_udpBuf);
const SDRdaemonSourceBuffer::MetaDataFEC& metaData = m_sdrDaemonBuffer.getCurrentMeta();
const SDRDaemonMetaDataFEC& metaData = m_sdrDaemonBuffer.getCurrentMeta();
bool change = false;
m_tv_sec = m_sdrDaemonBuffer.getTVOutSec();
@ -263,7 +263,7 @@ void SDRdaemonSourceUDPHandler::tick()
m_readLengthSamples += m_sdrDaemonBuffer.getRWBalanceCorrection();
}
const SDRdaemonSourceBuffer::MetaDataFEC& metaData = m_sdrDaemonBuffer.getCurrentMeta();
const SDRDaemonMetaDataFEC& metaData = m_sdrDaemonBuffer.getCurrentMeta();
m_readLength = m_readLengthSamples * (metaData.m_sampleBytes & 0xF) * 2;
if (SDR_RX_SAMP_SZ == metaData.m_sampleBits) // same sample size

2
plugins/samplesource/sdrdaemonsource/sdrdaemonsourceudphandler.h
View File

@ -43,7 +43,7 @@ public:
void stop();
void configureUDPLink(const QString& address, quint16 port);
void getRemoteAddress(QString& s) const { s = m_remoteAddress.toString(); }
int getNbOriginalBlocks() const { return SDRdaemonSourceBuffer::m_nbOriginalBlocks; }
int getNbOriginalBlocks() const { return SDRDaemonNbOrginalBlocks; }
bool isStreaming() const { return m_masterTimerConnected; }
int getSampleRate() const { return m_samplerate; }
int getCenterFrequency() const { return m_centerFrequency * 1000; }