mirror of
https://github.com/ggerganov/ggwave.git
synced 2026-02-07 01:11:22 +08:00
1929 lines
66 KiB
C++
1929 lines
66 KiB
C++
#include "ggwave/ggwave.h"
|
|
|
|
#include "fft.h"
|
|
#include "reed-solomon/rs.hpp"
|
|
|
|
#include <cmath>
|
|
#include <ctime>
|
|
#include <cstdio>
|
|
//#include <random>
|
|
|
|
#ifndef M_PI
|
|
#define M_PI 3.14159265358979323846
|
|
#endif
|
|
|
|
#ifdef ARDUINO
|
|
#define ggprintf(...)
|
|
#else
|
|
#define ggprintf(...) \
|
|
g_fptr && fprintf(g_fptr, __VA_ARGS__)
|
|
#endif
|
|
|
|
//
|
|
// C interface
|
|
//
|
|
|
|
namespace {
|
|
|
|
FILE * g_fptr = stderr;
|
|
std::vector<GGWave *> g_instances;
|
|
|
|
double linear_interp(double first_number, double second_number, double fraction) {
|
|
return (first_number + ((second_number - first_number)*fraction));
|
|
}
|
|
|
|
}
|
|
|
|
extern "C"
|
|
void ggwave_setLogFile(void * fptr) {
|
|
GGWave::setLogFile((FILE *) fptr);
|
|
}
|
|
|
|
extern "C"
|
|
ggwave_Parameters ggwave_getDefaultParameters(void) {
|
|
return GGWave::getDefaultParameters();
|
|
}
|
|
|
|
extern "C"
|
|
ggwave_Instance ggwave_init(const ggwave_Parameters parameters) {
|
|
static ggwave_Instance curId = 0;
|
|
|
|
if ((int) g_instances.size() < curId + 1) {
|
|
g_instances.resize(curId + 1, nullptr);
|
|
}
|
|
|
|
g_instances[curId] = new GGWave({
|
|
parameters.payloadLength,
|
|
parameters.sampleRateInp,
|
|
parameters.sampleRateOut,
|
|
parameters.sampleRate,
|
|
parameters.samplesPerFrame,
|
|
parameters.soundMarkerThreshold,
|
|
parameters.sampleFormatInp,
|
|
parameters.sampleFormatOut,
|
|
parameters.operatingMode});
|
|
|
|
return curId++;
|
|
}
|
|
|
|
extern "C"
|
|
void ggwave_free(ggwave_Instance instance) {
|
|
if ((int) g_instances.size() > instance && g_instances[instance]) {
|
|
delete (GGWave *) g_instances[instance];
|
|
g_instances[instance] = nullptr;
|
|
}
|
|
}
|
|
|
|
extern "C"
|
|
int ggwave_encode(
|
|
ggwave_Instance instance,
|
|
const void * payloadBuffer,
|
|
int payloadSize,
|
|
ggwave_ProtocolId protocolId,
|
|
int volume,
|
|
void * waveformBuffer,
|
|
int query) {
|
|
GGWave * ggWave = (GGWave *) g_instances[instance];
|
|
|
|
if (ggWave == nullptr) {
|
|
ggprintf("Invalid GGWave instance %d\n", instance);
|
|
return -1;
|
|
}
|
|
|
|
if (ggWave->init(payloadSize, (const char *) payloadBuffer, protocolId, volume) == false) {
|
|
ggprintf("Failed to initialize Tx transmission for GGWave instance %d\n", instance);
|
|
return -1;
|
|
}
|
|
|
|
if (query != 0) {
|
|
if (query == 1) {
|
|
return ggWave->encodeSize_bytes();
|
|
}
|
|
|
|
return ggWave->encodeSize_samples();
|
|
}
|
|
|
|
const int nBytes = ggWave->encode();
|
|
if (nBytes == 0) {
|
|
ggprintf("Failed to encode data - GGWave instance %d\n", instance);
|
|
return -1;
|
|
}
|
|
|
|
{
|
|
auto pSrc = (const char *) ggWave->txData();
|
|
auto pDst = ( char *) waveformBuffer;
|
|
std::copy(pSrc, pSrc + nBytes, pDst);
|
|
}
|
|
|
|
return nBytes;
|
|
}
|
|
|
|
extern "C"
|
|
int ggwave_decode(
|
|
ggwave_Instance instance,
|
|
const void * waveformBuffer,
|
|
int waveformSize,
|
|
void * payloadBuffer) {
|
|
GGWave * ggWave = (GGWave *) g_instances[instance];
|
|
|
|
if (ggWave->decode(waveformBuffer, waveformSize) == false) {
|
|
ggprintf("Failed to decode data - GGWave instance %d\n", instance);
|
|
return -1;
|
|
}
|
|
|
|
static thread_local GGWave::TxRxData data;
|
|
|
|
const auto dataLength = ggWave->rxTakeData(data);
|
|
if (dataLength == -1) {
|
|
// failed to decode message
|
|
return -1;
|
|
} else if (dataLength > 0) {
|
|
memcpy(payloadBuffer, data.data(), dataLength);
|
|
}
|
|
|
|
return dataLength;
|
|
}
|
|
|
|
extern "C"
|
|
int ggwave_ndecode(
|
|
ggwave_Instance instance,
|
|
const void * waveformBuffer,
|
|
int waveformSize,
|
|
void * payloadBuffer,
|
|
int payloadSize) {
|
|
GGWave * ggWave = (GGWave *) g_instances[instance];
|
|
|
|
if (ggWave->decode(waveformBuffer, waveformSize) == false) {
|
|
ggprintf("Failed to decode data - GGWave instance %d\n", instance);
|
|
return -1;
|
|
}
|
|
|
|
static thread_local GGWave::TxRxData data;
|
|
|
|
const auto dataLength = ggWave->rxTakeData(data);
|
|
if (dataLength == -1) {
|
|
// failed to decode message
|
|
return -1;
|
|
} else if (dataLength > payloadSize) {
|
|
// the payloadBuffer is not big enough to store the data
|
|
return -2;
|
|
} else if (dataLength > 0) {
|
|
memcpy(payloadBuffer, data.data(), dataLength);
|
|
}
|
|
|
|
return dataLength;
|
|
}
|
|
|
|
extern "C"
|
|
void ggwave_rxToggleProtocol(
|
|
ggwave_ProtocolId protocolId,
|
|
int state) {
|
|
GGWave::Protocols::rx().toggle(protocolId, state != 0);
|
|
}
|
|
|
|
extern "C"
|
|
void ggwave_txToggleProtocol(
|
|
ggwave_ProtocolId protocolId,
|
|
int state) {
|
|
GGWave::Protocols::tx().toggle(protocolId, state != 0);
|
|
}
|
|
|
|
//
|
|
// C++ implementation
|
|
//
|
|
|
|
namespace {
|
|
|
|
void FFT(float * f, int N, int * ip, float * w) {
|
|
rdft(N, 1, f, ip, w);
|
|
}
|
|
|
|
void FFT(const float * src, float * dst, int N, int * ip, float * w) {
|
|
std::copy(src, src + N, dst);
|
|
|
|
FFT(dst, N, ip, w);
|
|
}
|
|
|
|
inline void addAmplitudeSmooth(
|
|
const GGWave::Amplitude & src,
|
|
GGWave::Amplitude & dst,
|
|
float scalar, int startId, int finalId, int cycleMod, int nPerCycle) {
|
|
const int nTotal = nPerCycle*finalId;
|
|
const float frac = 0.15f;
|
|
const float ds = frac*nTotal;
|
|
const float ids = 1.0f/ds;
|
|
const int nBegin = frac*nTotal;
|
|
const int nEnd = (1.0f - frac)*nTotal;
|
|
|
|
for (int i = startId; i < finalId; i++) {
|
|
const float k = cycleMod*finalId + i;
|
|
if (k < nBegin) {
|
|
dst[i] += scalar*src[i]*(k*ids);
|
|
} else if (k > nEnd) {
|
|
dst[i] += scalar*src[i]*(((float)(nTotal) - k)*ids);
|
|
} else {
|
|
dst[i] += scalar*src[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
int getECCBytesForLength(int len) {
|
|
return len < 4 ? 2 : std::max(4, 2*(len/5));
|
|
}
|
|
|
|
int bytesForSampleFormat(GGWave::SampleFormat sampleFormat) {
|
|
switch (sampleFormat) {
|
|
case GGWAVE_SAMPLE_FORMAT_UNDEFINED: return 0; break;
|
|
case GGWAVE_SAMPLE_FORMAT_U8: return sizeof(uint8_t); break;
|
|
case GGWAVE_SAMPLE_FORMAT_I8: return sizeof(int8_t); break;
|
|
case GGWAVE_SAMPLE_FORMAT_U16: return sizeof(uint16_t); break;
|
|
case GGWAVE_SAMPLE_FORMAT_I16: return sizeof(int16_t); break;
|
|
case GGWAVE_SAMPLE_FORMAT_F32: return sizeof(float); break;
|
|
};
|
|
|
|
ggprintf("Invalid sample format: %d\n", (int) sampleFormat);
|
|
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
struct GGWave::Rx {
|
|
bool receiving = false;
|
|
bool analyzing = false;
|
|
|
|
int nMarkersSuccess = 0;
|
|
int markerFreqStart = 0;
|
|
int recvDuration_frames = 0;
|
|
|
|
int framesLeftToAnalyze = 0;
|
|
int framesLeftToRecord = 0;
|
|
int framesToAnalyze = 0;
|
|
int framesToRecord = 0;
|
|
int samplesNeeded = 0;
|
|
|
|
std::vector<float> fftOut; // complex
|
|
std::vector<int> fftWorkI;
|
|
std::vector<float> fftWorkF;
|
|
|
|
bool hasNewRxData = false;
|
|
bool hasNewSpectrum = false;
|
|
bool hasNewAmplitude = false;
|
|
|
|
Spectrum spectrum;
|
|
Amplitude amplitude;
|
|
Amplitude amplitudeResampled;
|
|
TxRxData amplitudeTmp;
|
|
|
|
int dataLength = 0;
|
|
|
|
TxRxData data;
|
|
RxProtocol protocol;
|
|
RxProtocolId protocolId;
|
|
RxProtocols protocols;
|
|
|
|
// variable-length decoding
|
|
int historyId = 0;
|
|
|
|
Amplitude amplitudeAverage;
|
|
std::vector<Amplitude> amplitudeHistory;
|
|
RecordedData amplitudeRecorded;
|
|
|
|
// fixed-length decoding
|
|
int historyIdFixed = 0;
|
|
|
|
std::vector<std::vector<uint16_t>> spectrumHistoryFixed;
|
|
std::vector<uint8_t> detectedBins;
|
|
std::vector<uint8_t> detectedTones;
|
|
};
|
|
|
|
struct GGWave::Tx {
|
|
bool hasData = false;
|
|
|
|
float sendVolume = 0.1f;
|
|
|
|
int dataLength = 0;
|
|
int lastAmplitudeSize = 0;
|
|
|
|
std::vector<bool> dataBits;
|
|
std::vector<double> phaseOffsets;
|
|
|
|
std::vector<Amplitude> bit1Amplitude;
|
|
std::vector<Amplitude> bit0Amplitude;
|
|
|
|
TxRxData data;
|
|
TxProtocol protocol;
|
|
TxProtocols protocols;
|
|
|
|
Amplitude output;
|
|
Amplitude outputResampled;
|
|
TxRxData outputTmp;
|
|
AmplitudeI16 outputI16;
|
|
|
|
Tones tones;
|
|
};
|
|
|
|
//
|
|
// Protocols
|
|
//
|
|
|
|
void GGWave::Protocols::enableAll() {
|
|
for (auto & p : *this) {
|
|
if (p.name) {
|
|
p.enabled = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void GGWave::Protocols::disableAll() {
|
|
for (auto & p : *this) {
|
|
p.enabled = false;
|
|
}
|
|
}
|
|
|
|
void GGWave::Protocols::toggle(ProtocolId id, bool state) {
|
|
if (state) {
|
|
// enable protocol
|
|
(*this)[id].enabled = true;
|
|
} else {
|
|
// disable protocol
|
|
(*this)[id].enabled = false;
|
|
}
|
|
}
|
|
|
|
void GGWave::Protocols::only(ProtocolId id) {
|
|
disableAll();
|
|
(*this)[id].enabled = true;
|
|
}
|
|
|
|
void GGWave::Protocols::only(std::initializer_list<ProtocolId> ids) {
|
|
disableAll();
|
|
for (auto id : ids) {
|
|
(*this)[id].enabled = true;
|
|
}
|
|
}
|
|
|
|
GGWave::TxProtocols & GGWave::Protocols::tx() {
|
|
static TxProtocols protocols = kDefault();
|
|
|
|
return protocols;
|
|
}
|
|
|
|
GGWave::RxProtocols & GGWave::Protocols::rx() {
|
|
static RxProtocols protocols = kDefault();
|
|
|
|
return protocols;
|
|
}
|
|
|
|
//
|
|
// GGWave
|
|
//
|
|
|
|
GGWave::GGWave(const Parameters & parameters) :
|
|
m_sampleRateInp (parameters.sampleRateInp),
|
|
m_sampleRateOut (parameters.sampleRateOut),
|
|
m_sampleRate (parameters.sampleRate),
|
|
m_samplesPerFrame (parameters.samplesPerFrame),
|
|
m_isamplesPerFrame (1.0f/m_samplesPerFrame),
|
|
m_sampleSizeInp (bytesForSampleFormat(parameters.sampleFormatInp)),
|
|
m_sampleSizeOut (bytesForSampleFormat(parameters.sampleFormatOut)),
|
|
m_sampleFormatInp (parameters.sampleFormatInp),
|
|
m_sampleFormatOut (parameters.sampleFormatOut),
|
|
m_hzPerSample (m_sampleRate/m_samplesPerFrame),
|
|
m_ihzPerSample (1.0f/m_hzPerSample),
|
|
m_freqDelta_bin (1),
|
|
m_freqDelta_hz (2*m_hzPerSample),
|
|
m_nBitsInMarker (16),
|
|
m_nMarkerFrames (parameters.payloadLength > 0 ? 0 : kDefaultMarkerFrames),
|
|
m_encodedDataOffset (parameters.payloadLength > 0 ? 0 : kDefaultEncodedDataOffset),
|
|
m_soundMarkerThreshold(parameters.soundMarkerThreshold),
|
|
m_isFixedPayloadLength(parameters.payloadLength > 0),
|
|
m_payloadLength (parameters.payloadLength),
|
|
m_isRxEnabled (parameters.operatingMode & GGWAVE_OPERATING_MODE_RX),
|
|
m_isTxEnabled (parameters.operatingMode & GGWAVE_OPERATING_MODE_TX),
|
|
m_needResampling (m_sampleRateInp != m_sampleRate || m_sampleRateOut != m_sampleRate),
|
|
m_txOnlyTones (parameters.operatingMode & GGWAVE_OPERATING_MODE_TX_ONLY_TONES),
|
|
m_isDSSEnabled (parameters.operatingMode & GGWAVE_OPERATING_MODE_USE_DSS),
|
|
|
|
// common
|
|
m_dataEncoded (kMaxDataSize),
|
|
|
|
m_rx(nullptr),
|
|
m_tx(nullptr),
|
|
m_resampler(nullptr) {
|
|
|
|
if (m_sampleSizeInp == 0) {
|
|
ggprintf("Invalid or unsupported capture sample format: %d\n", (int) parameters.sampleFormatInp);
|
|
return;
|
|
}
|
|
|
|
if (m_sampleSizeOut == 0) {
|
|
ggprintf("Invalid or unsupported playback sample format: %d\n", (int) parameters.sampleFormatOut);
|
|
return;
|
|
}
|
|
|
|
if (parameters.samplesPerFrame > kMaxSamplesPerFrame) {
|
|
ggprintf("Invalid samples per frame: %d, max: %d\n", parameters.samplesPerFrame, kMaxSamplesPerFrame);
|
|
return;
|
|
}
|
|
|
|
if (m_sampleRateInp < kSampleRateMin) {
|
|
ggprintf("Error: capture sample rate (%g Hz) must be >= %g Hz\n", m_sampleRateInp, kSampleRateMin);
|
|
return;
|
|
}
|
|
|
|
if (m_sampleRateInp > kSampleRateMax) {
|
|
ggprintf("Error: capture sample rate (%g Hz) must be <= %g Hz\n", m_sampleRateInp, kSampleRateMax);
|
|
return;
|
|
}
|
|
|
|
if (m_isRxEnabled) {
|
|
m_rx = new Rx();
|
|
|
|
m_rx->samplesNeeded = m_samplesPerFrame;
|
|
|
|
m_rx->fftOut.resize(2*m_samplesPerFrame);
|
|
m_rx->fftWorkI.resize(3 + sqrt(m_samplesPerFrame/2));
|
|
m_rx->fftWorkF.resize(m_samplesPerFrame/2);
|
|
m_rx->fftWorkI[0] = 0;
|
|
|
|
m_rx->spectrum.resize(m_samplesPerFrame);
|
|
m_rx->amplitude.resize(m_needResampling ? m_samplesPerFrame + 128 : m_samplesPerFrame); // small extra space because sometimes resampling needs a few more samples
|
|
m_rx->amplitudeResampled.resize(m_needResampling ? 8*m_samplesPerFrame : m_samplesPerFrame); // min input sampling rate is 0.125*m_sampleRate
|
|
m_rx->amplitudeTmp.resize(m_needResampling ? 8*m_samplesPerFrame*m_sampleSizeInp : m_samplesPerFrame*m_sampleSizeInp);
|
|
|
|
m_rx->data.resize(kMaxDataSize);
|
|
|
|
m_rx->protocol = {};
|
|
m_rx->protocolId = GGWAVE_PROTOCOL_COUNT;
|
|
m_rx->protocols = Protocols::rx();
|
|
|
|
if (m_isFixedPayloadLength) {
|
|
if (m_payloadLength > kMaxLengthFixed) {
|
|
ggprintf("Invalid payload legnth: %d, max: %d\n", m_payloadLength, kMaxLengthFixed);
|
|
return;
|
|
}
|
|
|
|
const int totalLength = m_payloadLength + getECCBytesForLength(m_payloadLength);
|
|
const int totalTxs = (totalLength + minBytesPerTx(m_rx->protocols) - 1)/minBytesPerTx(m_rx->protocols);
|
|
|
|
m_rx->spectrumHistoryFixed.resize(totalTxs*maxFramesPerTx(m_rx->protocols, false));
|
|
m_rx->detectedBins.resize(2*totalLength);
|
|
m_rx->detectedTones.resize(2*16*maxBytesPerTx(m_rx->protocols));
|
|
} else {
|
|
// variable payload length
|
|
m_rx->amplitudeRecorded.resize(kMaxRecordedFrames*m_samplesPerFrame);
|
|
m_rx->amplitudeAverage.resize(m_samplesPerFrame);
|
|
m_rx->amplitudeHistory.resize(kMaxSpectrumHistory);
|
|
}
|
|
|
|
for (auto & s : m_rx->amplitudeHistory) {
|
|
s.resize(m_samplesPerFrame);
|
|
}
|
|
|
|
for (auto & s : m_rx->spectrumHistoryFixed) {
|
|
s.resize(m_samplesPerFrame);
|
|
}
|
|
}
|
|
|
|
if (m_isTxEnabled) {
|
|
m_tx = new Tx();
|
|
|
|
m_tx->protocols = Protocols::tx();
|
|
|
|
const int maxDataBits = 2*16*maxBytesPerTx(m_tx->protocols);
|
|
|
|
m_tx->data.resize(kMaxDataSize);
|
|
m_tx->dataBits.resize(maxDataBits);
|
|
|
|
if (m_txOnlyTones == false) {
|
|
m_tx->phaseOffsets.resize(maxDataBits);
|
|
m_tx->bit0Amplitude.resize(maxDataBits);
|
|
for (auto & a : m_tx->bit0Amplitude) {
|
|
a.resize(m_samplesPerFrame);
|
|
}
|
|
m_tx->bit1Amplitude.resize(maxDataBits);
|
|
for (auto & a : m_tx->bit1Amplitude) {
|
|
a.resize(m_samplesPerFrame);
|
|
}
|
|
|
|
m_tx->output.resize(m_samplesPerFrame);
|
|
m_tx->outputResampled.resize(2*m_samplesPerFrame);
|
|
m_tx->outputTmp.resize(kMaxRecordedFrames*m_samplesPerFrame*m_sampleSizeOut);
|
|
m_tx->outputI16.resize(kMaxRecordedFrames*m_samplesPerFrame);
|
|
}
|
|
|
|
// TODO
|
|
// m_tx->tones;
|
|
}
|
|
|
|
// pre-allocate Reed-Solomon memory buffers
|
|
{
|
|
const auto maxLength = m_isFixedPayloadLength ? m_payloadLength : kMaxLengthVariable;
|
|
|
|
if (m_isFixedPayloadLength == false) {
|
|
m_workRSLength.resize(RS::ReedSolomon::getWorkSize_bytes(1, m_encodedDataOffset - 1));
|
|
}
|
|
m_workRSData.resize(RS::ReedSolomon::getWorkSize_bytes(maxLength, getECCBytesForLength(maxLength)));
|
|
}
|
|
|
|
if (m_needResampling) {
|
|
m_resampler = new Resampler();
|
|
}
|
|
|
|
if (m_isDSSEnabled) {
|
|
// magic numbers used to XOR the Rx / Tx data
|
|
// this achieves more homogeneous distribution of the sound energy across the spectrum
|
|
m_dssMagic = {
|
|
0x96, 0x9f, 0xb4, 0xaf, 0x1b, 0x91, 0xde, 0xc5, 0x45, 0x75, 0xe8, 0x2e, 0x0f, 0x32, 0x4a, 0x5f,
|
|
0xb4, 0x56, 0x95, 0xcb, 0x7f, 0x6a, 0x54, 0x6a, 0x48, 0xf2, 0x0b, 0x7b, 0xcd, 0xfb, 0x93, 0x6d,
|
|
0x3c, 0x77, 0x5e, 0xc3, 0x33, 0x47, 0xc0, 0xf1, 0x71, 0x32, 0x33, 0x27, 0x35, 0x68, 0x47, 0x1f,
|
|
0x4e, 0xac, 0x23, 0x42, 0x5f, 0x00, 0x37, 0xa4, 0x50, 0x6d, 0x48, 0x24, 0x91, 0x7c, 0xa1, 0x4e,
|
|
};
|
|
}
|
|
|
|
init("", {}, 0);
|
|
}
|
|
|
|
GGWave::~GGWave() {
|
|
if (m_rx) {
|
|
delete m_rx;
|
|
m_rx = nullptr;
|
|
}
|
|
|
|
if (m_tx) {
|
|
delete m_tx;
|
|
m_tx = nullptr;
|
|
}
|
|
|
|
if (m_resampler) {
|
|
delete m_resampler;
|
|
m_resampler = nullptr;
|
|
}
|
|
}
|
|
|
|
void GGWave::setLogFile(FILE * fptr) {
|
|
g_fptr = fptr;
|
|
}
|
|
|
|
const GGWave::Parameters & GGWave::getDefaultParameters() {
|
|
static ggwave_Parameters result {
|
|
-1, // vaiable payload length
|
|
kDefaultSampleRate,
|
|
kDefaultSampleRate,
|
|
kDefaultSampleRate,
|
|
kDefaultSamplesPerFrame,
|
|
kDefaultSoundMarkerThreshold,
|
|
GGWAVE_SAMPLE_FORMAT_F32,
|
|
GGWAVE_SAMPLE_FORMAT_F32,
|
|
(ggwave_OperatingMode) (GGWAVE_OPERATING_MODE_RX | GGWAVE_OPERATING_MODE_TX),
|
|
};
|
|
|
|
return result;
|
|
}
|
|
|
|
bool GGWave::init(const char * text, TxProtocolId protocolId, const int volume) {
|
|
return init(strlen(text), text, protocolId, volume);
|
|
}
|
|
|
|
bool GGWave::init(int dataSize, const char * dataBuffer, TxProtocolId protocolId, const int volume) {
|
|
if (dataSize < 0) {
|
|
ggprintf("Negative data size: %d\n", dataSize);
|
|
return false;
|
|
}
|
|
|
|
// Tx
|
|
if (m_isTxEnabled) {
|
|
const auto maxLength = m_isFixedPayloadLength ? m_payloadLength : kMaxLengthVariable;
|
|
|
|
if (dataSize > maxLength) {
|
|
ggprintf("Truncating data from %d to %d bytes\n", dataSize, maxLength);
|
|
dataSize = maxLength;
|
|
}
|
|
|
|
if (volume < 0 || volume > 100) {
|
|
ggprintf("Invalid volume: %d\n", volume);
|
|
return false;
|
|
}
|
|
|
|
m_tx->hasData = false;
|
|
std::fill(m_tx->data.begin(), m_tx->data.end(), 0);
|
|
std::fill(m_dataEncoded.begin(), m_dataEncoded.end(), 0);
|
|
|
|
if (dataSize > 0) {
|
|
if (protocolId < 0 || protocolId >= m_tx->protocols.size()) {
|
|
ggprintf("Invalid protocol ID: %d\n", protocolId);
|
|
return false;
|
|
}
|
|
|
|
const auto & protocol = m_tx->protocols[protocolId];
|
|
|
|
if (protocol.enabled == false) {
|
|
ggprintf("Protocol %d is not enabled - make sure to enable it before creating the instance\n", protocolId);
|
|
return false;
|
|
}
|
|
|
|
if (protocol.extra == 2 && m_isFixedPayloadLength == false) {
|
|
ggprintf("Mono-tone protocols with variable length are not supported\n");
|
|
return false;
|
|
}
|
|
|
|
m_tx->protocol = protocol;
|
|
m_tx->dataLength = m_isFixedPayloadLength ? m_payloadLength : dataSize;
|
|
m_tx->sendVolume = ((double)(volume))/100.0f;
|
|
|
|
m_tx->data[0] = m_tx->dataLength;
|
|
for (int i = 0; i < m_tx->dataLength; ++i) {
|
|
m_tx->data[i + 1] = i < dataSize ? dataBuffer[i] : 0;
|
|
if (m_isDSSEnabled) {
|
|
m_tx->data[i + 1] ^= m_dssMagic[i%m_dssMagic.size()];
|
|
}
|
|
}
|
|
|
|
m_tx->hasData = true;
|
|
}
|
|
} else {
|
|
if (dataSize > 0) {
|
|
ggprintf("Tx is disabled - cannot transmit data with this GGWave instance\n");
|
|
}
|
|
}
|
|
|
|
// Rx
|
|
if (m_isRxEnabled) {
|
|
m_rx->receiving = false;
|
|
m_rx->analyzing = false;
|
|
|
|
m_rx->framesToAnalyze = 0;
|
|
m_rx->framesLeftToAnalyze = 0;
|
|
m_rx->framesToRecord = 0;
|
|
m_rx->framesLeftToRecord = 0;
|
|
|
|
std::fill(m_rx->spectrum.begin(), m_rx->spectrum.end(), 0);
|
|
std::fill(m_rx->amplitude.begin(), m_rx->amplitude.end(), 0);
|
|
for (auto & s : m_rx->amplitudeHistory) {
|
|
std::fill(s.begin(), s.end(), 0);
|
|
}
|
|
|
|
std::fill(m_rx->data.begin(), m_rx->data.end(), 0);
|
|
|
|
for (auto & s : m_rx->spectrumHistoryFixed) {
|
|
std::fill(s.begin(), s.end(), 0);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
uint32_t GGWave::encodeSize_bytes() const {
|
|
return encodeSize_samples()*m_sampleSizeOut;
|
|
}
|
|
|
|
uint32_t GGWave::encodeSize_samples() const {
|
|
if (m_tx->hasData == false) {
|
|
return 0;
|
|
}
|
|
|
|
float factor = 1.0f;
|
|
int samplesPerFrameOut = m_samplesPerFrame;
|
|
if (m_sampleRateOut != m_sampleRate) {
|
|
factor = m_sampleRate/m_sampleRateOut;
|
|
// note : +1 extra sample in order to overestimate the buffer size
|
|
samplesPerFrameOut = m_resampler->resample(factor, m_samplesPerFrame, m_tx->output.data(), nullptr) + 1;
|
|
}
|
|
const int nECCBytesPerTx = getECCBytesForLength(m_tx->dataLength);
|
|
const int sendDataLength = m_tx->dataLength + m_encodedDataOffset;
|
|
const int totalBytes = sendDataLength + nECCBytesPerTx;
|
|
const int totalDataFrames = m_tx->protocol.extra*((totalBytes + m_tx->protocol.bytesPerTx - 1)/m_tx->protocol.bytesPerTx)*m_tx->protocol.framesPerTx;
|
|
|
|
return (
|
|
m_nMarkerFrames + totalDataFrames + m_nMarkerFrames
|
|
)*samplesPerFrameOut;
|
|
}
|
|
|
|
uint32_t GGWave::encode() {
|
|
if (m_isTxEnabled == false) {
|
|
ggprintf("Tx is disabled - cannot transmit data with this GGWave instance\n");
|
|
return 0;
|
|
}
|
|
|
|
if (m_resampler) {
|
|
m_resampler->reset();
|
|
}
|
|
|
|
const int nECCBytesPerTx = getECCBytesForLength(m_tx->dataLength);
|
|
const int sendDataLength = m_tx->dataLength + m_encodedDataOffset;
|
|
const int totalBytes = sendDataLength + nECCBytesPerTx;
|
|
const int totalDataFrames = m_tx->protocol.extra*((totalBytes + m_tx->protocol.bytesPerTx - 1)/m_tx->protocol.bytesPerTx)*m_tx->protocol.framesPerTx;
|
|
|
|
if (m_isFixedPayloadLength == false) {
|
|
RS::ReedSolomon rsLength(1, m_encodedDataOffset - 1, m_workRSLength.data());
|
|
rsLength.Encode(m_tx->data.data(), m_dataEncoded.data());
|
|
}
|
|
|
|
// first byte of m_tx->data contains the length of the payload, so we skip it:
|
|
RS::ReedSolomon rsData = RS::ReedSolomon(m_tx->dataLength, nECCBytesPerTx, m_workRSData.data());
|
|
rsData.Encode(m_tx->data.data() + 1, m_dataEncoded.data() + m_encodedDataOffset);
|
|
|
|
// generate tones
|
|
{
|
|
int frameId = 0;
|
|
bool hasData = m_tx->hasData;
|
|
|
|
m_tx->tones.clear();
|
|
while (hasData) {
|
|
m_tx->tones.push_back({});
|
|
|
|
if (frameId < m_nMarkerFrames) {
|
|
for (int i = 0; i < m_nBitsInMarker; ++i) {
|
|
m_tx->tones.back().push_back({});
|
|
m_tx->tones.back().back().duration_ms = (1000.0*m_samplesPerFrame)/m_sampleRate;
|
|
if (i%2 == 0) {
|
|
m_tx->tones.back().back().freq_hz = bitFreq(m_tx->protocol, i);
|
|
} else {
|
|
m_tx->tones.back().back().freq_hz = bitFreq(m_tx->protocol, i) + m_hzPerSample;
|
|
}
|
|
}
|
|
} else if (frameId < m_nMarkerFrames + totalDataFrames) {
|
|
int dataOffset = frameId - m_nMarkerFrames;
|
|
dataOffset /= m_tx->protocol.framesPerTx;
|
|
dataOffset *= m_tx->protocol.bytesPerTx;
|
|
|
|
std::fill(m_tx->dataBits.begin(), m_tx->dataBits.end(), 0);
|
|
|
|
for (int j = 0; j < m_tx->protocol.bytesPerTx; ++j) {
|
|
if (m_tx->protocol.extra == 1) {
|
|
{
|
|
uint8_t d = m_dataEncoded[dataOffset + j] & 15;
|
|
m_tx->dataBits[(2*j + 0)*16 + d] = 1;
|
|
}
|
|
{
|
|
uint8_t d = m_dataEncoded[dataOffset + j] & 240;
|
|
m_tx->dataBits[(2*j + 1)*16 + (d >> 4)] = 1;
|
|
}
|
|
} else {
|
|
if (dataOffset % m_tx->protocol.extra == 0) {
|
|
uint8_t d = m_dataEncoded[dataOffset/m_tx->protocol.extra + j] & 15;
|
|
m_tx->dataBits[(2*j + 0)*16 + d] = 1;
|
|
} else {
|
|
uint8_t d = m_dataEncoded[dataOffset/m_tx->protocol.extra + j] & 240;
|
|
m_tx->dataBits[(2*j + 0)*16 + (d >> 4)] = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int k = 0; k < 2*m_tx->protocol.bytesPerTx*16; ++k) {
|
|
if (m_tx->dataBits[k] == 0) continue;
|
|
|
|
m_tx->tones.back().push_back({});
|
|
m_tx->tones.back().back().duration_ms = (1000.0*m_samplesPerFrame)/m_sampleRate;
|
|
if (k%2) {
|
|
m_tx->tones.back().back().freq_hz = bitFreq(m_tx->protocol, k/2) + m_hzPerSample;
|
|
} else {
|
|
m_tx->tones.back().back().freq_hz = bitFreq(m_tx->protocol, k/2);
|
|
}
|
|
}
|
|
} else if (frameId < m_nMarkerFrames + totalDataFrames + m_nMarkerFrames) {
|
|
for (int i = 0; i < m_nBitsInMarker; ++i) {
|
|
m_tx->tones.back().push_back({});
|
|
m_tx->tones.back().back().duration_ms = (1000.0*m_samplesPerFrame)/m_sampleRate;
|
|
if (i%2 == 0) {
|
|
m_tx->tones.back().back().freq_hz = bitFreq(m_tx->protocol, i) + m_hzPerSample;
|
|
} else {
|
|
m_tx->tones.back().back().freq_hz = bitFreq(m_tx->protocol, i);
|
|
}
|
|
}
|
|
} else {
|
|
hasData = false;
|
|
break;
|
|
}
|
|
|
|
++frameId;
|
|
}
|
|
|
|
if (m_txOnlyTones) {
|
|
m_tx->hasData = false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// compute Tx data
|
|
{
|
|
for (int k = 0; k < (int) m_tx->phaseOffsets.size(); ++k) {
|
|
m_tx->phaseOffsets[k] = (M_PI*k)/(m_tx->protocol.nDataBitsPerTx());
|
|
}
|
|
|
|
// note : what is the purpose of this shuffle ? I forgot .. :(
|
|
//std::random_device rd;
|
|
//std::mt19937 g(rd());
|
|
|
|
//std::shuffle(phaseOffsets.begin(), phaseOffsets.end(), g);
|
|
|
|
for (int k = 0; k < (int) m_tx->dataBits.size(); ++k) {
|
|
const double freq = bitFreq(m_tx->protocol, k);
|
|
|
|
const double phaseOffset = m_tx->phaseOffsets[k];
|
|
const double curHzPerSample = m_hzPerSample;
|
|
const double curIHzPerSample = 1.0/curHzPerSample;
|
|
|
|
for (int i = 0; i < m_samplesPerFrame; i++) {
|
|
const double curi = i;
|
|
m_tx->bit1Amplitude[k][i] = std::sin((2.0*M_PI)*(curi*m_isamplesPerFrame)*(freq*curIHzPerSample) + phaseOffset);
|
|
}
|
|
|
|
for (int i = 0; i < m_samplesPerFrame; i++) {
|
|
const double curi = i;
|
|
m_tx->bit0Amplitude[k][i] = std::sin((2.0*M_PI)*(curi*m_isamplesPerFrame)*((freq + m_hzPerSample*m_freqDelta_bin)*curIHzPerSample) + phaseOffset);
|
|
}
|
|
}
|
|
}
|
|
|
|
int frameId = 0;
|
|
uint32_t offset = 0;
|
|
const float factor = m_sampleRate/m_sampleRateOut;
|
|
|
|
while (m_tx->hasData) {
|
|
std::fill(m_tx->output.begin(), m_tx->output.end(), 0.0f);
|
|
|
|
uint16_t nFreq = 0;
|
|
if (frameId < m_nMarkerFrames) {
|
|
nFreq = m_nBitsInMarker;
|
|
|
|
for (int i = 0; i < m_nBitsInMarker; ++i) {
|
|
if (i%2 == 0) {
|
|
::addAmplitudeSmooth(m_tx->bit1Amplitude[i], m_tx->output, m_tx->sendVolume, 0, m_samplesPerFrame, frameId, m_nMarkerFrames);
|
|
} else {
|
|
::addAmplitudeSmooth(m_tx->bit0Amplitude[i], m_tx->output, m_tx->sendVolume, 0, m_samplesPerFrame, frameId, m_nMarkerFrames);
|
|
}
|
|
}
|
|
} else if (frameId < m_nMarkerFrames + totalDataFrames) {
|
|
int dataOffset = frameId - m_nMarkerFrames;
|
|
int cycleModMain = dataOffset%m_tx->protocol.framesPerTx;
|
|
dataOffset /= m_tx->protocol.framesPerTx;
|
|
dataOffset *= m_tx->protocol.bytesPerTx;
|
|
|
|
std::fill(m_tx->dataBits.begin(), m_tx->dataBits.end(), 0);
|
|
|
|
for (int j = 0; j < m_tx->protocol.bytesPerTx; ++j) {
|
|
if (m_tx->protocol.extra == 1) {
|
|
{
|
|
uint8_t d = m_dataEncoded[dataOffset + j] & 15;
|
|
m_tx->dataBits[(2*j + 0)*16 + d] = 1;
|
|
}
|
|
{
|
|
uint8_t d = m_dataEncoded[dataOffset + j] & 240;
|
|
m_tx->dataBits[(2*j + 1)*16 + (d >> 4)] = 1;
|
|
}
|
|
} else {
|
|
if (dataOffset % m_tx->protocol.extra == 0) {
|
|
uint8_t d = m_dataEncoded[dataOffset/m_tx->protocol.extra + j] & 15;
|
|
m_tx->dataBits[(2*j + 0)*16 + d] = 1;
|
|
} else {
|
|
uint8_t d = m_dataEncoded[dataOffset/m_tx->protocol.extra + j] & 240;
|
|
m_tx->dataBits[(2*j + 0)*16 + (d >> 4)] = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int k = 0; k < 2*m_tx->protocol.bytesPerTx*16; ++k) {
|
|
if (m_tx->dataBits[k] == 0) continue;
|
|
|
|
++nFreq;
|
|
if (k%2) {
|
|
::addAmplitudeSmooth(m_tx->bit0Amplitude[k/2], m_tx->output, m_tx->sendVolume, 0, m_samplesPerFrame, cycleModMain, m_tx->protocol.framesPerTx);
|
|
} else {
|
|
::addAmplitudeSmooth(m_tx->bit1Amplitude[k/2], m_tx->output, m_tx->sendVolume, 0, m_samplesPerFrame, cycleModMain, m_tx->protocol.framesPerTx);
|
|
}
|
|
}
|
|
} else if (frameId < m_nMarkerFrames + totalDataFrames + m_nMarkerFrames) {
|
|
nFreq = m_nBitsInMarker;
|
|
|
|
const int fId = frameId - (m_nMarkerFrames + totalDataFrames);
|
|
for (int i = 0; i < m_nBitsInMarker; ++i) {
|
|
if (i%2 == 0) {
|
|
addAmplitudeSmooth(m_tx->bit0Amplitude[i], m_tx->output, m_tx->sendVolume, 0, m_samplesPerFrame, fId, m_nMarkerFrames);
|
|
} else {
|
|
addAmplitudeSmooth(m_tx->bit1Amplitude[i], m_tx->output, m_tx->sendVolume, 0, m_samplesPerFrame, fId, m_nMarkerFrames);
|
|
}
|
|
}
|
|
} else {
|
|
m_tx->hasData = false;
|
|
break;
|
|
}
|
|
|
|
if (nFreq == 0) nFreq = 1;
|
|
const float scale = 1.0f/nFreq;
|
|
for (int i = 0; i < m_samplesPerFrame; ++i) {
|
|
m_tx->output[i] *= scale;
|
|
}
|
|
|
|
int samplesPerFrameOut = m_samplesPerFrame;
|
|
if (m_sampleRateOut != m_sampleRate) {
|
|
samplesPerFrameOut = m_resampler->resample(factor, m_samplesPerFrame, m_tx->output.data(), m_tx->outputResampled.data());
|
|
} else {
|
|
m_tx->outputResampled = m_tx->output;
|
|
}
|
|
|
|
// default output is in 16-bit signed int so we always compute it
|
|
for (int i = 0; i < samplesPerFrameOut; ++i) {
|
|
m_tx->outputI16[offset + i] = 32768*m_tx->outputResampled[i];
|
|
}
|
|
|
|
// convert from 32-bit float
|
|
switch (m_sampleFormatOut) {
|
|
case GGWAVE_SAMPLE_FORMAT_UNDEFINED: break;
|
|
case GGWAVE_SAMPLE_FORMAT_U8:
|
|
{
|
|
auto p = reinterpret_cast<uint8_t *>(m_tx->outputTmp.data());
|
|
for (int i = 0; i < samplesPerFrameOut; ++i) {
|
|
p[offset + i] = 128*(m_tx->outputResampled[i] + 1.0f);
|
|
}
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_I8:
|
|
{
|
|
auto p = reinterpret_cast<uint8_t *>(m_tx->outputTmp.data());
|
|
for (int i = 0; i < samplesPerFrameOut; ++i) {
|
|
p[offset + i] = 128*m_tx->outputResampled[i];
|
|
}
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_U16:
|
|
{
|
|
auto p = reinterpret_cast<uint16_t *>(m_tx->outputTmp.data());
|
|
for (int i = 0; i < samplesPerFrameOut; ++i) {
|
|
p[offset + i] = 32768*(m_tx->outputResampled[i] + 1.0f);
|
|
}
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_I16:
|
|
{
|
|
// skip because we already have the data in m_tx->outputI16
|
|
//auto p = reinterpret_cast<uint16_t *>(m_tx->outputTmp.data());
|
|
//for (int i = 0; i < samplesPerFrameOut; ++i) {
|
|
// p[offset + i] = 32768*m_tx->outputResampled[i];
|
|
//}
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_F32:
|
|
{
|
|
auto p = reinterpret_cast<float *>(m_tx->outputTmp.data());
|
|
for (int i = 0; i < samplesPerFrameOut; ++i) {
|
|
p[offset + i] = m_tx->outputResampled[i];
|
|
}
|
|
} break;
|
|
}
|
|
|
|
++frameId;
|
|
offset += samplesPerFrameOut;
|
|
}
|
|
|
|
m_tx->lastAmplitudeSize = offset;
|
|
|
|
// the encoded waveform can be accessed via the txData() method
|
|
// we return the size of the waveform in bytes:
|
|
return offset*m_sampleSizeOut;
|
|
}
|
|
|
|
const void * GGWave::txData() const {
|
|
if (m_tx == nullptr) {
|
|
ggprintf("Tx is disabled - cannot transmit data with this GGWave instance\n");
|
|
return nullptr;
|
|
}
|
|
|
|
switch (m_sampleFormatOut) {
|
|
case GGWAVE_SAMPLE_FORMAT_UNDEFINED: break;
|
|
case GGWAVE_SAMPLE_FORMAT_I16:
|
|
{
|
|
return m_tx->outputI16.data();
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_U8:
|
|
case GGWAVE_SAMPLE_FORMAT_I8:
|
|
case GGWAVE_SAMPLE_FORMAT_U16:
|
|
case GGWAVE_SAMPLE_FORMAT_F32:
|
|
{
|
|
return m_tx->outputTmp.data();
|
|
} break;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
bool GGWave::decode(const void * data, uint32_t nBytes) {
|
|
if (m_isRxEnabled == false) {
|
|
ggprintf("Rx is disabled - cannot receive data with this GGWave instance\n");
|
|
return false;
|
|
}
|
|
|
|
if (m_tx && m_tx->hasData) {
|
|
ggprintf("Cannot decode while transmitting\n");
|
|
return false;
|
|
}
|
|
|
|
auto dataBuffer = (uint8_t *) data;
|
|
const float factor = m_sampleRateInp/m_sampleRate;
|
|
|
|
while (true) {
|
|
// read capture data
|
|
uint32_t nBytesNeeded = m_rx->samplesNeeded*m_sampleSizeInp;
|
|
|
|
if (m_sampleRateInp != m_sampleRate) {
|
|
// note : predict 4 extra samples just to make sure we have enough data
|
|
nBytesNeeded = (m_resampler->resample(1.0f/factor, m_rx->samplesNeeded, m_rx->amplitudeResampled.data(), nullptr) + 4)*m_sampleSizeInp;
|
|
}
|
|
|
|
const uint32_t nBytesRecorded = std::min(nBytes, nBytesNeeded);
|
|
|
|
if (nBytesRecorded == 0) {
|
|
break;
|
|
}
|
|
|
|
switch (m_sampleFormatInp) {
|
|
case GGWAVE_SAMPLE_FORMAT_UNDEFINED: break;
|
|
case GGWAVE_SAMPLE_FORMAT_U8:
|
|
case GGWAVE_SAMPLE_FORMAT_I8:
|
|
case GGWAVE_SAMPLE_FORMAT_U16:
|
|
case GGWAVE_SAMPLE_FORMAT_I16:
|
|
{
|
|
std::copy(dataBuffer, dataBuffer + nBytesRecorded, m_rx->amplitudeTmp.data());
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_F32:
|
|
{
|
|
std::copy(dataBuffer, dataBuffer + nBytesRecorded, (uint8_t *) m_rx->amplitudeResampled.data());
|
|
} break;
|
|
}
|
|
|
|
dataBuffer += nBytesRecorded;
|
|
nBytes -= nBytesRecorded;
|
|
|
|
if (nBytesRecorded % m_sampleSizeInp != 0) {
|
|
ggprintf("Failure during capture - provided bytes (%d) are not multiple of sample size (%d)\n",
|
|
nBytesRecorded, m_sampleSizeInp);
|
|
m_rx->samplesNeeded = m_samplesPerFrame;
|
|
break;
|
|
}
|
|
|
|
// convert to 32-bit float
|
|
int nSamplesRecorded = nBytesRecorded/m_sampleSizeInp;
|
|
switch (m_sampleFormatInp) {
|
|
case GGWAVE_SAMPLE_FORMAT_UNDEFINED: break;
|
|
case GGWAVE_SAMPLE_FORMAT_U8:
|
|
{
|
|
constexpr float scale = 1.0f/128;
|
|
auto p = reinterpret_cast<uint8_t *>(m_rx->amplitudeTmp.data());
|
|
for (int i = 0; i < nSamplesRecorded; ++i) {
|
|
m_rx->amplitudeResampled[i] = float(int16_t(*(p + i)) - 128)*scale;
|
|
}
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_I8:
|
|
{
|
|
constexpr float scale = 1.0f/128;
|
|
auto p = reinterpret_cast<int8_t *>(m_rx->amplitudeTmp.data());
|
|
for (int i = 0; i < nSamplesRecorded; ++i) {
|
|
m_rx->amplitudeResampled[i] = float(*(p + i))*scale;
|
|
}
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_U16:
|
|
{
|
|
constexpr float scale = 1.0f/32768;
|
|
auto p = reinterpret_cast<uint16_t *>(m_rx->amplitudeTmp.data());
|
|
for (int i = 0; i < nSamplesRecorded; ++i) {
|
|
m_rx->amplitudeResampled[i] = float(int32_t(*(p + i)) - 32768)*scale;
|
|
}
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_I16:
|
|
{
|
|
constexpr float scale = 1.0f/32768;
|
|
auto p = reinterpret_cast<int16_t *>(m_rx->amplitudeTmp.data());
|
|
for (int i = 0; i < nSamplesRecorded; ++i) {
|
|
m_rx->amplitudeResampled[i] = float(*(p + i))*scale;
|
|
}
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_F32: break;
|
|
}
|
|
|
|
uint32_t offset = m_samplesPerFrame - m_rx->samplesNeeded;
|
|
|
|
if (m_sampleRateInp != m_sampleRate) {
|
|
if (nSamplesRecorded <= 2*Resampler::kWidth) {
|
|
m_rx->samplesNeeded = m_samplesPerFrame;
|
|
break;
|
|
}
|
|
|
|
// reset resampler state every minute
|
|
if (!m_rx->receiving && m_resampler->nSamplesTotal() > 60.0f*factor*m_sampleRate) {
|
|
m_resampler->reset();
|
|
}
|
|
|
|
int nSamplesResampled = offset + m_resampler->resample(factor, nSamplesRecorded, m_rx->amplitudeResampled.data(), m_rx->amplitude.data() + offset);
|
|
nSamplesRecorded = nSamplesResampled;
|
|
} else {
|
|
for (int i = 0; i < nSamplesRecorded; ++i) {
|
|
m_rx->amplitude[offset + i] = m_rx->amplitudeResampled[i];
|
|
}
|
|
}
|
|
|
|
// we have enough bytes to do analysis
|
|
if (nSamplesRecorded >= m_samplesPerFrame) {
|
|
m_rx->hasNewAmplitude = true;
|
|
|
|
if (m_isFixedPayloadLength) {
|
|
decode_fixed();
|
|
} else {
|
|
decode_variable();
|
|
}
|
|
|
|
int nExtraSamples = nSamplesRecorded - m_samplesPerFrame;
|
|
for (int i = 0; i < nExtraSamples; ++i) {
|
|
m_rx->amplitude[i] = m_rx->amplitude[m_samplesPerFrame + i];
|
|
}
|
|
|
|
m_rx->samplesNeeded = m_samplesPerFrame - nExtraSamples;
|
|
} else {
|
|
m_rx->samplesNeeded = m_samplesPerFrame - nSamplesRecorded;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// instance state
|
|
//
|
|
|
|
bool GGWave::isDSSEnabled() const { return m_isDSSEnabled; }
|
|
|
|
int GGWave::samplesPerFrame() const { return m_samplesPerFrame; }
|
|
int GGWave::sampleSizeInp() const { return m_sampleSizeInp; }
|
|
int GGWave::sampleSizeOut() const { return m_sampleSizeOut; }
|
|
|
|
float GGWave::sampleRateInp() const { return m_sampleRateInp; }
|
|
float GGWave::sampleRateOut() const { return m_sampleRateOut; }
|
|
GGWave::SampleFormat GGWave::sampleFormatInp() const { return m_sampleFormatInp; }
|
|
GGWave::SampleFormat GGWave::sampleFormatOut() const { return m_sampleFormatOut; }
|
|
|
|
//
|
|
// Tx
|
|
//
|
|
|
|
const GGWave::Tones & GGWave::txTones() const { return m_tx->tones; }
|
|
|
|
bool GGWave::txHasData() const { return m_tx && m_tx->hasData; }
|
|
|
|
bool GGWave::txTakeAmplitudeI16(AmplitudeI16 & dst) {
|
|
if (m_tx->lastAmplitudeSize == 0) return false;
|
|
|
|
if ((int) dst.size() < m_tx->lastAmplitudeSize) {
|
|
dst.resize(m_tx->lastAmplitudeSize);
|
|
}
|
|
std::copy(m_tx->outputI16.begin(), m_tx->outputI16.begin() + m_tx->lastAmplitudeSize, dst.begin());
|
|
m_tx->lastAmplitudeSize = 0;
|
|
|
|
return true;
|
|
}
|
|
|
|
const GGWave::RxProtocols & GGWave::txProtocols() const { return m_tx->protocols; }
|
|
|
|
//
|
|
// Rx
|
|
//
|
|
|
|
bool GGWave::rxReceiving() const { return m_rx->receiving; }
|
|
bool GGWave::rxAnalyzing() const { return m_rx->analyzing; }
|
|
|
|
int GGWave::rxSamplesNeeded() const { return m_rx->samplesNeeded; }
|
|
int GGWave::rxFramesToRecord() const { return m_rx->framesToRecord; }
|
|
int GGWave::rxFramesLeftToRecord() const { return m_rx->framesLeftToRecord; }
|
|
int GGWave::rxFramesToAnalyze() const { return m_rx->framesToAnalyze; }
|
|
int GGWave::rxFramesLeftToAnalyze() const { return m_rx->framesLeftToAnalyze; }
|
|
|
|
bool GGWave::rxStopReceiving() {
|
|
if (m_rx->receiving == false) {
|
|
return false;
|
|
}
|
|
|
|
m_rx->receiving = false;
|
|
|
|
return true;
|
|
}
|
|
|
|
GGWave::RxProtocols & GGWave::rxProtocols() { return m_rx->protocols; }
|
|
|
|
int GGWave::rxDataLength() const { return m_rx->dataLength; }
|
|
|
|
const GGWave::TxRxData & GGWave::rxData() const { return m_rx->data; }
|
|
const GGWave::RxProtocol & GGWave::rxProtocol() const { return m_rx->protocol; }
|
|
const GGWave::RxProtocolId & GGWave::rxProtocolId() const { return m_rx->protocolId; }
|
|
const GGWave::Spectrum & GGWave::rxSpectrum() const { return m_rx->spectrum; }
|
|
const GGWave::Amplitude & GGWave::rxAmplitude() const { return m_rx->amplitude; }
|
|
|
|
int GGWave::rxTakeData(TxRxData & dst) {
|
|
if (m_rx->dataLength == 0) return 0;
|
|
|
|
auto res = m_rx->dataLength;
|
|
m_rx->dataLength = 0;
|
|
|
|
if (res != -1) {
|
|
dst = m_rx->data;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
bool GGWave::rxTakeSpectrum(Spectrum & dst) {
|
|
if (m_rx->hasNewSpectrum == false) return false;
|
|
|
|
m_rx->hasNewSpectrum = false;
|
|
dst = m_rx->spectrum;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool GGWave::rxTakeAmplitude(Amplitude & dst) {
|
|
if (m_rx->hasNewAmplitude == false) return false;
|
|
|
|
m_rx->hasNewAmplitude = false;
|
|
dst = m_rx->amplitude;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool GGWave::computeFFTR(const float * src, float * dst, int N) {
|
|
if (N != m_samplesPerFrame) {
|
|
ggprintf("computeFFTR: N (%d) must be equal to 'samplesPerFrame' %d\n", N, m_samplesPerFrame);
|
|
return false;
|
|
}
|
|
|
|
FFT(src, dst, N, m_rx->fftWorkI.data(), m_rx->fftWorkF.data());
|
|
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// GGWave::Resampler
|
|
//
|
|
|
|
GGWave::Resampler::Resampler() :
|
|
m_sincTable(kWidth*kSamplesPerZeroCrossing),
|
|
m_delayBuffer(3*kWidth),
|
|
m_edgeSamples(kWidth),
|
|
m_samplesInp(2048) {
|
|
makeSinc();
|
|
reset();
|
|
}
|
|
|
|
void GGWave::Resampler::reset() {
|
|
m_state = {};
|
|
std::fill(m_edgeSamples.begin(), m_edgeSamples.end(), 0.0f);
|
|
std::fill(m_delayBuffer.begin(), m_delayBuffer.end(), 0.0f);
|
|
std::fill(m_samplesInp.begin(), m_samplesInp.end(), 0.0f);
|
|
}
|
|
|
|
int GGWave::Resampler::resample(
|
|
float factor,
|
|
int nSamples,
|
|
const float * samplesInp,
|
|
float * samplesOut) {
|
|
int idxInp = -1;
|
|
int idxOut = 0;
|
|
int notDone = 1;
|
|
float data_in = 0.0f;
|
|
float data_out = 0.0f;
|
|
double one_over_factor = 1.0;
|
|
|
|
auto stateSave = m_state;
|
|
|
|
m_state.nSamplesTotal += nSamples;
|
|
|
|
if (samplesOut) {
|
|
assert(nSamples > kWidth);
|
|
if ((int) m_samplesInp.size() < nSamples + kWidth) {
|
|
m_samplesInp.resize(nSamples + kWidth);
|
|
}
|
|
for (int i = 0; i < kWidth; ++i) {
|
|
m_samplesInp[i] = m_edgeSamples[i];
|
|
m_edgeSamples[i] = samplesInp[nSamples - kWidth + i];
|
|
}
|
|
for (int i = 0; i < nSamples; ++i) {
|
|
m_samplesInp[i + kWidth] = samplesInp[i];
|
|
}
|
|
samplesInp = m_samplesInp.data();
|
|
}
|
|
|
|
while (notDone) {
|
|
while (m_state.timeLast < m_state.timeInt) {
|
|
if (++idxInp >= nSamples) {
|
|
notDone = 0;
|
|
break;
|
|
} else {
|
|
data_in = samplesInp[idxInp];
|
|
}
|
|
//printf("xxxx idxInp = %d\n", idxInp);
|
|
if (samplesOut) newData(data_in);
|
|
m_state.timeLast += 1;
|
|
}
|
|
|
|
if (notDone == false) break;
|
|
|
|
double temp1 = 0.0;
|
|
int left_limit = m_state.timeNow - kWidth + 1; /* leftmost neighboring sample used for interp.*/
|
|
int right_limit = m_state.timeNow + kWidth; /* rightmost leftmost neighboring sample used for interp.*/
|
|
if (left_limit < 0) left_limit = 0;
|
|
if (right_limit > m_state.nSamplesTotal + kWidth) right_limit = m_state.nSamplesTotal + kWidth;
|
|
if (factor < 1.0) {
|
|
for (int j = left_limit; j < right_limit; j++) {
|
|
temp1 += getData(j - m_state.timeInt)*sinc(m_state.timeNow - (double) j);
|
|
}
|
|
data_out = temp1;
|
|
}
|
|
else {
|
|
one_over_factor = 1.0 / factor;
|
|
for (int j = left_limit; j < right_limit; j++) {
|
|
temp1 += getData(j - m_state.timeInt)*one_over_factor*sinc(one_over_factor*(m_state.timeNow - (double) j));
|
|
}
|
|
data_out = temp1;
|
|
}
|
|
|
|
if (samplesOut) {
|
|
//printf("inp = %d, l = %d, r = %d, n = %d, a = %d, b = %d\n", idxInp, left_limit, right_limit, m_state.nSamplesTotal, left_limit - m_state.timeInt, right_limit - m_state.timeInt - 1);
|
|
samplesOut[idxOut] = data_out;
|
|
}
|
|
++idxOut;
|
|
|
|
m_state.timeNow += factor;
|
|
m_state.timeLast = m_state.timeInt;
|
|
m_state.timeInt = m_state.timeNow;
|
|
while (m_state.timeLast < m_state.timeInt) {
|
|
if (++idxInp >= nSamples) {
|
|
notDone = 0;
|
|
break;
|
|
} else {
|
|
data_in = samplesInp[idxInp];
|
|
}
|
|
if (samplesOut) newData(data_in);
|
|
m_state.timeLast += 1;
|
|
}
|
|
//printf("last idxInp = %d, nSamples = %d\n", idxInp, nSamples);
|
|
}
|
|
|
|
if (samplesOut == nullptr) {
|
|
m_state = stateSave;
|
|
}
|
|
|
|
return idxOut;
|
|
}
|
|
|
|
float GGWave::Resampler::getData(int j) const {
|
|
return m_delayBuffer[(int) j + kWidth];
|
|
}
|
|
|
|
void GGWave::Resampler::newData(float data) {
|
|
for (int i = 0; i < kDelaySize - 5; i++) {
|
|
m_delayBuffer[i] = m_delayBuffer[i + 1];
|
|
}
|
|
m_delayBuffer[kDelaySize - 5] = data;
|
|
}
|
|
|
|
void GGWave::Resampler::makeSinc() {
|
|
double temp, win_freq, win;
|
|
win_freq = M_PI/kWidth/kSamplesPerZeroCrossing;
|
|
m_sincTable[0] = 1.0;
|
|
for (int i = 1; i < kWidth*kSamplesPerZeroCrossing; i++) {
|
|
temp = (double) i*M_PI/kSamplesPerZeroCrossing;
|
|
m_sincTable[i] = sin(temp)/temp;
|
|
win = 0.5 + 0.5*cos(win_freq*i);
|
|
m_sincTable[i] *= win;
|
|
}
|
|
}
|
|
|
|
double GGWave::Resampler::sinc(double x) const {
|
|
int low;
|
|
double temp, delta;
|
|
if (fabs(x) >= kWidth - 1) {
|
|
return 0.0;
|
|
} else {
|
|
temp = fabs(x)*(double) kSamplesPerZeroCrossing;
|
|
low = temp; /* these are interpolation steps */
|
|
delta = temp - low; /* and can be ommited if desired */
|
|
return linear_interp(m_sincTable[low], m_sincTable[low + 1], delta);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Variable payload length
|
|
//
|
|
|
|
void GGWave::decode_variable() {
|
|
m_rx->amplitudeHistory[m_rx->historyId] = m_rx->amplitude;
|
|
|
|
if (++m_rx->historyId >= kMaxSpectrumHistory) {
|
|
m_rx->historyId = 0;
|
|
}
|
|
|
|
if (m_rx->historyId == 0 || m_rx->receiving) {
|
|
m_rx->hasNewSpectrum = true;
|
|
|
|
std::fill(m_rx->amplitudeAverage.begin(), m_rx->amplitudeAverage.end(), 0.0f);
|
|
for (auto & s : m_rx->amplitudeHistory) {
|
|
for (int i = 0; i < m_samplesPerFrame; ++i) {
|
|
m_rx->amplitudeAverage[i] += s[i];
|
|
}
|
|
}
|
|
|
|
float norm = 1.0f/kMaxSpectrumHistory;
|
|
for (int i = 0; i < m_samplesPerFrame; ++i) {
|
|
m_rx->amplitudeAverage[i] *= norm;
|
|
}
|
|
|
|
// calculate spectrum
|
|
FFT(m_rx->amplitudeAverage.data(), m_rx->fftOut.data(), m_samplesPerFrame, m_rx->fftWorkI.data(), m_rx->fftWorkF.data());
|
|
|
|
for (int i = 0; i < m_samplesPerFrame; ++i) {
|
|
m_rx->spectrum[i] = (m_rx->fftOut[2*i + 0]*m_rx->fftOut[2*i + 0] + m_rx->fftOut[2*i + 1]*m_rx->fftOut[2*i + 1]);
|
|
}
|
|
for (int i = 1; i < m_samplesPerFrame/2; ++i) {
|
|
m_rx->spectrum[i] += m_rx->spectrum[m_samplesPerFrame - i];
|
|
}
|
|
}
|
|
|
|
if (m_rx->framesLeftToRecord > 0) {
|
|
std::copy(m_rx->amplitude.begin(),
|
|
m_rx->amplitude.begin() + m_samplesPerFrame,
|
|
m_rx->amplitudeRecorded.data() + (m_rx->framesToRecord - m_rx->framesLeftToRecord)*m_samplesPerFrame);
|
|
|
|
if (--m_rx->framesLeftToRecord <= 0) {
|
|
m_rx->analyzing = true;
|
|
}
|
|
}
|
|
|
|
if (m_rx->analyzing) {
|
|
ggprintf("Analyzing captured data ..\n");
|
|
|
|
const int stepsPerFrame = 16;
|
|
const int step = m_samplesPerFrame/stepsPerFrame;
|
|
|
|
bool isValid = false;
|
|
for (int protocolId = 0; protocolId < (int) m_rx->protocols.size(); ++protocolId) {
|
|
const auto & protocol = m_rx->protocols[protocolId];
|
|
if (protocol.enabled == false) {
|
|
continue;
|
|
}
|
|
|
|
// skip Rx protocol if it is mono-tone
|
|
if (protocol.extra == 2) {
|
|
continue;
|
|
}
|
|
|
|
// skip Rx protocol if start frequency is different from detected one
|
|
if (protocol.freqStart != m_rx->markerFreqStart) {
|
|
continue;
|
|
}
|
|
|
|
std::fill(m_rx->spectrum.begin(), m_rx->spectrum.end(), 0.0f);
|
|
|
|
m_rx->framesToAnalyze = m_nMarkerFrames*stepsPerFrame;
|
|
m_rx->framesLeftToAnalyze = m_rx->framesToAnalyze;
|
|
|
|
// note : not sure if looping backwards here is more meaningful than looping forwards
|
|
for (int ii = m_nMarkerFrames*stepsPerFrame - 1; ii >= 0; --ii) {
|
|
bool knownLength = false;
|
|
|
|
int decodedLength = 0;
|
|
const int offsetStart = ii;
|
|
for (int itx = 0; itx < 1024; ++itx) {
|
|
int offsetTx = offsetStart + itx*protocol.framesPerTx*stepsPerFrame;
|
|
if (offsetTx >= m_rx->recvDuration_frames*stepsPerFrame || (itx + 1)*protocol.bytesPerTx >= (int) m_dataEncoded.size()) {
|
|
break;
|
|
}
|
|
|
|
std::copy(
|
|
m_rx->amplitudeRecorded.begin() + offsetTx*step,
|
|
m_rx->amplitudeRecorded.begin() + offsetTx*step + m_samplesPerFrame, m_rx->fftOut.data());
|
|
|
|
// note : should we skip the first and last frame here as they are amplitude-smoothed?
|
|
for (int k = 1; k < protocol.framesPerTx; ++k) {
|
|
for (int i = 0; i < m_samplesPerFrame; ++i) {
|
|
m_rx->fftOut[i] += m_rx->amplitudeRecorded[(offsetTx + k*stepsPerFrame)*step + i];
|
|
}
|
|
}
|
|
|
|
FFT(m_rx->fftOut.data(), m_samplesPerFrame, m_rx->fftWorkI.data(), m_rx->fftWorkF.data());
|
|
|
|
for (int i = 0; i < m_samplesPerFrame; ++i) {
|
|
m_rx->spectrum[i] = (m_rx->fftOut[2*i + 0]*m_rx->fftOut[2*i + 0] + m_rx->fftOut[2*i + 1]*m_rx->fftOut[2*i + 1]);
|
|
}
|
|
for (int i = 1; i < m_samplesPerFrame/2; ++i) {
|
|
m_rx->spectrum[i] += m_rx->spectrum[m_samplesPerFrame - i];
|
|
}
|
|
|
|
uint8_t curByte = 0;
|
|
for (int i = 0; i < 2*protocol.bytesPerTx; ++i) {
|
|
double freq = m_hzPerSample*protocol.freqStart;
|
|
int bin = round(freq*m_ihzPerSample) + 16*i;
|
|
|
|
int kmax = 0;
|
|
double amax = 0.0;
|
|
for (int k = 0; k < 16; ++k) {
|
|
if (m_rx->spectrum[bin + k] > amax) {
|
|
kmax = k;
|
|
amax = m_rx->spectrum[bin + k];
|
|
}
|
|
}
|
|
|
|
if (i%2) {
|
|
curByte += (kmax << 4);
|
|
m_dataEncoded[itx*protocol.bytesPerTx + i/2] = curByte;
|
|
curByte = 0;
|
|
} else {
|
|
curByte = kmax;
|
|
}
|
|
}
|
|
|
|
if (itx*protocol.bytesPerTx > m_encodedDataOffset && knownLength == false) {
|
|
RS::ReedSolomon rsLength(1, m_encodedDataOffset - 1, m_workRSLength.data());
|
|
if ((rsLength.Decode(m_dataEncoded.data(), m_rx->data.data()) == 0) && (m_rx->data[0] > 0 && m_rx->data[0] <= 140)) {
|
|
knownLength = true;
|
|
decodedLength = m_rx->data[0];
|
|
|
|
const int nTotalBytesExpected = m_encodedDataOffset + decodedLength + ::getECCBytesForLength(decodedLength);
|
|
const int nTotalFramesExpected = 2*m_nMarkerFrames + ((nTotalBytesExpected + protocol.bytesPerTx - 1)/protocol.bytesPerTx)*protocol.framesPerTx;
|
|
if (m_rx->recvDuration_frames > nTotalFramesExpected ||
|
|
m_rx->recvDuration_frames < nTotalFramesExpected - 2*m_nMarkerFrames) {
|
|
knownLength = false;
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
{
|
|
const int nTotalBytesExpected = m_encodedDataOffset + decodedLength + ::getECCBytesForLength(decodedLength);
|
|
if (knownLength && itx*protocol.bytesPerTx > nTotalBytesExpected + 1) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (knownLength) {
|
|
RS::ReedSolomon rsData(decodedLength, ::getECCBytesForLength(decodedLength), m_workRSData.data());
|
|
|
|
if (rsData.Decode(m_dataEncoded.data() + m_encodedDataOffset, m_rx->data.data()) == 0) {
|
|
if (decodedLength > 0) {
|
|
if (m_isDSSEnabled) {
|
|
for (int i = 0; i < decodedLength; ++i) {
|
|
m_rx->data[i] = m_rx->data[i] ^ m_dssMagic[i%m_dssMagic.size()];
|
|
}
|
|
}
|
|
|
|
ggprintf("Decoded length = %d, protocol = '%s' (%d)\n", decodedLength, protocol.name, protocolId);
|
|
ggprintf("Received sound data successfully: '%s'\n", m_rx->data.data());
|
|
|
|
isValid = true;
|
|
m_rx->hasNewRxData = true;
|
|
m_rx->dataLength = decodedLength;
|
|
m_rx->protocol = protocol;
|
|
m_rx->protocolId = RxProtocolId(protocolId);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isValid) {
|
|
break;
|
|
}
|
|
--m_rx->framesLeftToAnalyze;
|
|
}
|
|
|
|
if (isValid) break;
|
|
}
|
|
|
|
m_rx->framesToRecord = 0;
|
|
|
|
if (isValid == false) {
|
|
ggprintf("Failed to capture sound data. Please try again (length = %d)\n", m_rx->data[0]);
|
|
m_rx->dataLength = -1;
|
|
m_rx->framesToRecord = -1;
|
|
}
|
|
|
|
m_rx->receiving = false;
|
|
m_rx->analyzing = false;
|
|
|
|
std::fill(m_rx->spectrum.begin(), m_rx->spectrum.end(), 0.0f);
|
|
|
|
m_rx->framesToAnalyze = 0;
|
|
m_rx->framesLeftToAnalyze = 0;
|
|
}
|
|
|
|
// check if receiving data
|
|
if (m_rx->receiving == false) {
|
|
bool isReceiving = false;
|
|
|
|
for (const auto & protocol : m_rx->protocols) {
|
|
if (protocol.enabled == false) {
|
|
continue;
|
|
}
|
|
|
|
int nDetectedMarkerBits = m_nBitsInMarker;
|
|
|
|
for (int i = 0; i < m_nBitsInMarker; ++i) {
|
|
double freq = bitFreq(protocol, i);
|
|
int bin = round(freq*m_ihzPerSample);
|
|
|
|
if (i%2 == 0) {
|
|
if (m_rx->spectrum[bin] <= m_soundMarkerThreshold*m_rx->spectrum[bin + m_freqDelta_bin]) --nDetectedMarkerBits;
|
|
} else {
|
|
if (m_rx->spectrum[bin] >= m_soundMarkerThreshold*m_rx->spectrum[bin + m_freqDelta_bin]) --nDetectedMarkerBits;
|
|
}
|
|
}
|
|
|
|
if (nDetectedMarkerBits == m_nBitsInMarker) {
|
|
m_rx->markerFreqStart = protocol.freqStart;
|
|
isReceiving = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isReceiving) {
|
|
if (++m_rx->nMarkersSuccess >= 1) {
|
|
} else {
|
|
isReceiving = false;
|
|
}
|
|
} else {
|
|
m_rx->nMarkersSuccess = 0;
|
|
}
|
|
|
|
if (isReceiving) {
|
|
std::time_t timestamp = std::time(nullptr);
|
|
ggprintf("%sReceiving sound data ...\n", std::asctime(std::localtime(×tamp)));
|
|
|
|
m_rx->receiving = true;
|
|
std::fill(m_rx->data.begin(), m_rx->data.end(), 0);
|
|
|
|
// max recieve duration
|
|
m_rx->recvDuration_frames =
|
|
2*m_nMarkerFrames +
|
|
maxFramesPerTx(m_rx->protocols, true)*(
|
|
(kMaxLengthVariable + ::getECCBytesForLength(kMaxLengthVariable))/minBytesPerTx(m_rx->protocols) + 1
|
|
);
|
|
|
|
m_rx->nMarkersSuccess = 0;
|
|
m_rx->framesToRecord = m_rx->recvDuration_frames;
|
|
m_rx->framesLeftToRecord = m_rx->recvDuration_frames;
|
|
}
|
|
} else {
|
|
bool isEnded = false;
|
|
|
|
for (const auto & protocol : m_rx->protocols) {
|
|
if (protocol.enabled == false) {
|
|
continue;
|
|
}
|
|
|
|
int nDetectedMarkerBits = m_nBitsInMarker;
|
|
|
|
for (int i = 0; i < m_nBitsInMarker; ++i) {
|
|
double freq = bitFreq(protocol, i);
|
|
int bin = round(freq*m_ihzPerSample);
|
|
|
|
if (i%2 == 0) {
|
|
if (m_rx->spectrum[bin] >= m_soundMarkerThreshold*m_rx->spectrum[bin + m_freqDelta_bin]) nDetectedMarkerBits--;
|
|
} else {
|
|
if (m_rx->spectrum[bin] <= m_soundMarkerThreshold*m_rx->spectrum[bin + m_freqDelta_bin]) nDetectedMarkerBits--;
|
|
}
|
|
}
|
|
|
|
if (nDetectedMarkerBits == m_nBitsInMarker) {
|
|
isEnded = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isEnded) {
|
|
if (++m_rx->nMarkersSuccess >= 1) {
|
|
} else {
|
|
isEnded = false;
|
|
}
|
|
} else {
|
|
m_rx->nMarkersSuccess = 0;
|
|
}
|
|
|
|
if (isEnded && m_rx->framesToRecord > 1) {
|
|
std::time_t timestamp = std::time(nullptr);
|
|
m_rx->recvDuration_frames -= m_rx->framesLeftToRecord - 1;
|
|
ggprintf("%sReceived end marker. Frames left = %d, recorded = %d\n", std::asctime(std::localtime(×tamp)), m_rx->framesLeftToRecord, m_rx->recvDuration_frames);
|
|
m_rx->nMarkersSuccess = 0;
|
|
m_rx->framesLeftToRecord = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Fixed payload length
|
|
|
|
void GGWave::decode_fixed() {
|
|
m_rx->hasNewSpectrum = true;
|
|
|
|
// calculate spectrum
|
|
FFT(m_rx->amplitude.data(), m_rx->fftOut.data(), m_samplesPerFrame, m_rx->fftWorkI.data(), m_rx->fftWorkF.data());
|
|
|
|
float amax = 0.0f;
|
|
for (int i = 0; i < m_samplesPerFrame; ++i) {
|
|
m_rx->spectrum[i] = (m_rx->fftOut[2*i + 0]*m_rx->fftOut[2*i + 0] + m_rx->fftOut[2*i + 1]*m_rx->fftOut[2*i + 1]);
|
|
}
|
|
for (int i = 1; i < m_samplesPerFrame/2; ++i) {
|
|
m_rx->spectrum[i] += m_rx->spectrum[m_samplesPerFrame - i];
|
|
amax = std::max(amax, m_rx->spectrum[i]);
|
|
}
|
|
|
|
|
|
// original, floating-point version
|
|
//m_rx->spectrumHistoryFixed[m_rx->historyIdFixed] = m_rx->spectrum;
|
|
|
|
// in theory, using uint8_t should work almost the same and save 4 times the memory, but for some reason
|
|
// the results are not as good as with the floating-point version
|
|
// float -> uint8_t
|
|
//amax = 255.0f/(amax == 0.0f ? 1.0f : amax);
|
|
//for (int i = 0; i < m_samplesPerFrame; ++i) {
|
|
// m_rx->spectrumHistoryFixed[m_rx->historyIdFixed][i] = std::min(255.0f, std::max(0.0f, (float) round(m_rx->spectrum[i]*amax)));
|
|
//}
|
|
|
|
// hence we opt for the uint16_t version, saving 2 times the memory and getting similar results as the floating-point version
|
|
// float -> uint16_t
|
|
amax = 65535.0f/(amax == 0.0f ? 1.0f : amax);
|
|
for (int i = 0; i < m_samplesPerFrame; ++i) {
|
|
m_rx->spectrumHistoryFixed[m_rx->historyIdFixed][i] = std::min(65535.0f, std::max(0.0f, (float) round(m_rx->spectrum[i]*amax)));
|
|
}
|
|
|
|
if (++m_rx->historyIdFixed >= (int) m_rx->spectrumHistoryFixed.size()) {
|
|
m_rx->historyIdFixed = 0;
|
|
}
|
|
|
|
bool isValid = false;
|
|
for (int protocolId = 0; protocolId < (int) m_rx->protocols.size(); ++protocolId) {
|
|
const auto & protocol = m_rx->protocols[protocolId];
|
|
if (protocol.enabled == false) {
|
|
continue;
|
|
}
|
|
|
|
const int binStart = protocol.freqStart;
|
|
const int binDelta = 16;
|
|
const int binOffset = protocol.extra == 1 ? binDelta : 0;
|
|
|
|
if (binStart > m_samplesPerFrame) {
|
|
continue;
|
|
}
|
|
|
|
const int totalLength = m_payloadLength + getECCBytesForLength(m_payloadLength);
|
|
const int totalTxs = protocol.extra*((totalLength + protocol.bytesPerTx - 1)/protocol.bytesPerTx);
|
|
|
|
int historyStartId = m_rx->historyIdFixed - totalTxs*protocol.framesPerTx;
|
|
if (historyStartId < 0) {
|
|
historyStartId += m_rx->spectrumHistoryFixed.size();
|
|
}
|
|
|
|
const int nTones = 2*protocol.bytesPerTx;
|
|
std::fill(m_rx->detectedBins.begin(), m_rx->detectedBins.end(), 0);
|
|
|
|
int txNeededTotal = 0;
|
|
int txDetectedTotal = 0;
|
|
bool detectedSignal = true;
|
|
|
|
for (int k = 0; k < totalTxs; ++k) {
|
|
if (k % protocol.extra == 0) {
|
|
std::fill(m_rx->detectedTones.begin(), m_rx->detectedTones.begin() + 16*nTones, 0);
|
|
}
|
|
|
|
for (int i = 0; i < protocol.framesPerTx; ++i) {
|
|
int historyId = historyStartId + k*protocol.framesPerTx + i;
|
|
if (historyId >= (int) m_rx->spectrumHistoryFixed.size()) {
|
|
historyId -= m_rx->spectrumHistoryFixed.size();
|
|
}
|
|
|
|
for (int j = 0; j < protocol.bytesPerTx; ++j) {
|
|
int f0bin = 0;
|
|
uint16_t f0max = m_rx->spectrumHistoryFixed[historyId][binStart + 2*j*binDelta];
|
|
|
|
for (int b = 0; b < 16; ++b) {
|
|
{
|
|
const auto & v = m_rx->spectrumHistoryFixed[historyId][binStart + 2*j*binDelta + b];
|
|
|
|
if (f0max <= v) {
|
|
f0max = v;
|
|
f0bin = b;
|
|
}
|
|
}
|
|
}
|
|
|
|
int f1bin = 0;
|
|
if (protocol.extra == 1) {
|
|
uint16_t f1max = m_rx->spectrumHistoryFixed[historyId][binStart + 2*j*binDelta + binOffset];
|
|
for (int b = 0; b < 16; ++b) {
|
|
const auto & v = m_rx->spectrumHistoryFixed[historyId][binStart + 2*j*binDelta + binOffset + b];
|
|
|
|
if (f1max <= v) {
|
|
f1max = v;
|
|
f1bin = b;
|
|
}
|
|
}
|
|
} else {
|
|
f1bin = f0bin;
|
|
}
|
|
|
|
if ((k + 0)%protocol.extra == 0) m_rx->detectedTones[(2*j + 0)*16 + f0bin]++;
|
|
if ((k + 1)%protocol.extra == 0) m_rx->detectedTones[(2*j + 1)*16 + f1bin]++;
|
|
}
|
|
}
|
|
|
|
if (protocol.extra > 1 && (k % protocol.extra == 0)) continue;
|
|
|
|
int txNeeded = 0;
|
|
int txDetected = 0;
|
|
for (int j = 0; j < protocol.bytesPerTx; ++j) {
|
|
if ((k/protocol.extra)*protocol.bytesPerTx + j >= totalLength) break;
|
|
txNeeded += 2;
|
|
for (int b = 0; b < 16; ++b) {
|
|
if (m_rx->detectedTones[(2*j + 0)*16 + b] > protocol.framesPerTx/2) {
|
|
m_rx->detectedBins[2*((k/protocol.extra)*protocol.bytesPerTx + j) + 0] = b;
|
|
txDetected++;
|
|
}
|
|
if (m_rx->detectedTones[(2*j + 1)*16 + b] > protocol.framesPerTx/2) {
|
|
m_rx->detectedBins[2*((k/protocol.extra)*protocol.bytesPerTx + j) + 1] = b;
|
|
txDetected++;
|
|
}
|
|
}
|
|
}
|
|
|
|
txDetectedTotal += txDetected;
|
|
txNeededTotal += txNeeded;
|
|
}
|
|
|
|
if (txDetectedTotal < 0.75*txNeededTotal) {
|
|
detectedSignal = false;
|
|
}
|
|
|
|
if (detectedSignal) {
|
|
RS::ReedSolomon rsData(m_payloadLength, getECCBytesForLength(m_payloadLength), m_workRSData.data());
|
|
|
|
for (int j = 0; j < totalLength; ++j) {
|
|
m_dataEncoded[j] = (m_rx->detectedBins[2*j + 1] << 4) + m_rx->detectedBins[2*j + 0];
|
|
}
|
|
|
|
if (rsData.Decode(m_dataEncoded.data(), m_rx->data.data()) == 0) {
|
|
if (m_isDSSEnabled) {
|
|
for (int i = 0; i < m_payloadLength; ++i) {
|
|
m_rx->data[i] = m_rx->data[i] ^ m_dssMagic[i%m_dssMagic.size()];
|
|
}
|
|
}
|
|
|
|
ggprintf("Decoded length = %d, protocol = '%s' (%d)\n", m_payloadLength, protocol.name, protocolId);
|
|
ggprintf("Received sound data successfully: '%s'\n", m_rx->data.data());
|
|
|
|
isValid = true;
|
|
m_rx->hasNewRxData = true;
|
|
m_rx->dataLength = m_payloadLength;
|
|
m_rx->protocol = protocol;
|
|
m_rx->protocolId = RxProtocolId(protocolId);
|
|
}
|
|
}
|
|
|
|
if (isValid) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int GGWave::maxFramesPerTx(const Protocols & protocols, bool excludeMT) const {
|
|
int res = 0;
|
|
for (const auto & protocol : protocols) {
|
|
if (protocol.enabled == false) {
|
|
continue;
|
|
}
|
|
if (excludeMT && protocol.extra > 1) {
|
|
continue;
|
|
}
|
|
res = std::max(res, protocol.framesPerTx*protocol.extra);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int GGWave::minBytesPerTx(const Protocols & protocols) const {
|
|
int res = 1;
|
|
for (const auto & protocol : protocols) {
|
|
if (protocol.enabled == false) {
|
|
continue;
|
|
}
|
|
res = std::min(res, protocol.bytesPerTx);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int GGWave::maxBytesPerTx(const Protocols & protocols) const {
|
|
int res = 1;
|
|
for (const auto & protocol : protocols) {
|
|
if (protocol.enabled == false) {
|
|
continue;
|
|
}
|
|
res = std::max(res, protocol.bytesPerTx);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
double GGWave::bitFreq(const Protocol & p, int bit) const {
|
|
return m_hzPerSample*p.freqStart + m_freqDelta_hz*bit;
|
|
}
|