1
0
mirror of https://github.com/f4exb/sdrangel.git synced 2024-11-27 02:09:14 -05:00
sdrangel/sdrbase/channel/remotedatablock.h

176 lines
5.9 KiB
C
Raw Normal View History

2018-08-20 02:41:54 -04:00
///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2018 Edouard Griffiths, F4EXB. //
// //
// Remote sink channel (Rx) data block //
2018-08-20 02:41:54 -04:00
// //
// SDRangel can serve as a remote SDR front end that handles the interface //
// with a physical device and sends or receives the I/Q samples stream via UDP //
// to or from another SDRangel instance or any program implementing the same //
// protocol. The remote SDRangel is controlled via its Web REST API. //
2018-08-20 02:41:54 -04:00
// //
// 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. //
2018-08-20 02:41:54 -04:00
// //
// 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 CHANNEL_REMOTEDATABLOCK_H_
#define CHANNEL_REMOTEDATABLOCK_H_
2018-08-20 02:41:54 -04:00
#include <stdint.h>
#include <string.h>
2018-08-21 11:23:48 -04:00
#include <algorithm>
2018-08-28 00:33:15 -04:00
#include <QString>
2018-08-20 02:41:54 -04:00
#include "dsp/dsptypes.h"
#define UDPSINKFEC_UDPSIZE 512
#define UDPSINKFEC_NBORIGINALBLOCKS 128
//#define UDPSINKFEC_NBTXBLOCKS 8
2018-08-20 02:41:54 -04:00
#pragma pack(push, 1)
struct RemoteMetaDataFEC
2018-08-20 02:41:54 -04:00
{
uint32_t m_centerFrequency; //!< 4 center frequency in kHz
uint32_t m_sampleRate; //!< 8 sample rate in Hz
uint8_t m_sampleBytes; //!< 9 4 LSB: number of bytes per sample (2 or 4)
uint8_t m_sampleBits; //!< 10 number of effective bits per sample (deprecated)
2018-08-20 19:36:39 -04:00
uint8_t m_nbOriginalBlocks; //!< 11 number of blocks with original (protected) data
uint8_t m_nbFECBlocks; //!< 12 number of blocks carrying FEC
2018-08-20 19:36:39 -04:00
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
2018-08-20 02:41:54 -04:00
bool operator==(const RemoteMetaDataFEC& rhs)
2018-08-20 02:41:54 -04:00
{
// Only the first 6 fields are relevant
return (m_centerFrequency == rhs.m_centerFrequency)
&& (m_sampleRate == rhs.m_sampleRate)
&& (m_sampleBytes == rhs.m_sampleBytes)
&& (m_sampleBits == rhs.m_sampleBits)
&& (m_nbOriginalBlocks == rhs.m_nbOriginalBlocks)
&& (m_nbFECBlocks == rhs.m_nbFECBlocks);
2018-08-20 02:41:54 -04:00
}
void init()
{
2018-08-21 11:23:48 -04:00
m_centerFrequency = 0;
m_sampleRate = 0;
m_sampleBytes = 0;
m_sampleBits = 0;
m_nbOriginalBlocks = 0;
m_nbFECBlocks = 0;
2018-08-21 11:23:48 -04:00
m_tv_sec = 0;
m_tv_usec = 0;
m_crc32 = 0;
2018-08-20 02:41:54 -04:00
}
};
struct RemoteHeader
2018-08-20 02:41:54 -04:00
{
uint16_t m_frameIndex;
uint8_t m_blockIndex;
uint8_t m_sampleBytes; //!< number of bytes per sample (2 or 4) for this block
uint8_t m_sampleBits; //!< number of bits per sample
2018-08-20 02:41:54 -04:00
uint8_t m_filler;
uint16_t m_filler2;
2018-08-21 11:23:48 -04:00
void init()
2018-08-21 11:23:48 -04:00
{
m_frameIndex = 0;
m_blockIndex = 0;
m_sampleBytes = 2;
m_sampleBits = 16;
2018-08-21 11:23:48 -04:00
m_filler = 0;
m_filler2 = 0;
}
2018-08-20 02:41:54 -04:00
};
static const int RemoteUdpSize = UDPSINKFEC_UDPSIZE;
static const int RemoteNbOrginalBlocks = UDPSINKFEC_NBORIGINALBLOCKS;
static const int RemoteNbBytesPerBlock = UDPSINKFEC_UDPSIZE - sizeof(RemoteHeader);
2018-08-20 02:41:54 -04:00
struct RemoteProtectedBlock
2018-08-20 02:41:54 -04:00
{
uint8_t buf[RemoteNbBytesPerBlock];
2018-08-21 11:23:48 -04:00
void init() {
std::fill(buf, buf+RemoteNbBytesPerBlock, 0);
2018-08-21 11:23:48 -04:00
}
2018-08-20 02:41:54 -04:00
};
struct RemoteSuperBlock
2018-08-20 02:41:54 -04:00
{
RemoteHeader m_header;
RemoteProtectedBlock m_protectedBlock;
2018-08-21 11:23:48 -04:00
void init()
{
m_header.init();
m_protectedBlock.init();
}
2018-08-20 02:41:54 -04:00
};
#pragma pack(pop)
struct RemoteTxControlBlock
2018-08-20 02:41:54 -04:00
{
2018-08-21 08:00:56 -04:00
bool m_complete;
2018-08-20 02:41:54 -04:00
bool m_processed;
uint16_t m_frameIndex;
int m_nbBlocksFEC;
int m_txDelay;
QString m_dataAddress;
uint16_t m_dataPort;
2018-08-21 08:00:56 -04:00
RemoteTxControlBlock() {
2018-08-21 08:00:56 -04:00
m_complete = false;
m_processed = false;
m_frameIndex = 0;
m_nbBlocksFEC = 0;
m_txDelay = 100;
m_dataAddress = "127.0.0.1";
m_dataPort = 9090;
2018-08-21 08:00:56 -04:00
}
2018-08-20 02:41:54 -04:00
};
struct RemoteRxControlBlock
{
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_metaRetrieved; //!< true if meta data (block zero) was retrieved
int m_frameIndex; //!< this frame index or -1 if unset
RemoteRxControlBlock() {
m_blockCount = 0;
m_originalCount = 0;
m_recoveryCount = 0;
m_metaRetrieved = false;
m_frameIndex = -1;
}
};
class RemoteDataBlock
2018-08-20 02:41:54 -04:00
{
public:
RemoteDataBlock() {
m_superBlocks = new RemoteSuperBlock[256];
2018-08-21 11:23:48 -04:00
}
~RemoteDataBlock() {
2018-08-21 11:23:48 -04:00
delete[] m_superBlocks;
}
RemoteTxControlBlock m_txControlBlock;
RemoteRxControlBlock m_rxControlBlock;
RemoteSuperBlock *m_superBlocks;
2018-08-20 02:41:54 -04:00
};
#endif /* CHANNEL_REMOTEDATABLOCK_H_ */