145 lines
5.4 KiB
C++
145 lines
5.4 KiB
C++
// Copyright (c) Charles J. Cliffe
|
|
// SPDX-License-Identifier: GPL-2.0+
|
|
|
|
#include "FFTDataDistributor.h"
|
|
#include <algorithm>
|
|
#include <ThreadBlockingQueue.h>
|
|
|
|
//50 ms
|
|
#define HEARTBEAT_CHECK_PERIOD_MICROS (50 * 1000)
|
|
|
|
FFTDataDistributor::FFTDataDistributor() : outputBuffers("FFTDataDistributorBuffers"), fftSize(DEFAULT_FFT_SIZE), linesPerSecond(DEFAULT_WATERFALL_LPS), lineRateAccum(0.0) {
|
|
|
|
}
|
|
|
|
void FFTDataDistributor::setFFTSize(unsigned int size) {
|
|
|
|
fftSize.store(size);
|
|
}
|
|
|
|
void FFTDataDistributor::setLinesPerSecond(unsigned int lines) {
|
|
this->linesPerSecond = lines;
|
|
}
|
|
|
|
unsigned int FFTDataDistributor::getLinesPerSecond() const {
|
|
return this->linesPerSecond;
|
|
}
|
|
|
|
void FFTDataDistributor::process() {
|
|
|
|
while (!input->empty()) {
|
|
if (!isAnyOutputEmpty()) {
|
|
return;
|
|
}
|
|
DemodulatorThreadIQDataPtr inp;
|
|
|
|
if (!input->pop(inp, HEARTBEAT_CHECK_PERIOD_MICROS)) {
|
|
continue;
|
|
}
|
|
|
|
if (inp) {
|
|
//Settings have changed, set new values and dump all previous samples stored in inputBuffer:
|
|
if (inputBuffer.sampleRate != inp->sampleRate || inputBuffer.frequency != inp->frequency) {
|
|
|
|
//bufferMax must be at least fftSize (+ margin), else the waterfall get frozen, because no longer updated.
|
|
bufferMax = std::max((size_t)(inp->sampleRate * FFT_DISTRIBUTOR_BUFFER_IN_SECONDS), (size_t)(1.2 * fftSize.load()));
|
|
|
|
// std::cout << "Buffer Max: " << bufferMax << std::endl;
|
|
bufferOffset = 0;
|
|
bufferedItems = 0;
|
|
inputBuffer.sampleRate = inp->sampleRate;
|
|
inputBuffer.frequency = inp->frequency;
|
|
inputBuffer.data.resize(bufferMax);
|
|
}
|
|
|
|
//adjust (bufferMax ; inputBuffer.data) in case of FFT size change only.
|
|
if (bufferMax < (size_t)(1.2 * fftSize.load())) {
|
|
bufferMax = (size_t)(1.2 * fftSize.load());
|
|
inputBuffer.data.resize(bufferMax);
|
|
}
|
|
|
|
size_t nbSamplesToAdd = inp->data.size();
|
|
|
|
//No room left in inputBuffer.data to accept inp->data.size() more samples.
|
|
//so make room by sliding left of bufferOffset, which is fine because
|
|
//those samples has already been processed.
|
|
if ((bufferOffset + bufferedItems + inp->data.size()) > bufferMax) {
|
|
memmove(&inputBuffer.data[0], &inputBuffer.data[bufferOffset], bufferedItems*sizeof(liquid_float_complex));
|
|
bufferOffset = 0;
|
|
//if there are too much samples, we may even overflow !
|
|
//as a fallback strategy, drop the last incoming new samples not fitting in inputBuffer.data.
|
|
if (bufferedItems + inp->data.size() > bufferMax) {
|
|
//clamp nbSamplesToAdd
|
|
nbSamplesToAdd = bufferMax - bufferedItems;
|
|
std::cout << "FFTDataDistributor::process() incoming samples overflow, dropping the last " << (inp->data.size() - nbSamplesToAdd) << " input samples..." << std::endl;
|
|
}
|
|
}
|
|
|
|
//store nbSamplesToAdd incoming samples.
|
|
memcpy(&inputBuffer.data[bufferOffset+bufferedItems],&inp->data[0], nbSamplesToAdd *sizeof(liquid_float_complex));
|
|
bufferedItems += nbSamplesToAdd;
|
|
//
|
|
|
|
} else {
|
|
//empty inp, wait for another.
|
|
continue;
|
|
}
|
|
|
|
// number of seconds contained in input
|
|
double inputTime = (double)bufferedItems / (double)inputBuffer.sampleRate;
|
|
// number of lines in input
|
|
double inputLines = (double)bufferedItems / (double)fftSize;
|
|
|
|
// ratio required to achieve the desired rate:
|
|
// it means we can achieive 'lineRateStep' times the target linesPerSecond.
|
|
// < 1 means we cannot reach it by lack of samples.
|
|
double lineRateStep = ((double)linesPerSecond * inputTime)/(double)inputLines;
|
|
|
|
//we have enough samples to FFT at least one 'line' of 'fftSize' frequencies for display:
|
|
if (bufferedItems >= fftSize) {
|
|
size_t numProcessed = 0;
|
|
if (lineRateAccum + (lineRateStep * ((double)bufferedItems/(double)fftSize)) < 1.0) {
|
|
// move along, nothing to see here..
|
|
lineRateAccum += (lineRateStep * ((double)bufferedItems/(double)fftSize));
|
|
numProcessed = bufferedItems;
|
|
} else {
|
|
for (size_t i = 0, iMax = bufferedItems; i < iMax; i += fftSize) {
|
|
if ((i + fftSize) > iMax) {
|
|
break;
|
|
}
|
|
lineRateAccum += lineRateStep;
|
|
|
|
if (lineRateAccum >= 1.0) {
|
|
//each i represents a FFT computation
|
|
DemodulatorThreadIQDataPtr outp = outputBuffers.getBuffer();
|
|
|
|
outp->frequency = inputBuffer.frequency;
|
|
outp->sampleRate = inputBuffer.sampleRate;
|
|
outp->data.assign(inputBuffer.data.begin()+bufferOffset+i,
|
|
inputBuffer.data.begin()+bufferOffset+i+ fftSize);
|
|
//authorize distribute with losses
|
|
distribute(outp, NON_BLOCKING_TIMEOUT);
|
|
|
|
while (lineRateAccum >= 1.0) {
|
|
lineRateAccum -= 1.0;
|
|
}
|
|
}
|
|
|
|
numProcessed += fftSize;
|
|
} //end for
|
|
}
|
|
//advance bufferOffset read pointer,
|
|
//reduce size of bufferedItems.
|
|
if (numProcessed) {
|
|
bufferedItems -= numProcessed;
|
|
bufferOffset += numProcessed;
|
|
}
|
|
//clamp to zero the number of remaining items.
|
|
if (bufferedItems <= 0) {
|
|
bufferedItems = 0;
|
|
bufferOffset = 0;
|
|
}
|
|
} //end if bufferedItems >= fftSize
|
|
} //en while
|
|
}
|