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.
136 lines
6.5 KiB
136 lines
6.5 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// 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/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#ifndef PLUGINS_SAMPLESOURCE_SDRDAEMON_SDRDAEMONBUFFEROLD_H_ |
|
#define PLUGINS_SAMPLESOURCE_SDRDAEMON_SDRDAEMONBUFFEROLD_H_ |
|
|
|
#include <stdint.h> |
|
#include <cstring> |
|
#include <cstddef> |
|
#include <lz4.h> |
|
#include "../../../sdrbase/dsp/samplesinkfifo.h" |
|
#include "util/CRC64.h" |
|
|
|
class SDRdaemonBufferOld |
|
{ |
|
public: |
|
#pragma pack(push, 1) |
|
struct MetaData |
|
{ |
|
// critical data |
|
uint32_t m_centerFrequency; //!< center frequency in kHz |
|
uint32_t m_sampleRate; //!< sample rate in Hz |
|
uint8_t m_sampleBytes; //!< MSB(4): indicators, LSB(4) number of bytes per sample |
|
uint8_t m_sampleBits; //!< number of effective bits per sample |
|
uint16_t m_blockSize; //!< payload size |
|
uint32_t m_nbSamples; //!< number of samples in a hardware block |
|
// end of critical data |
|
uint16_t m_nbBlocks; //!< number of hardware blocks in the frame |
|
uint32_t m_nbBytes; //!< total number of bytes in the frame |
|
uint32_t m_tv_sec; //!< seconds of timestamp at start time of frame processing |
|
uint32_t m_tv_usec; //!< microseconds of timestamp at start time of frame processing |
|
uint64_t m_crc; //!< 64 bit CRC of the above |
|
|
|
bool operator==(const MetaData& rhs) |
|
{ |
|
return (memcmp((const void *) this, (const void *) &rhs, 20) == 0); // Only the 20 first bytes are relevant (critical) |
|
} |
|
|
|
void init() |
|
{ |
|
memset((void *) this, 0, sizeof(MetaData)); |
|
} |
|
|
|
void operator=(const MetaData& rhs) |
|
{ |
|
memcpy((void *) this, (const void *) &rhs, sizeof(MetaData)); |
|
} |
|
}; |
|
#pragma pack(pop) |
|
|
|
SDRdaemonBufferOld(uint32_t rateDivider); |
|
~SDRdaemonBufferOld(); |
|
bool readMeta(char *array, uint32_t length); //!< Attempt to read meta. Returns true if meta block |
|
void writeData(char *array, uint32_t length); //!< Write data into buffer. |
|
uint8_t *readDataChunk(); //!< Read a chunk of data from buffer |
|
const MetaData& getCurrentMeta() const { return m_currentMeta; } |
|
uint32_t getSampleRateStream() const { return m_sampleRateStream; } |
|
uint32_t getSampleRate() const { return m_sampleRate; } |
|
void updateBlockCounts(uint32_t nbBytesReceived); |
|
bool isSync() const { return m_sync; } |
|
bool isSyncLocked() const { return m_syncLock; } |
|
uint32_t getFrameSize() const { return m_frameSize; } |
|
bool isLz4Compressed() const { return m_lz4; } |
|
float getCompressionRatio() const { return (m_frameSize > 0 ? (float) m_lz4InSize / (float) m_frameSize : 1.0); } |
|
uint32_t getLz4DataCRCOK() const { return m_nbLastLz4CRCOK; } |
|
uint32_t getLz4SuccessfulDecodes() const { return m_nbLastLz4SuccessfulDecodes; } |
|
void setAutoFollowRate(bool autoFollowRate) { m_autoFollowRate = autoFollowRate; } |
|
|
|
static const int m_udpPayloadSize; |
|
static const int m_sampleSize; |
|
static const int m_iqSampleSize; |
|
|
|
private: |
|
void updateLZ4Sizes(uint32_t frameSize); |
|
void writeDataLZ4(const char *array, uint32_t length); |
|
void writeToRawBufferLZ4(); |
|
void writeToRawBufferUncompressed(const char *array, uint32_t length); |
|
void updateBufferSize(uint32_t sampleRate); |
|
void printMeta(MetaData *metaData); |
|
|
|
uint32_t m_rateDivider; //!< Number of times per seconds the samples are fetched |
|
bool m_sync; //!< Meta data acquired |
|
bool m_syncLock; //!< Meta data expected (Stream synchronized) |
|
bool m_lz4; //!< Stream is compressed with LZ4 |
|
MetaData m_currentMeta; //!< Stored current meta data |
|
CRC64 m_crc64; //!< CRC64 calculator |
|
|
|
uint32_t m_inCount; //!< Current position of uncompressed input |
|
uint8_t *m_lz4InBuffer; //!< Buffer for LZ4 compressed input |
|
uint32_t m_lz4InCount; //!< Current position in LZ4 input buffer |
|
uint32_t m_lz4InSize; //!< Size in bytes of the LZ4 input data |
|
uint8_t *m_lz4OutBuffer; //!< Buffer for LZ4 uncompressed output |
|
uint32_t m_frameSize; //!< Size in bytes of one uncompressed frame |
|
uint32_t m_nbLz4Decodes; |
|
uint32_t m_nbLz4SuccessfulDecodes; |
|
uint32_t m_nbLz4CRCOK; |
|
uint32_t m_nbLastLz4SuccessfulDecodes; |
|
uint32_t m_nbLastLz4CRCOK; |
|
uint64_t m_dataCRC; |
|
|
|
uint32_t m_sampleRateStream; //!< Current sample rate from the stream |
|
uint32_t m_sampleRate; //!< Current actual sample rate in Hz |
|
uint8_t m_sampleBytes; //!< Current number of bytes per I or Q sample |
|
uint8_t m_sampleBits; //!< Current number of effective bits per sample |
|
|
|
uint32_t m_writeIndex; //!< Current write position in the raw samples buffer |
|
uint32_t m_readChunkIndex; //!< Current read chunk index in the raw samples buffer |
|
uint32_t m_rawSize; //!< Size of the raw samples buffer in bytes |
|
uint8_t *m_rawBuffer; //!< Buffer for raw samples obtained from UDP (I/Q not in a formal I/Q structure) |
|
uint32_t m_chunkSize; //!< Size of a chunk of samples in bytes |
|
uint32_t m_bytesInBlock; //!< Number of bytes received in the current UDP block |
|
uint32_t m_nbBlocks; //!< Number of UDP blocks received in the current frame |
|
|
|
uint32_t m_readCycles; //!< Count of read cycles over raw buiffer |
|
uint32_t m_lastWriteIndex; //!< Write index at last skew estimation |
|
double m_skewRateSum; |
|
double m_skewRate; |
|
bool m_autoFollowRate; //!< Aito follow stream sample rate else stick with meta data sample rate |
|
}; |
|
|
|
|
|
|
|
#endif /* PLUGINS_SAMPLESOURCE_SDRDAEMON_SDRDAEMONBUFFEROLD_H_ */
|
|
|