mirror
/
SDRPlusPlus
kopia lustrzana https://github.com/AlexandreRouma/SDRPlusPlus
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

lots o shit

pull/785/head
AlexandreRouma 2022-06-15 16:08:28 +02:00
rodzic 79a15ed186
commit 343ec6ca1c
109 zmienionych plików z 496 dodań i 18305 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

2
CMakeLists.txt
Wyświetl plik

@ -52,7 +52,7 @@ option(OPT_BUILD_NEW_PORTAUDIO_SINK "Build the new PortAudio Sink Module (Depend
option(OPT_BUILD_FALCON9_DECODER "Build the falcon9 live decoder (Dependencies: ffplay)" OFF)
option(OPT_BUILD_KG_SSTV_DECODER "Build the M17 decoder module (no dependencies required)" OFF)
option(OPT_BUILD_M17_DECODER "Build the M17 decoder module (no dependencies required)" OFF)
option(OPT_BUILD_METEOR_DEMODULATOR "Build the meteor demodulator module (no dependencies required)" ON)
option(OPT_BUILD_METEOR_DEMODULATOR "Build the meteor demodulator module (no dependencies required)" OFF)
option(OPT_BUILD_RADIO "Main audio modulation decoder (AM, FM, SSB, etc...)" ON)
option(OPT_BUILD_WEATHER_SAT_DECODER "Build the HRPT decoder module (no dependencies required)" OFF)

15
core/src/core.cpp
Wyświetl plik

@ -42,15 +42,18 @@ namespace core {
// Forward this to the server
if (args["server"].b()) { server::setInputSampleRate(samplerate); return; }
sigpath::signalPath.sourceSampleRate = samplerate;
double effectiveSr = samplerate / ((double)(1 << sigpath::signalPath.decimation));
// NOTE: Zoom controls won't work
spdlog::info("New DSP samplerate: {0} (source samplerate is {1})", effectiveSr, samplerate);
// Update IQ frontend input samplerate and get effective samplerate
sigpath::iqFrontEnd.setSampleRate(samplerate);
double effectiveSr = sigpath::iqFrontEnd.getEffectiveSamplerate();
// Reset zoom
gui::waterfall.setBandwidth(effectiveSr);
gui::waterfall.setViewOffset(0);
gui::waterfall.setViewBandwidth(effectiveSr);
sigpath::signalPath.setSampleRate(effectiveSr);
gui::mainWindow.setViewBandwidthSlider(1.0);
// Debug logs
spdlog::info("New DSP samplerate: {0} (source samplerate is {1})", effectiveSr, samplerate);
}
};
@ -363,7 +366,7 @@ int sdrpp_main(int argc, char* argv[]) {
// Terminate backend (TODO: CHECK RETURN VALUE)
backend::end();
sigpath::signalPath.stop();
sigpath::iqFrontEnd.stop();
core::configManager.disableAutoSave();
core::configManager.save();

198
core/src/dsp/audio.h
Wyświetl plik

@ -1,198 +0,0 @@
#pragma once
#include <dsp/block.h>
namespace dsp {
class MonoToStereo : public generic_block<MonoToStereo> {
public:
MonoToStereo() {}
MonoToStereo(stream<float>* in) { init(in); }
void init(stream<float>* in) {
_in = in;
generic_block<MonoToStereo>::registerInput(_in);
generic_block<MonoToStereo>::registerOutput(&out);
generic_block<MonoToStereo>::_block_init = true;
}
void setInput(stream<float>* in) {
assert(generic_block<MonoToStereo>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<MonoToStereo>::ctrlMtx);
generic_block<MonoToStereo>::tempStop();
generic_block<MonoToStereo>::unregisterInput(_in);
_in = in;
generic_block<MonoToStereo>::registerInput(_in);
generic_block<MonoToStereo>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32f_x2_interleave_32fc((lv_32fc_t*)out.writeBuf, _in->readBuf, _in->readBuf, count);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<stereo_t> out;
private:
stream<float>* _in;
};
class ChannelsToStereo : public generic_block<ChannelsToStereo> {
public:
ChannelsToStereo() {}
ChannelsToStereo(stream<float>* in_left, stream<float>* in_right) { init(in_left, in_right); }
void init(stream<float>* in_left, stream<float>* in_right) {
_in_left = in_left;
_in_right = in_right;
nullbuf = new float[STREAM_BUFFER_SIZE];
for (int i = 0; i < STREAM_BUFFER_SIZE; i++) { nullbuf[i] = 0; }
generic_block<ChannelsToStereo>::registerInput(_in_left);
generic_block<ChannelsToStereo>::registerInput(_in_right);
generic_block<ChannelsToStereo>::registerOutput(&out);
generic_block<ChannelsToStereo>::_block_init = true;
}
void setInput(stream<float>* in_left, stream<float>* in_right) {
assert(generic_block<ChannelsToStereo>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<ChannelsToStereo>::ctrlMtx);
generic_block<ChannelsToStereo>::tempStop();
generic_block<ChannelsToStereo>::unregisterInput(_in_left);
generic_block<ChannelsToStereo>::unregisterInput(_in_right);
_in_left = in_left;
_in_right = in_right;
generic_block<ChannelsToStereo>::registerInput(_in_left);
generic_block<ChannelsToStereo>::registerInput(_in_right);
generic_block<ChannelsToStereo>::tempStart();
}
int run() {
int count_l = _in_left->read();
if (count_l < 0) { return -1; }
int count_r = _in_right->read();
if (count_r < 0) { return -1; }
if (count_l != count_r) {
spdlog::warn("ChannelsToStereo block size mismatch");
}
volk_32f_x2_interleave_32fc((lv_32fc_t*)out.writeBuf, _in_left->readBuf, _in_right->readBuf, count_l);
_in_left->flush();
_in_right->flush();
if (!out.swap(count_l)) { return -1; }
return count_l;
}
stream<stereo_t> out;
private:
stream<float>* _in_left;
stream<float>* _in_right;
float* nullbuf;
};
class StereoToMono : public generic_block<StereoToMono> {
public:
StereoToMono() {}
StereoToMono(stream<stereo_t>* in) { init(in); }
~StereoToMono() {
if (!generic_block<StereoToMono>::_block_init) { return; }
generic_block<StereoToMono>::stop();
delete[] l_buf;
delete[] r_buf;
generic_block<StereoToMono>::_block_init = false;
}
void init(stream<stereo_t>* in) {
_in = in;
l_buf = new float[STREAM_BUFFER_SIZE];
r_buf = new float[STREAM_BUFFER_SIZE];
generic_block<StereoToMono>::registerInput(_in);
generic_block<StereoToMono>::registerOutput(&out);
generic_block<StereoToMono>::_block_init = true;
}
void setInput(stream<stereo_t>* in) {
assert(generic_block<StereoToMono>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<StereoToMono>::ctrlMtx);
generic_block<StereoToMono>::tempStop();
generic_block<StereoToMono>::unregisterInput(_in);
_in = in;
generic_block<StereoToMono>::registerInput(_in);
generic_block<StereoToMono>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
for (int i = 0; i < count; i++) {
out.writeBuf[i] = (_in->readBuf[i].l + _in->readBuf[i].r) * 0.5f;
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<float> out;
private:
float *l_buf, *r_buf;
stream<stereo_t>* _in;
};
class StereoToChannels : public generic_block<StereoToChannels> {
public:
StereoToChannels() {}
StereoToChannels(stream<stereo_t>* in) { init(in); }
void init(stream<stereo_t>* in) {
_in = in;
generic_block<StereoToChannels>::registerInput(_in);
generic_block<StereoToChannels>::registerOutput(&out_left);
generic_block<StereoToChannels>::registerOutput(&out_right);
generic_block<StereoToChannels>::_block_init = true;
}
void setInput(stream<stereo_t>* in) {
assert(generic_block<StereoToChannels>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<StereoToChannels>::ctrlMtx);
generic_block<StereoToChannels>::tempStop();
generic_block<StereoToChannels>::unregisterInput(_in);
_in = in;
generic_block<StereoToChannels>::registerInput(_in);
generic_block<StereoToChannels>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32fc_deinterleave_32f_x2(out_left.writeBuf, out_right.writeBuf, (lv_32fc_t*)_in->readBuf, count);
_in->flush();
if (!out_left.swap(count)) { return -1; }
if (!out_right.swap(count)) { return -1; }
return count;
}
stream<float> out_left;
stream<float> out_right;
private:
stream<stereo_t>* _in;
};
}

170
core/src/dsp/block.h
Wyświetl plik

@ -1,29 +1,24 @@
#pragma once
#include <stdio.h>
#include <dsp/stream.h>
#include <dsp/types.h>
#include <assert.h>
#include <thread>
#include <vector>
#include <algorithm>
#include <spdlog/spdlog.h>
#include "stream.h"
#include "types.h"
namespace dsp {
class generic_unnamed_block {
class generic_block {
public:
virtual void start() {}
virtual void stop() {}
virtual int calcOutSize(int inSize) { return inSize; }
virtual int run() { return -1; }
};
template <class BLOCK>
class generic_block : public generic_unnamed_block {
class block : public generic_block {
public:
virtual void init() {}
virtual ~generic_block() {
virtual ~block() {
if (!_block_init) { return; }
stop();
_block_init = false;
@ -31,7 +26,7 @@ namespace dsp {
virtual void start() {
assert(_block_init);
std::lock_guard<std::mutex> lck(ctrlMtx);
std::lock_guard<std::recursive_mutex> lck(ctrlMtx);
if (running) {
return;
}
@ -41,7 +36,7 @@ namespace dsp {
virtual void stop() {
assert(_block_init);
std::lock_guard<std::mutex> lck(ctrlMtx);
std::lock_guard<std::recursive_mutex> lck(ctrlMtx);
if (!running) {
return;
}
@ -51,6 +46,7 @@ namespace dsp {
void tempStart() {
assert(_block_init);
if (!tempStopDepth || --tempStopDepth) { return; }
if (tempStopped) {
doStart();
tempStopped = false;
@ -59,26 +55,45 @@ namespace dsp {
void tempStop() {
assert(_block_init);
if (tempStopDepth++) { return; }
if (running && !tempStopped) {
doStop();
tempStopped = true;
}
}
virtual int calcOutSize(int inSize) {
assert(_block_init);
return inSize;
}
virtual int run() = 0;
friend BLOCK;
private:
protected:
void workerLoop() {
while (run() >= 0) {}
}
virtual void doStart() {
workerThread = std::thread(&block::workerLoop, this);
}
virtual void doStop() {
for (auto& in : inputs) {
in->stopReader();
}
for (auto& out : outputs) {
out->stopWriter();
}
// TODO: Make sure this isn't needed, I don't know why it stops
if (workerThread.joinable()) {
workerThread.join();
}
for (auto& in : inputs) {
in->clearReadStop();
}
for (auto& out : outputs) {
out->clearWriteStop();
}
}
void acquire() {
ctrlMtx.lock();
}
@ -103,125 +118,16 @@ namespace dsp {
outputs.erase(std::remove(outputs.begin(), outputs.end(), outStream), outputs.end());
}
virtual void doStart() {
workerThread = std::thread(&generic_block<BLOCK>::workerLoop, this);
}
virtual void doStop() {
for (auto& in : inputs) {
in->stopReader();
}
for (auto& out : outputs) {
out->stopWriter();
}
// TODO: Make sure this isn't needed, I don't know why it stops
if (workerThread.joinable()) {
workerThread.join();
}
for (auto& in : inputs) {
in->clearReadStop();
}
for (auto& out : outputs) {
out->clearWriteStop();
}
}
protected:
bool _block_init = false;
std::mutex ctrlMtx;
std::recursive_mutex ctrlMtx;
std::vector<untyped_stream*> inputs;
std::vector<untyped_stream*> outputs;
bool running = false;
bool tempStopped = false;
int tempStopDepth = 0;
std::thread workerThread;
};
template <class BLOCK>
class generic_hier_block {
public:
virtual void init() {}
virtual ~generic_hier_block() {
if (!_block_init) { return; }
stop();
_block_init = false;
}
virtual void start() {
assert(_block_init);
std::lock_guard<std::mutex> lck(ctrlMtx);
if (running) {
return;
}
running = true;
doStart();
}
virtual void stop() {
assert(_block_init);
std::lock_guard<std::mutex> lck(ctrlMtx);
if (!running) {
return;
}
doStop();
running = false;
}
void tempStart() {
assert(_block_init);
if (tempStopped) {
doStart();
tempStopped = false;
}
}
void tempStop() {
assert(_block_init);
if (running && !tempStopped) {
doStop();
tempStopped = true;
}
}
virtual int calcOutSize(int inSize) {
assert(_block_init);
return inSize;
}
friend BLOCK;
private:
void registerBlock(generic_unnamed_block* block) {
blocks.push_back(block);
}
void unregisterBlock(generic_unnamed_block* block) {
blocks.erase(std::remove(blocks.begin(), blocks.end(), block), blocks.end());
}
virtual void doStart() {
for (auto& block : blocks) {
block->start();
}
}
virtual void doStop() {
for (auto& block : blocks) {
block->stop();
}
}
std::vector<generic_unnamed_block*> blocks;
bool tempStopped = false;
bool running = false;
protected:
bool _block_init = false;
std::mutex ctrlMtx;
};
}

360
core/src/dsp/buffer.h
Wyświetl plik

@ -1,360 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <string.h>
#define RING_BUF_SZ 1000000
namespace dsp {
template <class T>
class RingBuffer {
public:
RingBuffer() {}
RingBuffer(int maxLatency) { init(maxLatency); }
~RingBuffer() {
if (!_init) { return; }
delete _buffer;
_init = false;
}
void init(int maxLatency) {
size = RING_BUF_SZ;
_buffer = new T[size];
_stopReader = false;
_stopWriter = false;
this->maxLatency = maxLatency;
writec = 0;
readc = 0;
readable = 0;
writable = size;
memset(_buffer, 0, size * sizeof(T));
_init = true;
}
int read(T* data, int len) {
assert(_init);
int dataRead = 0;
int toRead = 0;
while (dataRead < len) {
toRead = std::min<int>(waitUntilReadable(), len - dataRead);
if (toRead < 0) { return -1; };
if ((toRead + readc) > size) {
memcpy(&data[dataRead], &_buffer[readc], (size - readc) * sizeof(T));
memcpy(&data[dataRead + (size - readc)], &_buffer[0], (toRead - (size - readc)) * sizeof(T));
}
else {
memcpy(&data[dataRead], &_buffer[readc], toRead * sizeof(T));
}
dataRead += toRead;
_readable_mtx.lock();
readable -= toRead;
_readable_mtx.unlock();
_writable_mtx.lock();
writable += toRead;
_writable_mtx.unlock();
readc = (readc + toRead) % size;
canWriteVar.notify_one();
}
return len;
}
int readAndSkip(T* data, int len, int skip) {
assert(_init);
int dataRead = 0;
int toRead = 0;
while (dataRead < len) {
toRead = std::min<int>(waitUntilReadable(), len - dataRead);
if (toRead < 0) { return -1; };
if ((toRead + readc) > size) {
memcpy(&data[dataRead], &_buffer[readc], (size - readc) * sizeof(T));
memcpy(&data[dataRead + (size - readc)], &_buffer[0], (toRead - (size - readc)) * sizeof(T));
}
else {
memcpy(&data[dataRead], &_buffer[readc], toRead * sizeof(T));
}
dataRead += toRead;
_readable_mtx.lock();
readable -= toRead;
_readable_mtx.unlock();
_writable_mtx.lock();
writable += toRead;
_writable_mtx.unlock();
readc = (readc + toRead) % size;
canWriteVar.notify_one();
}
dataRead = 0;
while (dataRead < skip) {
toRead = std::min<int>(waitUntilReadable(), skip - dataRead);
if (toRead < 0) { return -1; };
dataRead += toRead;
_readable_mtx.lock();
readable -= toRead;
_readable_mtx.unlock();
_writable_mtx.lock();
writable += toRead;
_writable_mtx.unlock();
readc = (readc + toRead) % size;
canWriteVar.notify_one();
}
return len;
}
int waitUntilReadable() {
assert(_init);
if (_stopReader) { return -1; }
int _r = getReadable();
if (_r != 0) { return _r; }
std::unique_lock<std::mutex> lck(_readable_mtx);
canReadVar.wait(lck, [=]() { return ((this->getReadable(false) > 0) || this->getReadStop()); });
if (_stopReader) { return -1; }
return getReadable(false);
}
int getReadable(bool lock = true) {
assert(_init);
if (lock) { _readable_mtx.lock(); };
int _r = readable;
if (lock) { _readable_mtx.unlock(); };
return _r;
}
int write(T* data, int len) {
assert(_init);
int dataWritten = 0;
int toWrite = 0;
while (dataWritten < len) {
toWrite = std::min<int>(waitUntilwritable(), len - dataWritten);
if (toWrite < 0) { return -1; };
if ((toWrite + writec) > size) {
memcpy(&_buffer[writec], &data[dataWritten], (size - writec) * sizeof(T));
memcpy(&_buffer[0], &data[dataWritten + (size - writec)], (toWrite - (size - writec)) * sizeof(T));
}
else {
memcpy(&_buffer[writec], &data[dataWritten], toWrite * sizeof(T));
}
dataWritten += toWrite;
_readable_mtx.lock();
readable += toWrite;
_readable_mtx.unlock();
_writable_mtx.lock();
writable -= toWrite;
_writable_mtx.unlock();
writec = (writec + toWrite) % size;
canReadVar.notify_one();
}
return len;
}
int waitUntilwritable() {
assert(_init);
if (_stopWriter) { return -1; }
int _w = getWritable();
if (_w != 0) { return _w; }
std::unique_lock<std::mutex> lck(_writable_mtx);
canWriteVar.wait(lck, [=]() { return ((this->getWritable(false) > 0) || this->getWriteStop()); });
if (_stopWriter) { return -1; }
return getWritable(false);
}
int getWritable(bool lock = true) {
assert(_init);
if (lock) { _writable_mtx.lock(); };
int _w = writable;
if (lock) {
_writable_mtx.unlock();
_readable_mtx.lock();
};
int _r = readable;
if (lock) { _readable_mtx.unlock(); };
return std::max<int>(std::min<int>(_w, maxLatency - _r), 0);
}
void stopReader() {
assert(_init);
_stopReader = true;
canReadVar.notify_one();
}
void stopWriter() {
assert(_init);
_stopWriter = true;
canWriteVar.notify_one();
}
bool getReadStop() {
assert(_init);
return _stopReader;
}
bool getWriteStop() {
assert(_init);
return _stopWriter;
}
void clearReadStop() {
assert(_init);
_stopReader = false;
}
void clearWriteStop() {
assert(_init);
_stopWriter = false;
}
void setMaxLatency(int maxLatency) {
assert(_init);
this->maxLatency = maxLatency;
}
private:
bool _init = false;
T* _buffer;
int size;
int readc;
int writec;
int readable;
int writable;
int maxLatency;
bool _stopReader;
bool _stopWriter;
std::mutex _readable_mtx;
std::mutex _writable_mtx;
std::condition_variable canReadVar;
std::condition_variable canWriteVar;
};
#define TEST_BUFFER_SIZE 32
template <class T>
class SampleFrameBuffer : public generic_block<SampleFrameBuffer<T>> {
public:
SampleFrameBuffer() {}
SampleFrameBuffer(stream<T>* in) { init(in); }
void init(stream<T>* in) {
_in = in;
for (int i = 0; i < TEST_BUFFER_SIZE; i++) {
buffers[i] = new T[STREAM_BUFFER_SIZE];
}
generic_block<SampleFrameBuffer<T>>::registerInput(in);
generic_block<SampleFrameBuffer<T>>::registerOutput(&out);
generic_block<SampleFrameBuffer<T>>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<SampleFrameBuffer<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<SampleFrameBuffer<T>>::ctrlMtx);
generic_block<SampleFrameBuffer<T>>::tempStop();
generic_block<SampleFrameBuffer<T>>::unregisterInput(_in);
_in = in;
generic_block<SampleFrameBuffer<T>>::registerInput(_in);
generic_block<SampleFrameBuffer<T>>::tempStart();
}
void flush() {
std::unique_lock lck(bufMtx);
readCur = writeCur;
}
int run() {
// Wait for data
int count = _in->read();
if (count < 0) { return -1; }
if (bypass) {
memcpy(out.writeBuf, _in->readBuf, count * sizeof(T));
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
// Push it on the ring buffer
{
std::lock_guard<std::mutex> lck(bufMtx);
memcpy(buffers[writeCur], _in->readBuf, count * sizeof(T));
sizes[writeCur] = count;
writeCur++;
writeCur = ((writeCur) % TEST_BUFFER_SIZE);
// if (((writeCur - readCur + TEST_BUFFER_SIZE) % TEST_BUFFER_SIZE) >= (TEST_BUFFER_SIZE-2)) {
// spdlog::warn("Overflow");
// }
}
cnd.notify_all();
_in->flush();
return count;
}
void worker() {
while (true) {
// Wait for data
std::unique_lock lck(bufMtx);
cnd.wait(lck, [this]() { return (((writeCur - readCur + TEST_BUFFER_SIZE) % TEST_BUFFER_SIZE) > 0) || stopWorker; });
if (stopWorker) { break; }
// Write one to output buffer and unlock in preparation to swap buffers
int count = sizes[readCur];
memcpy(out.writeBuf, buffers[readCur], count * sizeof(T));
readCur++;
readCur = ((readCur) % TEST_BUFFER_SIZE);
lck.unlock();
// Swap
if (!out.swap(count)) { break; }
}
}
stream<T> out;
int writeCur = 0;
int readCur = 0;
bool bypass = false;
private:
void doStart() {
generic_block<SampleFrameBuffer<T>>::workerThread = std::thread(&generic_block<SampleFrameBuffer<T>>::workerLoop, this);
readWorkerThread = std::thread(&SampleFrameBuffer<T>::worker, this);
}
void doStop() {
_in->stopReader();
out.stopWriter();
stopWorker = true;
cnd.notify_all();
if (generic_block<SampleFrameBuffer<T>>::workerThread.joinable()) { generic_block<SampleFrameBuffer<T>>::workerThread.join(); }
if (readWorkerThread.joinable()) { readWorkerThread.join(); }
_in->clearReadStop();
out.clearWriteStop();
stopWorker = false;
}
stream<T>* _in;
std::thread readWorkerThread;
std::mutex bufMtx;
std::condition_variable cnd;
T* buffers[TEST_BUFFER_SIZE];
int sizes[TEST_BUFFER_SIZE];
bool stopWorker = false;
};
};

346
core/src/dsp/chain.h
Wyświetl plik

@ -1,209 +1,193 @@
#pragma once
#include <dsp/stream.h>
#include <type_traits>
#include <vector>
#include <utils/event.h>
#include <map>
#include "processor.h"
namespace dsp {
template <class T>
class ChainLinkAny {
template<class T>
class chain {
public:
virtual ~ChainLinkAny() {}
virtual void setInput(stream<T>* stream) = 0;
virtual stream<T>* getOutput() = 0;
virtual void start() = 0;
virtual void stop() = 0;
bool enabled = false;
};
chain() {}
template <class BLOCK, class T>
class ChainLink : public ChainLinkAny<T> {
public:
~ChainLink() {}
chain(stream<T>* in) { init(in); }
void setInput(stream<T>* stream) {
block.setInput(stream);
void init(stream<T>* in) {
_in = in;
out = _in;
}
stream<T>* getOutput() {
return &block.out;
template<typename Func>
void setInput(stream<T>* in, Func onOutputChange) {
_in = in;
for (auto& ln : links) {
if (states[ln]) {
ln->setInput(_in);
return;
}
}
out = _in;
onOutputChange(out);
}
void addBlock(Processor<T, T>* block, bool enabled) {
// Check if block is already part of the chain
if (blockExists(block)) {
throw std::runtime_error("[chain] Tried to add a block that is already part of the chain");
}
// Add to the list
links.push_back(block);
states[block] = false;
// Enable if needed
if (enabled) { enableBlock(block, [](stream<T>* out){}); }
}
template<typename Func>
void removeBlock(Processor<T, T>* block, Func onOutputChange) {
// Check if block is part of the chain
if (!blockExists(block)) {
throw std::runtime_error("[chain] Tried to remove a block that is not part of the chain");
}
// Disable the block
disableBlock(block, onOutputChange);
// Remove block from the list
states.erase(block);
links.erase(std::find(links.begin(), links.end(), block));
}
template<typename Func>
void enableBlock(Processor<T, T>* block, Func onOutputChange) {
// Check that the block is part of the chain
if (!blockExists(block)) {
throw std::runtime_error("[chain] Tried to enable a block that isn't part of the chain");
}
// If already enable, don't do anything
if (states[block]) { return; }
// Gather blocks before and after the block to enable
Processor<T, T>* before = blockBefore(block);
Processor<T, T>* after = blockAfter(block);
// Update input of next block or output
if (after) {
after->setInput(&block->out);
}
else {
out = &block->out;
onOutputChange(out);
}
// Set input of the new block
block->setInput(before ? &before->out : _in);
// Start new block
if (running) { block->start(); }
states[block] = true;
}
template<typename Func>
void disableBlock(Processor<T, T>* block, Func onOutputChange) {
// Check that the block is part of the chain
if (!blockExists(block)) {
throw std::runtime_error("[chain] Tried to enable a block that isn't part of the chain");
}
// If already disabled, don't do anything
if (!states[block]) { return; }
// Stop disabled block
block->stop();
states[block] = false;
// Gather blocks before and after the block to disable
Processor<T, T>* before = blockBefore(block);
Processor<T, T>* after = blockAfter(block);
// Update input of next block or output
if (after) {
after->setInput(before ? &before->out : _in);
}
else {
out = before ? &before->out : _in;
onOutputChange(out);
}
}
template<typename Func>
void setBlockEnabled(Processor<T, T>* block, bool enabled, Func onOutputChange) {
if (enabled) {
enableBlock(block, onOutputChange);
}
else {
disableBlock(block, onOutputChange);
}
}
template<typename Func>
void enableAllBlocks(Func onOutputChange) {
for (auto& ln : links) {
enableBlock(ln, onOutputChange);
}
}
template<typename Func>
void disableAllBlocks(Func onOutputChange) {
for (auto& ln : links) {
disableBlock(ln, onOutputChange);
}
}
void start() {
block.start();
}
void stop() {
block.stop();
}
BLOCK block;
};
template <class T>
class Chain {
public:
Chain() {}
Chain(stream<T>* input, EventHandler<stream<T>*>* outputChangedHandler) {
init(input, outputChangedHandler);
}
void init(stream<T>* input, EventHandler<stream<T>*>* outputChangedHandler) {
_input = input;
onOutputChanged.bindHandler(outputChangedHandler);
}
void add(ChainLinkAny<T>* link) {
// Check that link exists
if (std::find(links.begin(), links.end(), link) != links.end()) {
spdlog::error("Could not add new link to the chain, link already in the chain");
return;
}
// Assert that the link is stopped and disabled
link->stop();
link->enabled = false;
// Add new link to the list
links.push_back(link);
}
void enable(ChainLinkAny<T>* link) {
// Check that link exists and locate it
auto lnit = std::find(links.begin(), links.end(), link);
if (lnit == links.end()) {
spdlog::error("Could not enable link");
return;
}
// Enable the link
link->enabled = true;
// Find input
stream<T>* input = _input;
for (auto i = links.begin(); i < lnit; i++) {
if (!(*i)->enabled) { continue; }
input = (*i)->getOutput();
}
// Find next block
ChainLinkAny<T>* nextLink = NULL;
for (auto i = ++lnit; i < links.end(); i++) {
if (!(*i)->enabled) { continue; }
nextLink = *i;
break;
}
if (nextLink) {
// If a next block exists, change its input
nextLink->setInput(link->getOutput());
}
else {
// If there are no next blocks, change output of outside reader
onOutputChanged.emit(link->getOutput());
}
// Set input of newly enabled link
link->setInput(input);
// If running, start everything
if (running) { start(); }
}
void disable(ChainLinkAny<T>* link) {
// Check that link exists and locate it
auto lnit = std::find(links.begin(), links.end(), link);
if (lnit == links.end()) {
spdlog::error("Could not disable link");
return;
}
// Stop and disable link
link->stop();
link->enabled = false;
// Find its input
stream<T>* input = _input;
for (auto i = links.begin(); i < lnit; i++) {
if (!(*i)->enabled) { continue; }
input = (*i)->getOutput();
}
// Find next block
ChainLinkAny<T>* nextLink = NULL;
for (auto i = ++lnit; i < links.end(); i++) {
if (!(*i)->enabled) { continue; }
nextLink = *i;
break;
}
if (nextLink) {
// If a next block exists, change its input
nextLink->setInput(input);
}
else {
// If there are no next blocks, change output of outside reader
onOutputChanged.emit(input);
}
}
void disableAll() {
if (running) { return; }
for (auto& ln : links) {
disable(ln);
if (!states[ln]) { continue; }
ln->start();
}
}
void setState(ChainLinkAny<T>* link, bool enabled) {
enabled ? enable(link) : disable(link);
}
void setInput(stream<T>* input) {
_input = input;
// Set input of first enabled link
for (auto& ln : links) {
if (!ln->enabled) { continue; }
ln->setInput(_input);
return;
}
// No block found, this means nothing is enabled
onOutputChanged.emit(_input);
}
stream<T>* getOutput() {
stream<T>* lastOutput = _input;
for (auto& ln : links) {
if (!ln->enabled) { continue; }
lastOutput = ln->getOutput();
}
return lastOutput;
}
void start() {
running = true;
for (auto& ln : links) {
if (ln->enabled) {
ln->start();
}
else {
ln->stop();
}
}
}
void stop() {
running = false;
if (!running) { return; }
for (auto& ln : links) {
if (!states[ln]) { continue; }
ln->stop();
}
running = false;
}
Event<stream<T>*> onOutputChanged;
stream<T>* out;
private:
stream<T>* _input;
std::vector<ChainLinkAny<T>*> links;
Processor<T, T>* blockBefore(Processor<T, T>* block) {
for (auto& ln : links) {
if (ln == block) { return NULL; }
if (states[ln]) { return ln; }
}
}
Processor<T, T>* blockAfter(Processor<T, T>* block) {
bool blockFound = false;
for (auto& ln : links) {
if (ln == block) {
blockFound = true;
continue;
}
if (states[ln] && blockFound) { return ln; }
}
return NULL;
}
bool blockExists(Processor<T, T>* block) {
return states.find(block) != states.end();
}
stream<T>* _in;
std::vector<Processor<T, T>*> links;
std::map<Processor<T, T>*, bool> states;
bool running = false;
};
}

255
core/src/dsp/clock_recovery.h
Wyświetl plik

@ -1,255 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/utils/macros.h>
#include <dsp/interpolation_taps.h>
namespace dsp {
class EdgeTrigClockRecovery : public generic_block<EdgeTrigClockRecovery> {
public:
EdgeTrigClockRecovery() {}
EdgeTrigClockRecovery(stream<float>* in, int omega) { init(in, omega); }
void init(stream<float>* in, int omega) {
_in = in;
samplesPerSymbol = omega;
generic_block<EdgeTrigClockRecovery>::registerInput(_in);
generic_block<EdgeTrigClockRecovery>::registerOutput(&out);
generic_block<EdgeTrigClockRecovery>::_block_init = true;
}
void setInput(stream<float>* in) {
assert(generic_block<EdgeTrigClockRecovery>::_block_init);
generic_block<EdgeTrigClockRecovery>::tempStop();
generic_block<EdgeTrigClockRecovery>::unregisterInput(_in);
_in = in;
generic_block<EdgeTrigClockRecovery>::registerInput(_in);
generic_block<EdgeTrigClockRecovery>::tempStart();
}
int run() {
count = _in->read();
if (count < 0) { return -1; }
int outCount = 0;
for (int i = 0; i < count; i++) {
if (DSP_SIGN(lastVal) != DSP_SIGN(_in->readBuf[i])) {
counter = samplesPerSymbol / 2;
lastVal = _in->readBuf[i];
continue;
}
if (counter >= samplesPerSymbol) {
counter = 0;
out.writeBuf[outCount] = _in->readBuf[i];
outCount++;
}
else {
counter++;
}
lastVal = _in->readBuf[i];
}
_in->flush();
if (outCount > 0 && !out.swap(outCount)) { return -1; }
return count;
}
stream<float> out;
private:
int count;
int samplesPerSymbol = 1;
int counter = 0;
float lastVal = 0;
stream<float>* _in;
};
template <class T>
class MMClockRecovery : public generic_block<MMClockRecovery<T>> {
public:
MMClockRecovery() {}
MMClockRecovery(stream<T>* in, float omega, float gainOmega, float muGain, float omegaRelLimit) {
init(in, omega, gainOmega, muGain, omegaRelLimit);
}
void init(stream<T>* in, float omega, float gainOmega, float muGain, float omegaRelLimit) {
_in = in;
_omega = omega;
_muGain = muGain;
_gainOmega = gainOmega;
_omegaRelLimit = omegaRelLimit;
omegaMin = _omega - (_omega * _omegaRelLimit);
omegaMax = _omega + (_omega * _omegaRelLimit);
_dynOmega = _omega;
memset(delay, 0, 1024 * sizeof(T));
generic_block<MMClockRecovery<T>>::registerInput(_in);
generic_block<MMClockRecovery<T>>::registerOutput(&out);
generic_block<MMClockRecovery<T>>::_block_init = true;
}
void setOmega(float omega, float omegaRelLimit) {
assert(generic_block<MMClockRecovery<T>>::_block_init);
generic_block<MMClockRecovery<T>>::tempStop();
omegaMin = _omega - (_omega * _omegaRelLimit);
omegaMax = _omega + (_omega * _omegaRelLimit);
_omega = omega;
_dynOmega = _omega;
generic_block<MMClockRecovery<T>>::tempStart();
}
void setGains(float omegaGain, float muGain) {
assert(generic_block<MMClockRecovery<T>>::_block_init);
generic_block<MMClockRecovery<T>>::tempStop();
_gainOmega = omegaGain;
_muGain = muGain;
generic_block<MMClockRecovery<T>>::tempStart();
}
void setOmegaRelLimit(float omegaRelLimit) {
assert(generic_block<MMClockRecovery<T>>::_block_init);
generic_block<MMClockRecovery<T>>::tempStop();
_omegaRelLimit = omegaRelLimit;
omegaMin = _omega - (_omega * _omegaRelLimit);
omegaMax = _omega + (_omega * _omegaRelLimit);
generic_block<MMClockRecovery<T>>::tempStart();
}
void setInput(stream<T>* in) {
assert(generic_block<MMClockRecovery<T>>::_block_init);
generic_block<MMClockRecovery<T>>::tempStop();
generic_block<MMClockRecovery<T>>::unregisterInput(_in);
_in = in;
generic_block<MMClockRecovery<T>>::registerInput(_in);
generic_block<MMClockRecovery<T>>::tempStart();
}
int run() {
count = _in->read();
if (count < 0) { return -1; }
int outCount = 0;
float outVal;
float phaseError;
float roundedStep;
int maxOut = 2.0f * _omega * (float)count;
// Copy the first 7 values to the delay buffer for fast computing
memcpy(&delay[7], _in->readBuf, 7 * sizeof(T));
int i = nextOffset;
for (; i < count && outCount < maxOut;) {
if constexpr (std::is_same_v<T, float>) {
// Calculate output value
// If we still need to use the old values, calculate using delay buf
// Otherwise, use normal buffer
if (i < 7) {
volk_32f_x2_dot_prod_32f(&outVal, &delay[i], INTERP_TAPS[(int)roundf(_mu * 128.0f)], 8);
}
else {
volk_32f_x2_dot_prod_32f(&outVal, &_in->readBuf[i - 7], INTERP_TAPS[(int)roundf(_mu * 128.0f)], 8);
}
out.writeBuf[outCount++] = outVal;
// Cursed phase detect approximation (don't ask me how this approximation works)
phaseError = (DSP_STEP(lastOutput) * outVal) - (lastOutput * DSP_STEP(outVal));
lastOutput = outVal;
}
if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
// Propagate delay
_p_2T = _p_1T;
_p_1T = _p_0T;
_c_2T = _c_1T;
_c_1T = _c_0T;
// Perform interpolation the same way as for float values
if (i < 7) {
volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&_p_0T, (lv_32fc_t*)&delay[i], INTERP_TAPS[(int)roundf(_mu * 128.0f)], 8);
}
else {
volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&_p_0T, (lv_32fc_t*)&_in->readBuf[i - 7], INTERP_TAPS[(int)roundf(_mu * 128.0f)], 8);
}
out.writeBuf[outCount++] = _p_0T;
// Slice output value
_c_0T = DSP_STEP_CPLX(_p_0T);
// Cursed math to calculate the phase error
phaseError = (((_p_0T - _p_2T) * _c_1T.conj()) - ((_c_0T - _c_2T) * _p_1T.conj())).re;
}
// Clamp phase error
if (phaseError > 1.0f) { phaseError = 1.0f; }
if (phaseError < -1.0f) { phaseError = -1.0f; }
// Adjust the symbol rate using the phase error approximation and clamp
// TODO: Branchless clamp
_dynOmega = _dynOmega + (_gainOmega * phaseError);
if (_dynOmega > omegaMax) { _dynOmega = omegaMax; }
else if (_dynOmega < omegaMin) {
_dynOmega = omegaMin;
}
// Adjust the symbol phase according to the phase error approximation
// It will now contain the phase delta needed to jump to the next symbol
// Rounded step will contain the rounded number of symbols
_mu = _mu + _dynOmega + (_muGain * phaseError);
roundedStep = floor(_mu);
// Step to where the next symbol should be, and check for bogus input
i += (int)roundedStep;
if (i < 0) { i = 0; }
// Now that we've stepped to the next symbol, keep only the offset inside the symbol
_mu -= roundedStep;
}
nextOffset = i - count;
// Save the last 7 values for the next round
memcpy(delay, &_in->readBuf[count - 7], 7 * sizeof(T));
_in->flush();
if (outCount > 0 && !out.swap(outCount)) { return -1; }
return count;
}
stream<T> out;
private:
int count;
// Delay buffer
T delay[1024];
int nextOffset = 0;
// Configuration
float _omega = 1.0f;
float _muGain = 1.0f;
float _gainOmega = 0.001f;
float _omegaRelLimit = 0.005;
// Precalculated values
float omegaMin = _omega + (_omega * _omegaRelLimit);
float omegaMax = _omega + (_omega * _omegaRelLimit);
// Runtime adjusted
float _dynOmega = _omega;
float _mu = 0.5f;
float lastOutput = 0.0f;
// Cursed complex stuff
complex_t _p_0T = { 0, 0 }, _p_1T = { 0, 0 }, _p_2T = { 0, 0 };
complex_t _c_0T = { 0, 0 }, _c_1T = { 0, 0 }, _c_2T = { 0, 0 };
stream<T>* _in;
};
}

160
core/src/dsp/compression.h
Wyświetl plik

@ -1,160 +0,0 @@
#pragma once
#include <dsp/block.h>
namespace dsp {
enum PCMType {
PCM_TYPE_I8,
PCM_TYPE_I16,
PCM_TYPE_F32
};
class DynamicRangeCompressor : public generic_block<DynamicRangeCompressor> {
public:
DynamicRangeCompressor() {}
DynamicRangeCompressor(stream<complex_t>* in, PCMType pcmType) {
init(in, pcmType);
}
void init(stream<complex_t>* in, PCMType pcmType) {
_in = in;
_pcmType = pcmType;
out.setBufferSize((sizeof(dsp::complex_t) * STREAM_BUFFER_SIZE) + 8);
generic_block<DynamicRangeCompressor>::registerInput(_in);
generic_block<DynamicRangeCompressor>::registerOutput(&out);
generic_block<DynamicRangeCompressor>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<DynamicRangeCompressor>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<DynamicRangeCompressor>::ctrlMtx);
generic_block<DynamicRangeCompressor>::tempStop();
generic_block<DynamicRangeCompressor>::unregisterInput(_in);
_in = in;
generic_block<DynamicRangeCompressor>::registerInput(_in);
generic_block<DynamicRangeCompressor>::tempStart();
}
void setPCMType(PCMType pcmType) {
assert(generic_block<DynamicRangeCompressor>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<DynamicRangeCompressor>::ctrlMtx);
_pcmType = pcmType;
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
PCMType type = _pcmType;
uint16_t* compressionType = (uint16_t*)out.writeBuf;
uint16_t* sampleType = (uint16_t*)&out.writeBuf[2];
float* scaler = (float*)&out.writeBuf[4];
void* dataBuf = &out.writeBuf[8];
// Write options and leave blank space for compression
*compressionType = 0;
*sampleType = type;
// If type is float32, no compression is needed
if (type == PCM_TYPE_F32) {
*scaler = 0;
memcpy(dataBuf, _in->readBuf, count * sizeof(complex_t));
_in->flush();
if (!out.swap(8 + (count * sizeof(complex_t)))) { return -1; }
return count;
}
// Find maximum value
uint32_t maxIdx;
volk_32f_index_max_32u(&maxIdx, (float*)_in->readBuf, count * 2);
float maxVal = ((float*)_in->readBuf)[maxIdx];
*scaler = maxVal;
// Convert to the right type and send it out (sign bit determines pcm type)
if (type == PCM_TYPE_I8) {
volk_32f_s32f_convert_8i((int8_t*)dataBuf, (float*)_in->readBuf, 128.0f / maxVal, count * 2);
_in->flush();
if (!out.swap(8 + (count * sizeof(int8_t) * 2))) { return -1; }
}
else if (type == PCM_TYPE_I16) {
volk_32f_s32f_convert_16i((int16_t*)dataBuf, (float*)_in->readBuf, 32768.0f / maxVal, count * 2);
_in->flush();
if (!out.swap(8 + (count * sizeof(int16_t) * 2))) { return -1; }
}
else {
_in->flush();
}
return count;
}
stream<uint8_t> out;
private:
stream<complex_t>* _in;
PCMType _pcmType;
};
class DynamicRangeDecompressor : public generic_block<DynamicRangeDecompressor> {
public:
DynamicRangeDecompressor() {}
DynamicRangeDecompressor(stream<uint8_t>* in) { init(in); }
void init(stream<uint8_t>* in) {
_in = in;
generic_block<DynamicRangeDecompressor>::registerInput(_in);
generic_block<DynamicRangeDecompressor>::registerOutput(&out);
generic_block<DynamicRangeDecompressor>::_block_init = true;
}
void setInput(stream<uint8_t>* in) {
assert(generic_block<DynamicRangeDecompressor>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<DynamicRangeDecompressor>::ctrlMtx);
generic_block<DynamicRangeDecompressor>::tempStop();
generic_block<DynamicRangeDecompressor>::unregisterInput(_in);
_in = in;
generic_block<DynamicRangeDecompressor>::registerInput(_in);
generic_block<DynamicRangeDecompressor>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
uint16_t sampleType = *(uint16_t*)&_in->readBuf[2];
float scaler = *(float*)&_in->readBuf[4];
void* dataBuf = &_in->readBuf[8];
if (sampleType == PCM_TYPE_F32) {
memcpy(out.writeBuf, dataBuf, count - 8);
_in->flush();
if (!out.swap((count - 8) / sizeof(complex_t))) { return -1; }
}
else if (sampleType == PCM_TYPE_I16) {
int outCount = (count - 8) / (sizeof(int16_t) * 2);
volk_16i_s32f_convert_32f((float*)out.writeBuf, (int16_t*)dataBuf, 32768.0f / scaler, outCount * 2);
_in->flush();
if (!out.swap(outCount)) { return -1; }
}
else if (sampleType == PCM_TYPE_I8) {
int outCount = (count - 8) / (sizeof(int8_t) * 2);
volk_8i_s32f_convert_32f((float*)out.writeBuf, (int8_t*)dataBuf, 128.0f / scaler, outCount * 2);
_in->flush();
if (!out.swap(outCount)) { return -1; }
}
else {
_in->flush();
}
return count;
}
stream<complex_t> out;
private:
stream<uint8_t>* _in;
};
}

337
core/src/dsp/conversion.h
Wyświetl plik

@ -1,337 +0,0 @@
#pragma once
#include <dsp/block.h>
namespace dsp {
class ComplexToStereo : public generic_block<ComplexToStereo> {
public:
ComplexToStereo() {}
ComplexToStereo(stream<complex_t>* in) { init(in); }
static_assert(sizeof(complex_t) == sizeof(stereo_t));
void init(stream<complex_t>* in) {
_in = in;
generic_block<ComplexToStereo>::registerInput(_in);
generic_block<ComplexToStereo>::registerOutput(&out);
generic_block<ComplexToStereo>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<ComplexToStereo>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<ComplexToStereo>::ctrlMtx);
generic_block<ComplexToStereo>::tempStop();
generic_block<ComplexToStereo>::unregisterInput(_in);
_in = in;
generic_block<ComplexToStereo>::registerInput(_in);
generic_block<ComplexToStereo>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
memcpy(out.writeBuf, _in->readBuf, count * sizeof(complex_t));
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<stereo_t> out;
private:
stream<complex_t>* _in;
};
class ComplexToReal : public generic_block<ComplexToReal> {
public:
ComplexToReal() {}
ComplexToReal(stream<complex_t>* in) { init(in); }
void init(stream<complex_t>* in) {
_in = in;
generic_block<ComplexToReal>::registerInput(_in);
generic_block<ComplexToReal>::registerOutput(&out);
generic_block<ComplexToReal>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<ComplexToReal>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<ComplexToReal>::ctrlMtx);
generic_block<ComplexToReal>::tempStop();
generic_block<ComplexToReal>::unregisterInput(_in);
_in = in;
generic_block<ComplexToReal>::registerInput(_in);
generic_block<ComplexToReal>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32fc_deinterleave_real_32f(out.writeBuf, (lv_32fc_t*)_in->readBuf, count);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<float> out;
private:
stream<complex_t>* _in;
};
class ComplexToImag : public generic_block<ComplexToImag> {
public:
ComplexToImag() {}
ComplexToImag(stream<complex_t>* in) { init(in); }
void init(stream<complex_t>* in) {
_in = in;
generic_block<ComplexToImag>::registerInput(_in);
generic_block<ComplexToImag>::registerOutput(&out);
generic_block<ComplexToImag>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<ComplexToImag>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<ComplexToImag>::ctrlMtx);
generic_block<ComplexToImag>::tempStop();
generic_block<ComplexToImag>::unregisterInput(_in);
_in = in;
generic_block<ComplexToImag>::registerInput(_in);
generic_block<ComplexToImag>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32fc_deinterleave_imag_32f(out.writeBuf, (lv_32fc_t*)_in->readBuf, count);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<float> out;
private:
stream<complex_t>* _in;
};
class RealToComplex : public generic_block<RealToComplex> {
public:
RealToComplex() {}
RealToComplex(stream<float>* in) { init(in); }
~RealToComplex() {
if (!generic_block<RealToComplex>::_block_init) { return; }
generic_block<RealToComplex>::stop();
delete[] nullBuffer;
generic_block<RealToComplex>::_block_init = false;
}
void init(stream<float>* in) {
_in = in;
nullBuffer = new float[STREAM_BUFFER_SIZE];
memset(nullBuffer, 0, STREAM_BUFFER_SIZE * sizeof(float));
generic_block<RealToComplex>::registerInput(_in);
generic_block<RealToComplex>::registerOutput(&out);
generic_block<RealToComplex>::_block_init = true;
}
void setInput(stream<float>* in) {
assert(generic_block<RealToComplex>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<RealToComplex>::ctrlMtx);
generic_block<RealToComplex>::tempStop();
generic_block<RealToComplex>::unregisterInput(_in);
_in = in;
generic_block<RealToComplex>::registerInput(_in);
generic_block<RealToComplex>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32f_x2_interleave_32fc((lv_32fc_t*)out.writeBuf, _in->readBuf, nullBuffer, count);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
private:
float* nullBuffer;
stream<float>* _in;
};
class Int16CToComplex : public generic_block<Int16CToComplex> {
public:
Int16CToComplex() {}
Int16CToComplex(stream<int16_t>* in) { init(in); }
void init(stream<int16_t>* in) {
_in = in;
generic_block<Int16CToComplex>::registerInput(_in);
generic_block<Int16CToComplex>::registerOutput(&out);
generic_block<Int16CToComplex>::_block_init = true;
}
void setInput(stream<int16_t>* in) {
assert(generic_block<Int16CToComplex>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Int16CToComplex>::ctrlMtx);
generic_block<Int16CToComplex>::tempStop();
generic_block<Int16CToComplex>::unregisterInput(_in);
_in = in;
generic_block<Int16CToComplex>::registerInput(_in);
generic_block<Int16CToComplex>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_16i_s32f_convert_32f((float*)out.writeBuf, _in->readBuf, 32768.0f, count * 2);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
private:
stream<int16_t>* _in;
};
class ComplexToInt16C : public generic_block<ComplexToInt16C> {
public:
ComplexToInt16C() {}
ComplexToInt16C(stream<complex_t>* in) { init(in); }
void init(stream<complex_t>* in) {
_in = in;
generic_block<ComplexToInt16C>::registerInput(_in);
generic_block<ComplexToInt16C>::registerOutput(&out);
generic_block<ComplexToInt16C>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<ComplexToInt16C>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<ComplexToInt16C>::ctrlMtx);
generic_block<ComplexToInt16C>::tempStop();
generic_block<ComplexToInt16C>::unregisterInput(_in);
_in = in;
generic_block<ComplexToInt16C>::registerInput(_in);
generic_block<ComplexToInt16C>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32f_s32f_convert_16i(out.writeBuf, (float*)_in->readBuf, 32768.0f, count * 2);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<int16_t> out;
private:
stream<complex_t>* _in;
};
class Int16ToFloat : public generic_block<Int16ToFloat> {
public:
Int16ToFloat() {}
Int16ToFloat(stream<int16_t>* in) { init(in); }
void init(stream<int16_t>* in) {
_in = in;
generic_block<Int16ToFloat>::registerInput(_in);
generic_block<Int16ToFloat>::registerOutput(&out);
generic_block<Int16ToFloat>::_block_init = true;
}
void setInput(stream<int16_t>* in) {
assert(generic_block<Int16ToFloat>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Int16ToFloat>::ctrlMtx);
generic_block<Int16ToFloat>::tempStop();
generic_block<Int16ToFloat>::unregisterInput(_in);
_in = in;
generic_block<Int16ToFloat>::registerInput(_in);
generic_block<Int16ToFloat>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_16i_s32f_convert_32f(out.writeBuf, _in->readBuf, 32768.0f, count);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<float> out;
private:
stream<int16_t>* _in;
};
class FloatToInt16 : public generic_block<FloatToInt16> {
public:
FloatToInt16() {}
FloatToInt16(stream<float>* in) { init(in); }
void init(stream<float>* in) {
_in = in;
generic_block<FloatToInt16>::registerInput(_in);
generic_block<FloatToInt16>::registerOutput(&out);
generic_block<FloatToInt16>::_block_init = true;
}
void setInput(stream<float>* in) {
assert(generic_block<FloatToInt16>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FloatToInt16>::ctrlMtx);
generic_block<FloatToInt16>::tempStop();
generic_block<FloatToInt16>::unregisterInput(_in);
_in = in;
generic_block<FloatToInt16>::registerInput(_in);
generic_block<FloatToInt16>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32f_s32f_convert_16i(out.writeBuf, _in->readBuf, 32768.0f, count);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<int16_t> out;
private:
stream<float>* _in;
};
}

142
core/src/dsp/correction.h
Wyświetl plik

@ -1,142 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/stream.h>
#include <dsp/types.h>
#include <dsp/window.h>
namespace dsp {
class IQCorrector : public generic_block<IQCorrector> {
public:
IQCorrector() {}
IQCorrector(stream<complex_t>* in, float rate) { init(in, rate); }
void init(stream<complex_t>* in, float rate) {
_in = in;
correctionRate = rate;
offset.re = 0;
offset.im = 0;
generic_block<IQCorrector>::registerInput(_in);
generic_block<IQCorrector>::registerOutput(&out);
generic_block<IQCorrector>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<IQCorrector>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<IQCorrector>::ctrlMtx);
generic_block<IQCorrector>::tempStop();
generic_block<IQCorrector>::unregisterInput(_in);
_in = in;
generic_block<IQCorrector>::registerInput(_in);
generic_block<IQCorrector>::tempStart();
}
void setCorrectionRate(float rate) {
correctionRate = rate;
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
if (bypass) {
memcpy(out.writeBuf, _in->readBuf, count * sizeof(complex_t));
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
for (int i = 0; i < count; i++) {
out.writeBuf[i] = _in->readBuf[i] - offset;
offset = offset + (out.writeBuf[i] * correctionRate);
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
// TEMPORARY FOR DEBUG PURPOSES
bool bypass = false;
complex_t offset;
private:
stream<complex_t>* _in;
float correctionRate = 0.00001;
};
class DCBlocker : public generic_block<DCBlocker> {
public:
DCBlocker() {}
DCBlocker(stream<float>* in, float rate) { init(in, rate); }
void init(stream<float>* in, float rate) {
_in = in;
correctionRate = rate;
offset = 0;
generic_block<DCBlocker>::registerInput(_in);
generic_block<DCBlocker>::registerOutput(&out);
generic_block<DCBlocker>::_block_init = true;
}
void setInput(stream<float>* in) {
assert(generic_block<DCBlocker>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<DCBlocker>::ctrlMtx);
generic_block<DCBlocker>::tempStop();
generic_block<DCBlocker>::unregisterInput(_in);
_in = in;
generic_block<DCBlocker>::registerInput(_in);
generic_block<DCBlocker>::tempStart();
}
void setCorrectionRate(float rate) {
correctionRate = rate;
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
if (bypass) {
memcpy(out.writeBuf, _in->readBuf, count * sizeof(complex_t));
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
for (int i = 0; i < count; i++) {
out.writeBuf[i] = _in->readBuf[i] - offset;
offset = offset + (out.writeBuf[i] * correctionRate);
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<float> out;
// TEMPORARY FOR DEBUG PURPOSES
bool bypass = false;
float offset;
private:
stream<float>* _in;
float correctionRate = 0.00001;
};
}

106
core/src/dsp/decimation.h
Wyświetl plik

@ -1,106 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/stream.h>
#include <dsp/types.h>
#include <dsp/window.h>
namespace dsp {
template <class T>
class HalfDecimator : public generic_block<HalfDecimator<T>> {
public:
HalfDecimator() {}
HalfDecimator(stream<T>* in, dsp::filter_window::generic_window* window) { init(in, window); }
~HalfDecimator() {
if (!generic_block<HalfDecimator<T>>::_block_init) { return; }
generic_block<HalfDecimator<T>>::stop();
volk_free(buffer);
volk_free(taps);
generic_block<HalfDecimator<T>>::_block_init = false;
}
void init(stream<T>* in, dsp::filter_window::generic_window* window) {
_in = in;
tapCount = window->getTapCount();
taps = (float*)volk_malloc(tapCount * sizeof(float), volk_get_alignment());
window->createTaps(taps, tapCount);
buffer = (T*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(T) * 2, volk_get_alignment());
bufStart = &buffer[tapCount];
generic_block<HalfDecimator<T>>::registerInput(_in);
generic_block<HalfDecimator<T>>::registerOutput(&out);
generic_block<HalfDecimator<T>>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<HalfDecimator<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<HalfDecimator<T>>::ctrlMtx);
generic_block<HalfDecimator<T>>::tempStop();
generic_block<HalfDecimator<T>>::unregisterInput(_in);
_in = in;
generic_block<HalfDecimator<T>>::registerInput(_in);
generic_block<HalfDecimator<T>>::tempStart();
}
void updateWindow(dsp::filter_window::generic_window* window) {
assert(generic_block<HalfDecimator<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<HalfDecimator<T>>::ctrlMtx);
std::lock_guard<std::mutex> lck2(bufMtx);
_window = window;
volk_free(taps);
tapCount = window->getTapCount();
taps = (float*)volk_malloc(tapCount * sizeof(float), volk_get_alignment());
bufStart = &buffer[tapCount];
window->createTaps(taps, tapCount);
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
memcpy(bufStart, _in->readBuf, count * sizeof(T));
_in->flush();
int inIndex = _inIndex;
int outIndex = 0;
if constexpr (std::is_same_v<T, float>) {
while (inIndex < count) {
volk_32f_x2_dot_prod_32f((float*)&out.writeBuf[outIndex], (float*)&buffer[inIndex + 1], taps, tapCount);
inIndex += 2;
outIndex++;
}
}
if constexpr (std::is_same_v<T, complex_t>) {
while (inIndex < count) {
volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&out.writeBuf[outIndex], (lv_32fc_t*)&buffer[inIndex + 1], taps, tapCount);
inIndex += 2;
outIndex++;
}
}
_inIndex = inIndex - count;
if (!out.swap(outIndex)) { return -1; }
memmove(buffer, &buffer[count], tapCount * sizeof(T));
return count;
}
stream<T> out;
private:
stream<T>* _in;
dsp::filter_window::generic_window* _window;
std::mutex bufMtx;
T* bufStart;
T* buffer;
int tapCount;
float* taps;
int _inIndex = 0;
};
}

414
core/src/dsp/deframing.h
Wyświetl plik

@ -1,414 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <inttypes.h>
#define DSP_SIGN(n) ((n) >= 0)
#define DSP_STEP(n) (((n) > 0.0f) ? 1.0f : -1.0f)
namespace dsp {
class Deframer : public generic_block<Deframer> {
public:
Deframer() {}
Deframer(stream<uint8_t>* in, int frameLen, uint8_t* syncWord, int syncLen) { init(in, frameLen, syncWord, syncLen); }
~Deframer() {
if (!generic_block<Deframer>::_block_init) { return; }
generic_block<Deframer>::stop();
generic_block<Deframer>::_block_init = false;
}
void init(stream<uint8_t>* in, int frameLen, uint8_t* syncWord, int syncLen) {
_in = in;
_frameLen = frameLen;
_syncword = new uint8_t[syncLen];
_syncLen = syncLen;
memcpy(_syncword, syncWord, syncLen);
buffer = new uint8_t[STREAM_BUFFER_SIZE + syncLen];
memset(buffer, 0, syncLen);
bufferStart = buffer + syncLen;
generic_block<Deframer>::registerInput(_in);
generic_block<Deframer>::registerOutput(&out);
generic_block<Deframer>::_block_init = true;
}
void setInput(stream<uint8_t>* in) {
assert(generic_block<Deframer>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Deframer>::ctrlMtx);
generic_block<Deframer>::tempStop();
generic_block<Deframer>::unregisterInput(_in);
_in = in;
generic_block<Deframer>::registerInput(_in);
generic_block<Deframer>::tempStart();
}
int run() {
count = _in->read();
if (count < 0) { return -1; }
// Copy data into work buffer
memcpy(bufferStart, _in->readBuf, count - 1);
// Iterate through all symbols
for (int i = 0; i < count;) {
// If already in the process of reading bits
if (bitsRead >= 0) {
if ((bitsRead % 8) == 0) { out.writeBuf[bitsRead / 8] = 0; }
out.writeBuf[bitsRead / 8] |= (buffer[i] << (7 - (bitsRead % 8)));
i++;
bitsRead++;
if (bitsRead >= _frameLen) {
if (!out.swap((bitsRead / 8) + ((bitsRead % 8) > 0))) { return -1; }
bitsRead = -1;
if (allowSequential) { nextBitIsStartOfFrame = true; }
}
continue;
}
// Else, check for a header
else if (memcmp(buffer + i, _syncword, _syncLen) == 0) {
bitsRead = 0;
//printf("Frame found!\n");
badFrameCount = 0;
continue;
}
else if (nextBitIsStartOfFrame) {
nextBitIsStartOfFrame = false;
// try to save
if (badFrameCount < 5) {
badFrameCount++;
//printf("Frame found!\n");
bitsRead = 0;
continue;
}
}
else {
i++;
}
nextBitIsStartOfFrame = false;
}
// Keep last _syncLen4 symbols
memcpy(buffer, &_in->readBuf[count - _syncLen], _syncLen);
//printf("Block processed\n");
callcount++;
_in->flush();
return count;
}
bool allowSequential = true;
stream<uint8_t> out;
private:
uint8_t* buffer;
uint8_t* bufferStart;
uint8_t* _syncword;
int count;
int _frameLen;
int _syncLen;
int bitsRead = -1;
int badFrameCount = 5;
bool nextBitIsStartOfFrame = false;
int callcount = 0;
stream<uint8_t>* _in;
};
inline int MachesterHammingDistance(float* data, uint8_t* syncBits, int n) {
int dist = 0;
for (int i = 0; i < n; i++) {
if ((data[(2 * i) + 1] > data[2 * i]) != syncBits[i]) { dist++; }
}
return dist;
}
inline int HammingDistance(uint8_t* data, uint8_t* syncBits, int n) {
int dist = 0;
for (int i = 0; i < n; i++) {
if (data[i] != syncBits[i]) { dist++; }
}
return dist;
}
class ManchesterDeframer : public generic_block<ManchesterDeframer> {
public:
ManchesterDeframer() {}
ManchesterDeframer(stream<float>* in, int frameLen, uint8_t* syncWord, int syncLen) { init(in, frameLen, syncWord, syncLen); }
void init(stream<float>* in, int frameLen, uint8_t* syncWord, int syncLen) {
_in = in;
_frameLen = frameLen;
_syncword = new uint8_t[syncLen];
_syncLen = syncLen;
memcpy(_syncword, syncWord, syncLen);
buffer = new float[STREAM_BUFFER_SIZE + (syncLen * 2)];
memset(buffer, 0, syncLen * 2 * sizeof(float));
bufferStart = &buffer[syncLen * 2];
generic_block<ManchesterDeframer>::registerInput(_in);
generic_block<ManchesterDeframer>::registerOutput(&out);
generic_block<ManchesterDeframer>::_block_init = true;
}
void setInput(stream<float>* in) {
assert(generic_block<ManchesterDeframer>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<ManchesterDeframer>::ctrlMtx);
generic_block<ManchesterDeframer>::tempStop();
generic_block<ManchesterDeframer>::unregisterInput(_in);
_in = in;
generic_block<ManchesterDeframer>::registerInput(_in);
generic_block<ManchesterDeframer>::tempStart();
}
int run() {
count = _in->read();
if (count < 0) { return -1; }
int readable;
// Copy data into work buffer
memcpy(bufferStart, _in->readBuf, (count - 1) * sizeof(float));
// Iterate through all symbols
for (int i = 0; i < count;) {
// If already in the process of reading bits
if (bitsRead >= 0) {
readable = std::min<int>(count - i, _frameLen - bitsRead);
memcpy(&out.writeBuf[bitsRead], &buffer[i], readable * sizeof(float));
bitsRead += readable;
i += readable;
if (bitsRead >= _frameLen) {
out.swap(_frameLen);
bitsRead = -1;
}
continue;
}
// Else, check for a header
if (MachesterHammingDistance(&buffer[i], _syncword, _syncLen) <= 2) {
bitsRead = 0;
continue;
}
i++;
}
// Keep last _syncLen symbols
memcpy(buffer, &_in->readBuf[count - (_syncLen * 2)], _syncLen * 2 * sizeof(float));
_in->flush();
return count;
}
stream<float> out;
private:
float* buffer;
float* bufferStart;
uint8_t* _syncword;
int count;
int _frameLen;
int _syncLen;
int bitsRead = -1;
stream<float>* _in;
};
class SymbolDeframer : public generic_block<SymbolDeframer> {
public:
SymbolDeframer() {}
SymbolDeframer(stream<uint8_t>* in, int frameLen, uint8_t* syncWord, int syncLen) { init(in, frameLen, syncWord, syncLen); }
void init(stream<uint8_t>* in, int frameLen, uint8_t* syncWord, int syncLen) {
_in = in;
_frameLen = frameLen;
_syncword = new uint8_t[syncLen];
_syncLen = syncLen;
memcpy(_syncword, syncWord, syncLen);
buffer = new uint8_t[STREAM_BUFFER_SIZE + syncLen];
memset(buffer, 0, syncLen);
bufferStart = &buffer[syncLen];
generic_block<SymbolDeframer>::registerInput(_in);
generic_block<SymbolDeframer>::registerOutput(&out);
generic_block<SymbolDeframer>::_block_init = true;
}
void setInput(stream<uint8_t>* in) {
assert(generic_block<SymbolDeframer>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<SymbolDeframer>::ctrlMtx);
generic_block<SymbolDeframer>::tempStop();
generic_block<SymbolDeframer>::unregisterInput(_in);
_in = in;
generic_block<SymbolDeframer>::registerInput(_in);
generic_block<SymbolDeframer>::tempStart();
}
int run() {
count = _in->read();
if (count < 0) { return -1; }
int readable;
// Copy data into work buffer
memcpy(bufferStart, _in->readBuf, count - 1);
// Iterate through all symbols
for (int i = 0; i < count;) {
// If already in the process of reading bits
if (bitsRead >= 0) {
readable = std::min<int>(count - i, _frameLen - bitsRead);
memcpy(&out.writeBuf[bitsRead], &buffer[i], readable);
bitsRead += readable;
i += readable;
if (bitsRead >= _frameLen) {
out.swap(_frameLen);
bitsRead = -1;
}
continue;
}
// Else, check for a header
if (HammingDistance(&buffer[i], _syncword, _syncLen) <= 2) {
bitsRead = 0;
continue;
}
i++;
}
// Keep last _syncLen symbols
memcpy(buffer, &_in->readBuf[count - _syncLen], _syncLen);
_in->flush();
return count;
}
stream<uint8_t> out;
private:
uint8_t* buffer;
uint8_t* bufferStart;
uint8_t* _syncword;
int count;
int _frameLen;
int _syncLen;
int bitsRead = -1;
stream<uint8_t>* _in;
};
class ManchesterDecoder : public generic_block<ManchesterDecoder> {
public:
ManchesterDecoder() {}
ManchesterDecoder(stream<float>* in, bool inverted) { init(in, inverted); }
void init(stream<float>* in, bool inverted) {
_in = in;
_inverted = inverted;
generic_block<ManchesterDecoder>::registerInput(_in);
generic_block<ManchesterDecoder>::registerOutput(&out);
generic_block<ManchesterDecoder>::_block_init = true;
}
void setInput(stream<float>* in) {
assert(generic_block<ManchesterDecoder>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<ManchesterDecoder>::ctrlMtx);
generic_block<ManchesterDecoder>::tempStop();
generic_block<ManchesterDecoder>::unregisterInput(_in);
_in = in;
generic_block<ManchesterDecoder>::registerInput(_in);
generic_block<ManchesterDecoder>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
if (_inverted) {
for (int i = 0; i < count; i += 2) {
out.writeBuf[i / 2] = (_in->readBuf[i + 1] < _in->readBuf[i]);
}
}
else {
for (int i = 0; i < count; i += 2) {
out.writeBuf[i / 2] = (_in->readBuf[i + 1] > _in->readBuf[i]);
}
}
_in->flush();
out.swap(count / 2);
return count;
}
stream<uint8_t> out;
private:
stream<float>* _in;
bool _inverted;
};
class BitPacker : public generic_block<BitPacker> {
public:
BitPacker() {}
BitPacker(stream<uint8_t>* in) { init(in); }
void init(stream<uint8_t>* in) {
_in = in;
generic_block<BitPacker>::registerInput(_in);
generic_block<BitPacker>::registerOutput(&out);
generic_block<BitPacker>::_block_init = true;
}
void setInput(stream<uint8_t>* in) {
assert(generic_block<BitPacker>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<BitPacker>::ctrlMtx);
generic_block<BitPacker>::tempStop();
generic_block<BitPacker>::unregisterInput(_in);
_in = in;
generic_block<BitPacker>::registerInput(_in);
generic_block<BitPacker>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
for (int i = 0; i < count; i++) {
if ((i % 8) == 0) { out.writeBuf[i / 8] = 0; }
out.writeBuf[i / 8] |= (_in->readBuf[i] & 1) << (7 - (i % 8));
}
_in->flush();
out.swap((count / 8) + (((count % 8) == 0) ? 0 : 1));
return count;
}
stream<uint8_t> out;
private:
stream<uint8_t>* _in;
};
}

834
core/src/dsp/demodulator.h
Wyświetl plik

@ -1,834 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <volk/volk.h>
#include <dsp/filter.h>
#include <dsp/processing.h>
#include <dsp/routing.h>
#include <spdlog/spdlog.h>
#include <dsp/pll.h>
#include <dsp/clock_recovery.h>
#include <dsp/math.h>
#include <dsp/conversion.h>
#include <dsp/audio.h>
#include <dsp/stereo_fm.h>
#include <dsp/correction.h>
#define FAST_ATAN2_COEF1 FL_M_PI / 4.0f
#define FAST_ATAN2_COEF2 3.0f * FAST_ATAN2_COEF1
inline float fast_arctan2(float y, float x) {
float abs_y = fabsf(y);
float r, angle;
if (x == 0.0f && y == 0.0f) { return 0.0f; }
if (x >= 0.0f) {
r = (x - abs_y) / (x + abs_y);
angle = FAST_ATAN2_COEF1 - FAST_ATAN2_COEF1 * r;
}
else {
r = (x + abs_y) / (abs_y - x);
angle = FAST_ATAN2_COEF2 - FAST_ATAN2_COEF1 * r;
}
if (y < 0.0f) {
return -angle;
}
return angle;
}
namespace dsp {
class FloatFMDemod : public generic_block<FloatFMDemod> {
public:
FloatFMDemod() {}
FloatFMDemod(stream<complex_t>* in, float sampleRate, float deviation) { init(in, sampleRate, deviation); }
void init(stream<complex_t>* in, float sampleRate, float deviation) {
_in = in;
_sampleRate = sampleRate;
_deviation = deviation;
phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
generic_block<FloatFMDemod>::registerInput(_in);
generic_block<FloatFMDemod>::registerOutput(&out);
generic_block<FloatFMDemod>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<FloatFMDemod>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FloatFMDemod>::ctrlMtx);
generic_block<FloatFMDemod>::tempStop();
generic_block<FloatFMDemod>::unregisterInput(_in);
_in = in;
generic_block<FloatFMDemod>::registerInput(_in);
generic_block<FloatFMDemod>::tempStart();
}
void setSampleRate(float sampleRate) {
assert(generic_block<FloatFMDemod>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FloatFMDemod>::ctrlMtx);
generic_block<FloatFMDemod>::tempStop();
_sampleRate = sampleRate;
phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
generic_block<FloatFMDemod>::tempStart();
}
float getSampleRate() {
assert(generic_block<FloatFMDemod>::_block_init);
return _sampleRate;
}
void setDeviation(float deviation) {
assert(generic_block<FloatFMDemod>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FloatFMDemod>::ctrlMtx);
generic_block<FloatFMDemod>::tempStop();
_deviation = deviation;
phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
generic_block<FloatFMDemod>::tempStart();
}
float getDeviation() {
assert(generic_block<FloatFMDemod>::_block_init);
return _deviation;
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
// This is somehow faster than volk...
float diff, currentPhase;
for (int i = 0; i < count; i++) {
currentPhase = fast_arctan2(_in->readBuf[i].im, _in->readBuf[i].re);
diff = currentPhase - phase;
if (diff > 3.1415926535f) { diff -= 2 * 3.1415926535f; }
else if (diff <= -3.1415926535f) {
diff += 2 * 3.1415926535f;
}
out.writeBuf[i] = diff / phasorSpeed;
phase = currentPhase;
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<float> out;
private:
float phase = 0;
float phasorSpeed, _sampleRate, _deviation;
stream<complex_t>* _in;
};
class FMDemod : public generic_block<FMDemod> {
public:
FMDemod() {}
FMDemod(stream<complex_t>* in, float sampleRate, float deviation) { init(in, sampleRate, deviation); }
void init(stream<complex_t>* in, float sampleRate, float deviation) {
_in = in;
_sampleRate = sampleRate;
_deviation = deviation;
phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
generic_block<FMDemod>::registerInput(_in);
generic_block<FMDemod>::registerOutput(&out);
generic_block<FMDemod>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<FMDemod>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FMDemod>::ctrlMtx);
generic_block<FMDemod>::tempStop();
generic_block<FMDemod>::unregisterInput(_in);
_in = in;
generic_block<FMDemod>::registerInput(_in);
generic_block<FMDemod>::tempStart();
}
void setSampleRate(float sampleRate) {
assert(generic_block<FMDemod>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FMDemod>::ctrlMtx);
generic_block<FMDemod>::tempStop();
_sampleRate = sampleRate;
phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
generic_block<FMDemod>::tempStart();
}
float getSampleRate() {
assert(generic_block<FMDemod>::_block_init);
return _sampleRate;
}
void setDeviation(float deviation) {
assert(generic_block<FMDemod>::_block_init);
_deviation = deviation;
phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
}
float getDeviation() {
assert(generic_block<FMDemod>::_block_init);
return _deviation;
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
// This is somehow faster than volk...
float diff, currentPhase;
for (int i = 0; i < count; i++) {
currentPhase = fast_arctan2(_in->readBuf[i].im, _in->readBuf[i].re);
diff = currentPhase - phase;
if (diff > 3.1415926535f) { diff -= 2 * 3.1415926535f; }
else if (diff <= -3.1415926535f) {
diff += 2 * 3.1415926535f;
}
out.writeBuf[i].l = diff / phasorSpeed;
out.writeBuf[i].r = diff / phasorSpeed;
phase = currentPhase;
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<stereo_t> out;
private:
float phase = 0;
float phasorSpeed, _sampleRate, _deviation;
stream<complex_t>* _in;
};
class AMDemod : public generic_block<AMDemod> {
public:
AMDemod() {}
AMDemod(stream<complex_t>* in) { init(in); }
void init(stream<complex_t>* in) {
_in = in;
generic_block<AMDemod>::registerInput(_in);
generic_block<AMDemod>::registerOutput(&out);
generic_block<AMDemod>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<AMDemod>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<AMDemod>::ctrlMtx);
generic_block<AMDemod>::tempStop();
generic_block<AMDemod>::unregisterInput(_in);
_in = in;
generic_block<AMDemod>::registerInput(_in);
generic_block<AMDemod>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32fc_magnitude_32f(out.writeBuf, (lv_32fc_t*)_in->readBuf, count);
_in->flush();
for (int i = 0; i < count; i++) {
out.writeBuf[i] -= avg;
avg += out.writeBuf[i] * 10e-4;
}
if (!out.swap(count)) { return -1; }
return count;
}
stream<float> out;
private:
stream<complex_t>* _in;
float avg = 0;
};
class SSBDemod : public generic_block<SSBDemod> {
public:
SSBDemod() {}
SSBDemod(stream<complex_t>* in, float sampleRate, float bandWidth, int mode) { init(in, sampleRate, bandWidth, mode); }
~SSBDemod() {
if (!generic_block<SSBDemod>::_block_init) { return; }
generic_block<SSBDemod>::stop();
delete[] buffer;
generic_block<SSBDemod>::_block_init = false;
}
enum {
MODE_USB,
MODE_LSB,
MODE_DSB
};
void init(stream<complex_t>* in, float sampleRate, float bandWidth, int mode) {
_in = in;
_sampleRate = sampleRate;
_bandWidth = bandWidth;
_mode = mode;
phase = lv_cmake(1.0f, 0.0f);
switch (_mode) {
case MODE_USB:
phaseDelta = lv_cmake(std::cos((_bandWidth / _sampleRate) * FL_M_PI), std::sin((_bandWidth / _sampleRate) * FL_M_PI));
break;
case MODE_LSB:
phaseDelta = lv_cmake(std::cos(-(_bandWidth / _sampleRate) * FL_M_PI), std::sin(-(_bandWidth / _sampleRate) * FL_M_PI));
break;
case MODE_DSB:
phaseDelta = lv_cmake(1.0f, 0.0f);
break;
}
buffer = new lv_32fc_t[STREAM_BUFFER_SIZE];
generic_block<SSBDemod>::registerInput(_in);
generic_block<SSBDemod>::registerOutput(&out);
generic_block<SSBDemod>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<SSBDemod>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<SSBDemod>::ctrlMtx);
generic_block<SSBDemod>::tempStop();
generic_block<SSBDemod>::unregisterInput(_in);
_in = in;
generic_block<SSBDemod>::registerInput(_in);
generic_block<SSBDemod>::tempStart();
}
void setSampleRate(float sampleRate) {
assert(generic_block<SSBDemod>::_block_init);
_sampleRate = sampleRate;
switch (_mode) {
case MODE_USB:
phaseDelta = lv_cmake(std::cos((_bandWidth / _sampleRate) * FL_M_PI), std::sin((_bandWidth / _sampleRate) * FL_M_PI));
break;
case MODE_LSB:
phaseDelta = lv_cmake(std::cos(-(_bandWidth / _sampleRate) * FL_M_PI), std::sin(-(_bandWidth / _sampleRate) * FL_M_PI));
break;
case MODE_DSB:
phaseDelta = lv_cmake(1.0f, 0.0f);
break;
}
}
void setBandWidth(float bandWidth) {
assert(generic_block<SSBDemod>::_block_init);
_bandWidth = bandWidth;
switch (_mode) {
case MODE_USB:
phaseDelta = lv_cmake(std::cos((_bandWidth / _sampleRate) * FL_M_PI), std::sin((_bandWidth / _sampleRate) * FL_M_PI));
break;
case MODE_LSB:
phaseDelta = lv_cmake(std::cos(-(_bandWidth / _sampleRate) * FL_M_PI), std::sin(-(_bandWidth / _sampleRate) * FL_M_PI));
break;
case MODE_DSB:
phaseDelta = lv_cmake(1.0f, 0.0f);
break;
}
}
void setMode(int mode) {
assert(generic_block<SSBDemod>::_block_init);
_mode = mode;
switch (_mode) {
case MODE_USB:
phaseDelta = lv_cmake(std::cos((_bandWidth / _sampleRate) * FL_M_PI), std::sin((_bandWidth / _sampleRate) * FL_M_PI));
break;
case MODE_LSB:
phaseDelta = lv_cmake(std::cos(-(_bandWidth / _sampleRate) * FL_M_PI), std::sin(-(_bandWidth / _sampleRate) * FL_M_PI));
break;
case MODE_DSB:
phaseDelta = lv_cmake(1.0f, 0.0f);
break;
}
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32fc_s32fc_x2_rotator_32fc(buffer, (lv_32fc_t*)_in->readBuf, phaseDelta, &phase, count);
volk_32fc_deinterleave_real_32f(out.writeBuf, buffer, count);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<float> out;
private:
int _mode;
float _sampleRate, _bandWidth;
stream<complex_t>* _in;
lv_32fc_t* buffer;
lv_32fc_t phase;
lv_32fc_t phaseDelta;
};
class FSKDemod : public generic_hier_block<FSKDemod> {
public:
FSKDemod() {}
FSKDemod(stream<complex_t>* input, float sampleRate, float deviation, float baudRate, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
init(input, sampleRate, deviation, baudRate, omegaGain, muGain, omegaRelLimit);
}
void init(stream<complex_t>* input, float sampleRate, float deviation, float baudRate, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
_sampleRate = sampleRate;
_deviation = deviation;
_baudRate = baudRate;
_omegaGain = omegaGain;
_muGain = muGain;
_omegaRelLimit = omegaRelLimit;
demod.init(input, _sampleRate, _deviation);
recov.init(&demod.out, _sampleRate / _baudRate, _omegaGain, _muGain, _omegaRelLimit);
out = &recov.out;
generic_hier_block<FSKDemod>::registerBlock(&demod);
generic_hier_block<FSKDemod>::registerBlock(&recov);
generic_hier_block<FSKDemod>::_block_init = true;
}
void setInput(stream<complex_t>* input) {
assert((generic_hier_block<FSKDemod>::_block_init));
demod.setInput(input);
}
void setSampleRate(float sampleRate) {
assert(generic_hier_block<FSKDemod>::_block_init);
generic_hier_block<FSKDemod>::tempStop();
_sampleRate = sampleRate;
demod.setSampleRate(_sampleRate);
recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
generic_hier_block<FSKDemod>::tempStart();
}
void setDeviation(float deviation) {
assert(generic_hier_block<FSKDemod>::_block_init);
_deviation = deviation;
demod.setDeviation(deviation);
}
void setBaudRate(float baudRate, float omegaRelLimit) {
assert(generic_hier_block<FSKDemod>::_block_init);
_baudRate = baudRate;
_omegaRelLimit = omegaRelLimit;
recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
}
void setMMGains(float omegaGain, float myGain) {
assert(generic_hier_block<FSKDemod>::_block_init);
_omegaGain = omegaGain;
_muGain = myGain;
recov.setGains(_omegaGain, _muGain);
}
void setOmegaRelLimit(float omegaRelLimit) {
assert(generic_hier_block<FSKDemod>::_block_init);
_omegaRelLimit = omegaRelLimit;
recov.setOmegaRelLimit(_omegaRelLimit);
}
stream<float>* out = NULL;
private:
FloatFMDemod demod;
MMClockRecovery<float> recov;
float _sampleRate;
float _deviation;
float _baudRate;
float _omegaGain;
float _muGain;
float _omegaRelLimit;
};
class GFSKDemod : public generic_hier_block<GFSKDemod> {
public:
GFSKDemod() {}
GFSKDemod(stream<complex_t>* input, float sampleRate, float deviation, float rrcAlpha, float baudRate, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
init(input, sampleRate, deviation, rrcAlpha, baudRate, omegaGain, muGain, omegaRelLimit);
}
void init(stream<complex_t>* input, float sampleRate, float deviation, float rrcAlpha, float baudRate, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
_sampleRate = sampleRate;
_deviation = deviation;
_rrcAlpha = rrcAlpha;
_baudRate = baudRate;
_omegaGain = omegaGain;
_muGain = muGain;
_omegaRelLimit = omegaRelLimit;
demod.init(input, _sampleRate, _deviation);
rrc.init(31, _sampleRate, _baudRate, _rrcAlpha);
fir.init(&demod.out, &rrc);
recov.init(&fir.out, _sampleRate / _baudRate, _omegaGain, _muGain, _omegaRelLimit);
out = &recov.out;
generic_hier_block<GFSKDemod>::registerBlock(&demod);
generic_hier_block<GFSKDemod>::registerBlock(&fir);
generic_hier_block<GFSKDemod>::registerBlock(&recov);
generic_hier_block<GFSKDemod>::_block_init = true;
}
void setInput(stream<complex_t>* input) {
assert((generic_hier_block<GFSKDemod>::_block_init));
demod.setInput(input);
}
void setSampleRate(float sampleRate) {
assert(generic_hier_block<GFSKDemod>::_block_init);
generic_hier_block<GFSKDemod>::tempStop();
_sampleRate = sampleRate;
demod.setSampleRate(_sampleRate);
recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
rrc.setSampleRate(_sampleRate);
fir.updateWindow(&rrc);
generic_hier_block<GFSKDemod>::tempStart();
}
void setDeviation(float deviation) {
assert(generic_hier_block<GFSKDemod>::_block_init);
_deviation = deviation;
demod.setDeviation(deviation);
}
void setRRCAlpha(float rrcAlpha) {
assert(generic_hier_block<GFSKDemod>::_block_init);
_rrcAlpha = rrcAlpha;
rrc.setAlpha(_rrcAlpha);
fir.updateWindow(&rrc);
}
void setBaudRate(float baudRate, float omegaRelLimit) {
assert(generic_hier_block<GFSKDemod>::_block_init);
_baudRate = baudRate;
_omegaRelLimit = omegaRelLimit;
generic_hier_block<GFSKDemod>::tempStop();
recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
rrc.setBaudRate(_baudRate);
fir.updateWindow(&rrc);
generic_hier_block<GFSKDemod>::tempStart();
}
void setMMGains(float omegaGain, float myGain) {
assert(generic_hier_block<GFSKDemod>::_block_init);
_omegaGain = omegaGain;
_muGain = myGain;
recov.setGains(_omegaGain, _muGain);
}
void setOmegaRelLimit(float omegaRelLimit) {
assert(generic_hier_block<GFSKDemod>::_block_init);
_omegaRelLimit = omegaRelLimit;
recov.setOmegaRelLimit(_omegaRelLimit);
}
stream<float>* out = NULL;
private:
FloatFMDemod demod;
RRCTaps rrc;
FIR<float> fir;
MMClockRecovery<float> recov;
float _sampleRate;
float _deviation;
float _rrcAlpha;
float _baudRate;
float _omegaGain;
float _muGain;
float _omegaRelLimit;
};
template <int ORDER, bool OFFSET>
class PSKDemod : public generic_hier_block<PSKDemod<ORDER, OFFSET>> {
public:
PSKDemod() {}
PSKDemod(stream<complex_t>* input, float sampleRate, float baudRate, int RRCTapCount = 31, float RRCAlpha = 0.32f, float agcRate = 10e-4, float costasLoopBw = 0.004f, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
init(input, sampleRate, baudRate, RRCTapCount, RRCAlpha, agcRate, costasLoopBw, omegaGain, muGain, omegaRelLimit);
}
void init(stream<complex_t>* input, float sampleRate, float baudRate, int RRCTapCount = 31, float RRCAlpha = 0.32f, float agcRate = 10e-4, float costasLoopBw = 0.004f, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
_RRCTapCount = RRCTapCount;
_RRCAlpha = RRCAlpha;
_sampleRate = sampleRate;
_agcRate = agcRate;
_costasLoopBw = costasLoopBw;
_baudRate = baudRate;
_omegaGain = omegaGain;
_muGain = muGain;
_omegaRelLimit = omegaRelLimit;
agc.init(input, 1.0f, 65535, _agcRate);
taps.init(_RRCTapCount, _sampleRate, _baudRate, _RRCAlpha);
rrc.init(&agc.out, &taps);
demod.init(&rrc.out, _costasLoopBw);
generic_hier_block<PSKDemod<ORDER, OFFSET>>::registerBlock(&agc);
generic_hier_block<PSKDemod<ORDER, OFFSET>>::registerBlock(&rrc);
generic_hier_block<PSKDemod<ORDER, OFFSET>>::registerBlock(&demod);
if constexpr (OFFSET) {
delay.init(&demod.out);
recov.init(&delay.out, _sampleRate / _baudRate, _omegaGain, _muGain, _omegaRelLimit);
generic_hier_block<PSKDemod<ORDER, OFFSET>>::registerBlock(&delay);
}
else {
recov.init(&demod.out, _sampleRate / _baudRate, _omegaGain, _muGain, _omegaRelLimit);
}
generic_hier_block<PSKDemod<ORDER, OFFSET>>::registerBlock(&recov);
out = &recov.out;
generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init = true;
}
void setInput(stream<complex_t>* input) {
assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
agc.setInput(input);
}
void setSampleRate(float sampleRate) {
assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
_sampleRate = sampleRate;
rrc.tempStop();
recov.tempStop();
taps.setSampleRate(_sampleRate);
rrc.updateWindow(&taps);
recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
rrc.tempStart();
recov.tempStart();
}
void setBaudRate(float baudRate) {
assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
_baudRate = baudRate;
rrc.tempStop();
recov.tempStop();
taps.setBaudRate(_baudRate);
rrc.updateWindow(&taps);
recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
rrc.tempStart();
recov.tempStart();
}
void setRRCParams(int RRCTapCount, float RRCAlpha) {
assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
_RRCTapCount = RRCTapCount;
_RRCAlpha = RRCAlpha;
taps.setTapCount(_RRCTapCount);
taps.setAlpha(RRCAlpha);
rrc.updateWindow(&taps);
}
void setAgcRate(float agcRate) {
assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
_agcRate = agcRate;
agc.setRate(_agcRate);
}
void setCostasLoopBw(float costasLoopBw) {
assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
_costasLoopBw = costasLoopBw;
demod.setLoopBandwidth(_costasLoopBw);
}
void setMMGains(float omegaGain, float myGain) {
assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
_omegaGain = omegaGain;
_muGain = myGain;
recov.setGains(_omegaGain, _muGain);
}
void setOmegaRelLimit(float omegaRelLimit) {
assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
_omegaRelLimit = omegaRelLimit;
recov.setOmegaRelLimit(_omegaRelLimit);
}
stream<complex_t>* out = NULL;
private:
dsp::ComplexAGC agc;
dsp::RRCTaps taps;
dsp::FIR<dsp::complex_t> rrc;
CostasLoop<ORDER> demod;
DelayImag delay;
MMClockRecovery<dsp::complex_t> recov;
int _RRCTapCount;
float _RRCAlpha;
float _sampleRate;
float _agcRate;
float _baudRate;
float _costasLoopBw;
float _omegaGain;
float _muGain;
float _omegaRelLimit;
};
class PMDemod : public generic_hier_block<PMDemod> {
public:
PMDemod() {}
PMDemod(stream<complex_t>* input, float sampleRate, float baudRate, float agcRate = 0.02e-3f, float pllLoopBandwidth = (0.06f * 0.06f) / 4.0f, int rrcTapCount = 31, float rrcAlpha = 0.6f, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
init(input, sampleRate, baudRate, agcRate, pllLoopBandwidth, rrcTapCount, rrcAlpha, omegaGain, muGain, omegaRelLimit);
}
void init(stream<complex_t>* input, float sampleRate, float baudRate, float agcRate = 0.02e-3f, float pllLoopBandwidth = (0.06f * 0.06f) / 4.0f, int rrcTapCount = 31, float rrcAlpha = 0.6f, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
_sampleRate = sampleRate;
_baudRate = baudRate;
_agcRate = agcRate;
_pllLoopBandwidth = pllLoopBandwidth;
_rrcTapCount = rrcTapCount;
_rrcAlpha = rrcAlpha;
_omegaGain = omegaGain;
_muGain = muGain;
_omegaRelLimit = omegaRelLimit;
agc.init(input, 1.0f, 65535, _agcRate);
pll.init(&agc.out, _pllLoopBandwidth);
rrcwin.init(_rrcTapCount, _sampleRate, _baudRate, _rrcAlpha);
rrc.init(&pll.out, &rrcwin);
recov.init(&rrc.out, _sampleRate / _baudRate, _omegaGain, _muGain, _omegaRelLimit);
out = &recov.out;
generic_hier_block<PMDemod>::registerBlock(&agc);
generic_hier_block<PMDemod>::registerBlock(&pll);
generic_hier_block<PMDemod>::registerBlock(&rrc);
generic_hier_block<PMDemod>::registerBlock(&recov);
generic_hier_block<PMDemod>::_block_init = true;
}
void setInput(stream<complex_t>* input) {
assert(generic_hier_block<PMDemod>::_block_init);
agc.setInput(input);
}
void setAgcRate(float agcRate) {
assert(generic_hier_block<PMDemod>::_block_init);
_agcRate = agcRate;
agc.setRate(_agcRate);
}
void setPllLoopBandwidth(float pllLoopBandwidth) {
assert(generic_hier_block<PMDemod>::_block_init);
_pllLoopBandwidth = pllLoopBandwidth;
pll.setLoopBandwidth(_pllLoopBandwidth);
}
void setRRCParams(int rrcTapCount, float rrcAlpha) {
assert(generic_hier_block<PMDemod>::_block_init);
_rrcTapCount = rrcTapCount;
_rrcAlpha = rrcAlpha;
rrcwin.setTapCount(_rrcTapCount);
rrcwin.setAlpha(_rrcAlpha);
rrc.updateWindow(&rrcwin);
}
void setMMGains(float omegaGain, float muGain) {
assert(generic_hier_block<PMDemod>::_block_init);
_omegaGain = omegaGain;
_muGain = muGain;
recov.setGains(_omegaGain, _muGain);
}
void setOmegaRelLimit(float omegaRelLimit) {
assert(generic_hier_block<PMDemod>::_block_init);
_omegaRelLimit = omegaRelLimit;
recov.setOmegaRelLimit(_omegaRelLimit);
}
stream<float>* out = NULL;
private:
dsp::ComplexAGC agc;
dsp::CarrierTrackingPLL<float> pll;
dsp::RRCTaps rrcwin;
dsp::FIR<float> rrc;
dsp::MMClockRecovery<float> recov;
float _sampleRate;
float _baudRate;
float _agcRate;
float _pllLoopBandwidth;
int _rrcTapCount;
float _rrcAlpha;
float _omegaGain;
float _muGain;
float _omegaRelLimit;
};
class StereoFMDemod : public generic_hier_block<StereoFMDemod> {
public:
StereoFMDemod() {}
StereoFMDemod(stream<complex_t>* input, float sampleRate, float deviation) {
init(input, sampleRate, deviation);
}
void init(stream<complex_t>* input, float sampleRate, float deviation) {
_sampleRate = sampleRate;
PilotFirWin.init(18750, 19250, 3000, _sampleRate);
demod.init(input, _sampleRate, deviation);
r2c.init(&demod.out);
pilotFilter.init(&r2c.out, &PilotFirWin);
demux.init(&pilotFilter.dataOut, &pilotFilter.pilotOut, 0.1f);
recon.init(&demux.AplusBOut, &demux.AminusBOut);
out = &recon.out;
generic_hier_block<StereoFMDemod>::registerBlock(&demod);
generic_hier_block<StereoFMDemod>::registerBlock(&r2c);
generic_hier_block<StereoFMDemod>::registerBlock(&pilotFilter);
generic_hier_block<StereoFMDemod>::registerBlock(&demux);
generic_hier_block<StereoFMDemod>::registerBlock(&recon);
generic_hier_block<StereoFMDemod>::_block_init = true;
}
void setInput(stream<complex_t>* input) {
assert(generic_hier_block<StereoFMDemod>::_block_init);
demod.setInput(input);
}
void setDeviation(float deviation) {
demod.setDeviation(deviation);
}
stream<stereo_t>* out = NULL;
private:
filter_window::BandPassBlackmanWindow PilotFirWin;
FloatFMDemod demod;
RealToComplex r2c;
FMStereoDemuxPilotFilter pilotFilter;
FMStereoDemux demux;
FMStereoReconstruct recon;
float _sampleRate;
};
}

147
core/src/dsp/falcon_fec.h
Wyświetl plik

@ -1,147 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <inttypes.h>
// WTF???
extern "C" {
#include <correct.h>
}
const uint8_t toDB[] = {
0x00, 0x7b, 0xaf, 0xd4, 0x99, 0xe2, 0x36, 0x4d, 0xfa, 0x81, 0x55, 0x2e, 0x63, 0x18, 0xcc, 0xb7, 0x86, 0xfd, 0x29, 0x52, 0x1f,
0x64, 0xb0, 0xcb, 0x7c, 0x07, 0xd3, 0xa8, 0xe5, 0x9e, 0x4a, 0x31, 0xec, 0x97, 0x43, 0x38, 0x75, 0x0e, 0xda, 0xa1, 0x16, 0x6d, 0xb9, 0xc2, 0x8f, 0xf4,
0x20, 0x5b, 0x6a, 0x11, 0xc5, 0xbe, 0xf3, 0x88, 0x5c, 0x27, 0x90, 0xeb, 0x3f, 0x44, 0x09, 0x72, 0xa6, 0xdd, 0xef, 0x94, 0x40, 0x3b, 0x76, 0x0d, 0xd9,
0xa2, 0x15, 0x6e, 0xba, 0xc1, 0x8c, 0xf7, 0x23, 0x58, 0x69, 0x12, 0xc6, 0xbd, 0xf0, 0x8b, 0x5f, 0x24, 0x93, 0xe8, 0x3c, 0x47, 0x0a, 0x71, 0xa5, 0xde,
0x03, 0x78, 0xac, 0xd7, 0x9a, 0xe1, 0x35, 0x4e, 0xf9, 0x82, 0x56, 0x2d, 0x60, 0x1b, 0xcf, 0xb4, 0x85, 0xfe, 0x2a, 0x51, 0x1c, 0x67, 0xb3, 0xc8, 0x7f,
0x04, 0xd0, 0xab, 0xe6, 0x9d, 0x49, 0x32, 0x8d, 0xf6, 0x22, 0x59, 0x14, 0x6f, 0xbb, 0xc0, 0x77, 0x0c, 0xd8, 0xa3, 0xee, 0x95, 0x41, 0x3a, 0x0b, 0x70,
0xa4, 0xdf, 0x92, 0xe9, 0x3d, 0x46, 0xf1, 0x8a, 0x5e, 0x25, 0x68, 0x13, 0xc7, 0xbc, 0x61, 0x1a, 0xce, 0xb5, 0xf8, 0x83, 0x57, 0x2c, 0x9b, 0xe0, 0x34,
0x4f, 0x02, 0x79, 0xad, 0xd6, 0xe7, 0x9c, 0x48, 0x33, 0x7e, 0x05, 0xd1, 0xaa, 0x1d, 0x66, 0xb2, 0xc9, 0x84, 0xff, 0x2b, 0x50, 0x62, 0x19, 0xcd, 0xb6,
0xfb, 0x80, 0x54, 0x2f, 0x98, 0xe3, 0x37, 0x4c, 0x01, 0x7a, 0xae, 0xd5, 0xe4, 0x9f, 0x4b, 0x30, 0x7d, 0x06, 0xd2, 0xa9, 0x1e, 0x65, 0xb1, 0xca, 0x87,
0xfc, 0x28, 0x53, 0x8e, 0xf5, 0x21, 0x5a, 0x17, 0x6c, 0xb8, 0xc3, 0x74, 0x0f, 0xdb, 0xa0, 0xed, 0x96, 0x42, 0x39, 0x08, 0x73, 0xa7, 0xdc, 0x91, 0xea,
0x3e, 0x45, 0xf2, 0x89, 0x5d, 0x26, 0x6b, 0x10, 0xc4, 0xbf
};
const uint8_t fromDB[] = {
0x00, 0xcc, 0xac, 0x60, 0x79, 0xb5, 0xd5, 0x19, 0xf0, 0x3c, 0x5c, 0x90, 0x89, 0x45, 0x25, 0xe9, 0xfd, 0x31, 0x51, 0x9d,
0x84, 0x48, 0x28, 0xe4, 0x0d, 0xc1, 0xa1, 0x6d, 0x74, 0xb8, 0xd8, 0x14, 0x2e, 0xe2, 0x82, 0x4e, 0x57, 0x9b, 0xfb, 0x37, 0xde, 0x12, 0x72, 0xbe, 0xa7,
0x6b, 0x0b, 0xc7, 0xd3, 0x1f, 0x7f, 0xb3, 0xaa, 0x66, 0x06, 0xca, 0x23, 0xef, 0x8f, 0x43, 0x5a, 0x96, 0xf6, 0x3a, 0x42, 0x8e, 0xee, 0x22, 0x3b, 0xf7,
0x97, 0x5b, 0xb2, 0x7e, 0x1e, 0xd2, 0xcb, 0x07, 0x67, 0xab, 0xbf, 0x73, 0x13, 0xdf, 0xc6, 0x0a, 0x6a, 0xa6, 0x4f, 0x83, 0xe3, 0x2f, 0x36, 0xfa, 0x9a,
0x56, 0x6c, 0xa0, 0xc0, 0x0c, 0x15, 0xd9, 0xb9, 0x75, 0x9c, 0x50, 0x30, 0xfc, 0xe5, 0x29, 0x49, 0x85, 0x91, 0x5d, 0x3d, 0xf1, 0xe8, 0x24, 0x44, 0x88,
0x61, 0xad, 0xcd, 0x01, 0x18, 0xd4, 0xb4, 0x78, 0xc5, 0x09, 0x69, 0xa5, 0xbc, 0x70, 0x10, 0xdc, 0x35, 0xf9, 0x99, 0x55, 0x4c, 0x80, 0xe0, 0x2c, 0x38,
0xf4, 0x94, 0x58, 0x41, 0x8d, 0xed, 0x21, 0xc8, 0x04, 0x64, 0xa8, 0xb1, 0x7d, 0x1d, 0xd1, 0xeb, 0x27, 0x47, 0x8b, 0x92, 0x5e, 0x3e, 0xf2, 0x1b, 0xd7,
0xb7, 0x7b, 0x62, 0xae, 0xce, 0x02, 0x16, 0xda, 0xba, 0x76, 0x6f, 0xa3, 0xc3, 0x0f, 0xe6, 0x2a, 0x4a, 0x86, 0x9f, 0x53, 0x33, 0xff, 0x87, 0x4b, 0x2b,
0xe7, 0xfe, 0x32, 0x52, 0x9e, 0x77, 0xbb, 0xdb, 0x17, 0x0e, 0xc2, 0xa2, 0x6e, 0x7a, 0xb6, 0xd6, 0x1a, 0x03, 0xcf, 0xaf, 0x63, 0x8a, 0x46, 0x26, 0xea,
0xf3, 0x3f, 0x5f, 0x93, 0xa9, 0x65, 0x05, 0xc9, 0xd0, 0x1c, 0x7c, 0xb0, 0x59, 0x95, 0xf5, 0x39, 0x20, 0xec, 0x8c, 0x40, 0x54, 0x98, 0xf8, 0x34, 0x2d,
0xe1, 0x81, 0x4d, 0xa4, 0x68, 0x08, 0xc4, 0xdd, 0x11, 0x71, 0xbd
};
const uint8_t randVals[] = {
0xFF, 0x48, 0x0E, 0xC0, 0x9A, 0x0D, 0x70, 0xBC, 0x8E, 0x2C, 0x93, 0xAD, 0xA7, 0xB7, 0x46, 0xCE,
0x5A, 0x97, 0x7D, 0xCC, 0x32, 0xA2, 0xBF, 0x3E, 0x0A, 0x10, 0xF1, 0x88, 0x94, 0xCD, 0xEA, 0xB1,
0xFE, 0x90, 0x1D, 0x81, 0x34, 0x1A, 0xE1, 0x79, 0x1C, 0x59, 0x27, 0x5B, 0x4F, 0x6E, 0x8D, 0x9C,
0xB5, 0x2E, 0xFB, 0x98, 0x65, 0x45, 0x7E, 0x7C, 0x14, 0x21, 0xE3, 0x11, 0x29, 0x9B, 0xD5, 0x63,
0xFD, 0x20, 0x3B, 0x02, 0x68, 0x35, 0xC2, 0xF2, 0x38, 0xB2, 0x4E, 0xB6, 0x9E, 0xDD, 0x1B, 0x39,
0x6A, 0x5D, 0xF7, 0x30, 0xCA, 0x8A, 0xFC, 0xF8, 0x28, 0x43, 0xC6, 0x22, 0x53, 0x37, 0xAA, 0xC7,
0xFA, 0x40, 0x76, 0x04, 0xD0, 0x6B, 0x85, 0xE4, 0x71, 0x64, 0x9D, 0x6D, 0x3D, 0xBA, 0x36, 0x72,
0xD4, 0xBB, 0xEE, 0x61, 0x95, 0x15, 0xF9, 0xF0, 0x50, 0x87, 0x8C, 0x44, 0xA6, 0x6F, 0x55, 0x8F,
0xF4, 0x80, 0xEC, 0x09, 0xA0, 0xD7, 0x0B, 0xC8, 0xE2, 0xC9, 0x3A, 0xDA, 0x7B, 0x74, 0x6C, 0xE5,
0xA9, 0x77, 0xDC, 0xC3, 0x2A, 0x2B, 0xF3, 0xE0, 0xA1, 0x0F, 0x18, 0x89, 0x4C, 0xDE, 0xAB, 0x1F,
0xE9, 0x01, 0xD8, 0x13, 0x41, 0xAE, 0x17, 0x91, 0xC5, 0x92, 0x75, 0xB4, 0xF6, 0xE8, 0xD9, 0xCB,
0x52, 0xEF, 0xB9, 0x86, 0x54, 0x57, 0xE7, 0xC1, 0x42, 0x1E, 0x31, 0x12, 0x99, 0xBD, 0x56, 0x3F,
0xD2, 0x03, 0xB0, 0x26, 0x83, 0x5C, 0x2F, 0x23, 0x8B, 0x24, 0xEB, 0x69, 0xED, 0xD1, 0xB3, 0x96,
0xA5, 0xDF, 0x73, 0x0C, 0xA8, 0xAF, 0xCF, 0x82, 0x84, 0x3C, 0x62, 0x25, 0x33, 0x7A, 0xAC, 0x7F,
0xA4, 0x07, 0x60, 0x4D, 0x06, 0xB8, 0x5E, 0x47, 0x16, 0x49, 0xD6, 0xD3, 0xDB, 0xA3, 0x67, 0x2D,
0x4B, 0xBE, 0xE6, 0x19, 0x51, 0x5F, 0x9F, 0x05, 0x08, 0x78, 0xC4, 0x4A, 0x66, 0xF5, 0x58
};
namespace dsp {
class FalconRS : public generic_block<FalconRS> {
public:
FalconRS() {}
FalconRS(stream<uint8_t>* in) { init(in); }
void init(stream<uint8_t>* in) {
_in = in;
for (int i = 0; i < 5; i++) { memset(buffers[i], 0, 255); }
for (int i = 0; i < 5; i++) { memset(outBuffers[i], 0, 255); }
rs = correct_reed_solomon_create(correct_rs_primitive_polynomial_ccsds, 120, 11, 16);
if (rs == NULL) { printf("Error creating the reed solomon decoder\n"); }
generic_block<FalconRS>::registerInput(_in);
generic_block<FalconRS>::registerOutput(&out);
generic_block<FalconRS>::_block_init = true;
}
void setInput(stream<uint8_t>* in) {
assert(generic_block<FalconRS>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FalconRS>::ctrlMtx);
generic_block<FalconRS>::tempStop();
generic_block<FalconRS>::unregisterInput(_in);
_in = in;
generic_block<FalconRS>::registerInput(_in);
generic_block<FalconRS>::tempStart();
}
int run() {
count = _in->read();
if (count < 0) { return -1; }
uint8_t* data = _in->readBuf + 4;
// Deinterleave
for (int i = 0; i < 255 * 5; i++) {
buffers[i % 5][i / 5] = fromDB[data[i]];
}
// Reed the solomon :weary:
int result = 0;
result = correct_reed_solomon_decode(rs, buffers[0], 255, outBuffers[0]);
if (result == -1) {
_in->flush();
return count;
}
result = correct_reed_solomon_decode(rs, buffers[1], 255, outBuffers[1]);
if (result == -1) {
_in->flush();
return count;
}
result = correct_reed_solomon_decode(rs, buffers[2], 255, outBuffers[2]);
if (result == -1) {
_in->flush();
return count;
}
result = correct_reed_solomon_decode(rs, buffers[3], 255, outBuffers[3]);
if (result == -1) {
_in->flush();
return count;
}
result = correct_reed_solomon_decode(rs, buffers[4], 255, outBuffers[4]);
if (result == -1) {
_in->flush();
return count;
}
// Reinterleave
for (int i = 0; i < 255 * 5; i++) {
out.writeBuf[i] = toDB[outBuffers[i % 5][i / 5]] ^ randVals[i % 255];
}
out.swap(255 * 5);
_in->flush();
return count;
}
stream<uint8_t> out;
private:
int count;
uint8_t buffers[5][255];
uint8_t outBuffers[5][255];
correct_reed_solomon* rs;
stream<uint8_t>* _in;
};
}

125
core/src/dsp/falcon_packet.h
Wyświetl plik

@ -1,125 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <inttypes.h>
namespace dsp {
struct FalconFrameHeader {
uint32_t counter;
uint16_t packet;
};
class FalconPacketSync : public generic_block<FalconPacketSync> {
public:
FalconPacketSync() {}
FalconPacketSync(stream<uint8_t>* in) { init(in); }
void init(stream<uint8_t>* in) {
_in = in;
generic_block<FalconPacketSync>::registerInput(_in);
generic_block<FalconPacketSync>::registerOutput(&out);
generic_block<FalconPacketSync>::_block_init = true;
}
void setInput(stream<uint8_t>* in) {
assert(generic_block<FalconPacketSync>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FalconPacketSync>::ctrlMtx);
generic_block<FalconPacketSync>::tempStop();
generic_block<FalconPacketSync>::unregisterInput(_in);
_in = in;
generic_block<FalconPacketSync>::registerInput(_in);
generic_block<FalconPacketSync>::tempStart();
}
int run() {
count = _in->read();
if (count < 0) { return -1; }
// Parse frame header
FalconFrameHeader header;
header.packet = (_in->readBuf[3] | ((_in->readBuf[2] & 0b111) << 8));
header.counter = ((_in->readBuf[2] >> 3) | (_in->readBuf[1] << 5) | ((_in->readBuf[0] & 0b111111) << 13));
// Pointer to the data aera of the frame
uint8_t* data = _in->readBuf + 4;
int dataLen = 1191;
// If a frame was missed, cancel reading the current packet
if (lastCounter + 1 != header.counter) {
packetRead = -1;
}
lastCounter = header.counter;
// If frame is just a continuation of a single packet, save it
// If we're not currently reading a packet
if (header.packet == 2047 && packetRead >= 0) {
memcpy(packet + packetRead, data, dataLen);
packetRead += dataLen;
_in->flush();
printf("Wow, all data\n");
return count;
}
else if (header.packet == 2047) {
printf("Wow, all data\n");
_in->flush();
return count;
}
// Finish reading the last package and send it
if (packetRead >= 0) {
memcpy(packet + packetRead, data, header.packet);
memcpy(out.writeBuf, packet, packetRead + header.packet);
out.swap(packetRead + header.packet);
packetRead = -1;
}
// Iterate through every packet of the frame
for (int i = header.packet; i < dataLen;) {
// First, check if we can read the header. If not, save and wait for next frame
if (dataLen - i < 4) {
packetRead = dataLen - i;
memcpy(packet, &data[i], packetRead);
break;
}
// Extract packet length
uint16_t length = (((data[i] & 0b1111) << 8) | data[i + 1]) + 2;
// Check if it's not an invalid zero length packet
if (length <= 2) {
packetRead = -1;
break;
}
uint64_t pktId = ((uint64_t)data[i + 2] << 56) | ((uint64_t)data[i + 3] << 48) | ((uint64_t)data[i + 4] << 40) | ((uint64_t)data[i + 5] << 32) | ((uint64_t)data[i + 6] << 24) | ((uint64_t)data[i + 7] << 16) | ((uint64_t)data[i + 8] << 8) | data[i + 9];
// If the packet doesn't fit the frame, save and go to next frame
if (dataLen - i < length) {
packetRead = dataLen - i;
memcpy(packet, &data[i], packetRead);
break;
}
// Here, the package fits fully, read it and jump to the next
memcpy(out.writeBuf, &data[i], length);
out.swap(length);
i += length;
}
_in->flush();
return count;
}
stream<uint8_t> out;
private:
int count;
uint32_t lastCounter = 0;
int packetRead = -1;
uint8_t packet[0x4008];
stream<uint8_t>* _in;
};
}

269
core/src/dsp/filter.h
Wyświetl plik

@ -1,269 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/window.h>
#include <string.h>
namespace dsp {
template <class T>
class FIR : public generic_block<FIR<T>> {
public:
FIR() {}
FIR(stream<T>* in, dsp::filter_window::generic_window* window) { init(in, window); }
~FIR() {
if (!generic_block<FIR<T>>::_block_init) { return; }
generic_block<FIR<T>>::stop();
volk_free(buffer);
volk_free(taps);
generic_block<FIR<T>>::_block_init = false;
}
void init(stream<T>* in, dsp::filter_window::generic_window* window) {
_in = in;
tapCount = window->getTapCount();
taps = (float*)volk_malloc(tapCount * sizeof(float), volk_get_alignment());
window->createTaps(taps, tapCount);
buffer = (T*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(T) * 2, volk_get_alignment());
bufStart = &buffer[tapCount];
generic_block<FIR<T>>::registerInput(_in);
generic_block<FIR<T>>::registerOutput(&out);
generic_block<FIR<T>>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<FIR<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FIR<T>>::ctrlMtx);
generic_block<FIR<T>>::tempStop();
generic_block<FIR<T>>::unregisterInput(_in);
_in = in;
generic_block<FIR<T>>::registerInput(_in);
generic_block<FIR<T>>::tempStart();
}
void updateWindow(dsp::filter_window::generic_window* window) {
assert(generic_block<FIR<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FIR<T>>::ctrlMtx);
_window = window;
volk_free(taps);
tapCount = window->getTapCount();
taps = (float*)volk_malloc(tapCount * sizeof(float), volk_get_alignment());
bufStart = &buffer[tapCount];
window->createTaps(taps, tapCount);
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
generic_block<FIR<T>>::ctrlMtx.lock();
memcpy(bufStart, _in->readBuf, count * sizeof(T));
_in->flush();
if constexpr (std::is_same_v<T, float>) {
for (int i = 0; i < count; i++) {
volk_32f_x2_dot_prod_32f((float*)&out.writeBuf[i], (float*)&buffer[i + 1], taps, tapCount);
}
}
if constexpr (std::is_same_v<T, complex_t>) {
for (int i = 0; i < count; i++) {
volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&out.writeBuf[i], (lv_32fc_t*)&buffer[i + 1], taps, tapCount);
}
}
if (!out.swap(count)) { return -1; }
memmove(buffer, &buffer[count], tapCount * sizeof(T));
generic_block<FIR<T>>::ctrlMtx.unlock();
return count;
}
stream<T> out;
private:
stream<T>* _in;
dsp::filter_window::generic_window* _window;
T* bufStart;
T* buffer;
int tapCount;
float* taps;
};
class ComplexFIR : public generic_block<ComplexFIR> {
public:
ComplexFIR() {}
ComplexFIR(stream<complex_t>* in, dsp::filter_window::generic_complex_window* window) { init(in, window); }
~ComplexFIR() {
if (!generic_block<ComplexFIR>::_block_init) { return; }
generic_block<ComplexFIR>::stop();
volk_free(buffer);
volk_free(taps);
generic_block<ComplexFIR>::_block_init = false;
}
void init(stream<complex_t>* in, dsp::filter_window::generic_complex_window* window) {
_in = in;
tapCount = window->getTapCount();
taps = (complex_t*)volk_malloc(tapCount * sizeof(complex_t), volk_get_alignment());
window->createTaps(taps, tapCount);
buffer = (complex_t*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(complex_t) * 2, volk_get_alignment());
bufStart = &buffer[tapCount];
generic_block<ComplexFIR>::registerInput(_in);
generic_block<ComplexFIR>::registerOutput(&out);
generic_block<ComplexFIR>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<ComplexFIR>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<ComplexFIR>::ctrlMtx);
generic_block<ComplexFIR>::tempStop();
generic_block<ComplexFIR>::unregisterInput(_in);
_in = in;
generic_block<ComplexFIR>::registerInput(_in);
generic_block<ComplexFIR>::tempStart();
}
void updateWindow(dsp::filter_window::generic_complex_window* window) {
assert(generic_block<ComplexFIR>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<ComplexFIR>::ctrlMtx);
_window = window;
volk_free(taps);
tapCount = window->getTapCount();
taps = (complex_t*)volk_malloc(tapCount * sizeof(complex_t), volk_get_alignment());
bufStart = &buffer[tapCount];
window->createTaps(taps, tapCount);
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
generic_block<ComplexFIR>::ctrlMtx.lock();
memcpy(bufStart, _in->readBuf, count * sizeof(complex_t));
_in->flush();
for (int i = 0; i < count; i++) {
volk_32fc_x2_dot_prod_32fc((lv_32fc_t*)&out.writeBuf[i], (lv_32fc_t*)&buffer[i + 1], (lv_32fc_t*)taps, tapCount);
}
if (!out.swap(count)) { return -1; }
memmove(buffer, &buffer[count], tapCount * sizeof(complex_t));
generic_block<ComplexFIR>::ctrlMtx.unlock();
return count;
}
stream<complex_t> out;
private:
stream<complex_t>* _in;
dsp::filter_window::generic_complex_window* _window;
complex_t* bufStart;
complex_t* buffer;
int tapCount;
complex_t* taps;
};
class BFMDeemp : public generic_block<BFMDeemp> {
public:
BFMDeemp() {}
BFMDeemp(stream<stereo_t>* in, float sampleRate, float tau) { init(in, sampleRate, tau); }
void init(stream<stereo_t>* in, float sampleRate, float tau) {
_in = in;
_sampleRate = sampleRate;
_tau = tau;
float dt = 1.0f / _sampleRate;
alpha = dt / (_tau + dt);
generic_block<BFMDeemp>::registerInput(_in);
generic_block<BFMDeemp>::registerOutput(&out);
generic_block<BFMDeemp>::_block_init = true;
}
void setInput(stream<stereo_t>* in) {
assert(generic_block<BFMDeemp>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<BFMDeemp>::ctrlMtx);
generic_block<BFMDeemp>::tempStop();
generic_block<BFMDeemp>::unregisterInput(_in);
_in = in;
generic_block<BFMDeemp>::registerInput(_in);
generic_block<BFMDeemp>::tempStart();
}
void setSampleRate(float sampleRate) {
assert(generic_block<BFMDeemp>::_block_init);
_sampleRate = sampleRate;
float dt = 1.0f / _sampleRate;
alpha = dt / (_tau + dt);
}
void setTau(float tau) {
assert(generic_block<BFMDeemp>::_block_init);
_tau = tau;
float dt = 1.0f / _sampleRate;
alpha = dt / (_tau + dt);
}
int run() {
count = _in->read();
if (count < 0) { return -1; }
if (bypass) {
memcpy(out.writeBuf, _in->readBuf, count * sizeof(stereo_t));
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
if (isnan(lastOutL)) {
lastOutL = 0.0f;
}
if (isnan(lastOutR)) {
lastOutR = 0.0f;
}
out.writeBuf[0].l = (alpha * _in->readBuf[0].l) + ((1 - alpha) * lastOutL);
out.writeBuf[0].r = (alpha * _in->readBuf[0].r) + ((1 - alpha) * lastOutR);
for (int i = 1; i < count; i++) {
out.writeBuf[i].l = (alpha * _in->readBuf[i].l) + ((1 - alpha) * out.writeBuf[i - 1].l);
out.writeBuf[i].r = (alpha * _in->readBuf[i].r) + ((1 - alpha) * out.writeBuf[i - 1].r);
}
lastOutL = out.writeBuf[count - 1].l;
lastOutR = out.writeBuf[count - 1].r;
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
bool bypass = false;
stream<stereo_t> out;
private:
int count;
float lastOutL = 0.0f;
float lastOutR = 0.0f;
float alpha;
float _tau;
float _sampleRate;
stream<stereo_t>* _in;
};
}

208
core/src/dsp/firdec/firdec_plans.h
Wyświetl plik

@ -1,208 +0,0 @@
#pragma once
#include "taps/fir_2_2.h"
#include "taps/fir_4_4.h"
#include "taps/fir_8_4.h"
#include "taps/fir_16_8.h"
#include "taps/fir_32_16.h"
#include "taps/fir_64_32.h"
#include "taps/fir_128_32.h"
#include "taps/fir_256_64.h"
#include "taps/fir_512_128.h"
#include "taps/fir_1024_128.h"
#include "taps/fir_2048_128.h"
namespace dsp {
namespace firdec {
struct stage {
unsigned int decimation;
unsigned int tapcount;
const float* taps;
};
const unsigned int plan_2_len = 1;
const stage plan_2[] = {
{ 2, fir_2_2_len, fir_2_2_taps }
};
const unsigned int plan_4_len = 1;
const stage plan_4[] = {
{ 4, fir_4_4_len, fir_4_4_taps }
};
const unsigned int plan_8_len = 2;
const stage plan_8[] = {
{ 4, fir_8_4_len, fir_8_4_taps },
{ 2, fir_2_2_len, fir_2_2_taps }
};
const unsigned int plan_16_len = 2;
const stage plan_16[] = {
{ 8, fir_16_8_len, fir_16_8_taps },
{ 2, fir_2_2_len, fir_2_2_taps }
};
const unsigned int plan_32_len = 2;
const stage plan_32[] = {
{ 16, fir_32_16_len, fir_32_16_taps },
{ 2, fir_2_2_len, fir_2_2_taps }
};
const unsigned int plan_64_len = 2;
const stage plan_64[] = {
{ 32, fir_64_32_len, fir_64_32_taps },
{ 2, fir_2_2_len, fir_2_2_taps }
};
const unsigned int plan_128_len = 2;
const stage plan_128[] = {
{ 32, fir_128_32_len, fir_128_32_taps },
{ 4, fir_4_4_len, fir_4_4_taps }
};
const unsigned int plan_256_len = 2;
const stage plan_256[] = {
{ 64, fir_256_64_len, fir_256_64_taps },
{ 4, fir_4_4_len, fir_4_4_taps }
};
const unsigned int plan_512_len = 2;
const stage plan_512[] = {
{ 128, fir_512_128_len, fir_512_128_taps },
{ 4, fir_4_4_len, fir_4_4_taps }
};
const unsigned int plan_1024_len = 3;
const stage plan_1024[] = {
{ 128, fir_1024_128_len, fir_1024_128_taps },
{ 4, fir_8_4_len, fir_8_4_taps },
{ 2, fir_2_2_len, fir_2_2_taps }
};
const unsigned int plan_2048_len = 3;
const stage plan_2048[] = {
{ 128, fir_2048_128_len, fir_2048_128_taps },
{ 8, fir_16_8_len, fir_16_8_taps },
{ 2, fir_2_2_len, fir_2_2_taps }
};
const unsigned int plan_4096_len = 3;
const stage plan_4096[] = {
{ 128, fir_2048_128_len, fir_2048_128_taps },
{ 16, fir_32_16_len, fir_32_16_taps },
{ 2, fir_2_2_len, fir_2_2_taps }
};
const unsigned int plan_8192_len = 3;
const stage plan_8192[] = {
{ 128, fir_2048_128_len, fir_2048_128_taps },
{ 32, fir_64_32_len, fir_64_32_taps },
{ 2, fir_2_2_len, fir_2_2_taps }
};
struct plan {
unsigned int stageCount;
const stage* stages;
};
const unsigned int plans_len = 13;
const plan plans[] {
{ plan_2_len, plan_2 },
{ plan_4_len, plan_4 },
{ plan_8_len, plan_8 },
{ plan_16_len, plan_16 },
{ plan_32_len, plan_32 },
{ plan_64_len, plan_64 },
{ plan_128_len, plan_128 },
{ plan_256_len, plan_256 },
{ plan_512_len, plan_512 },
{ plan_1024_len, plan_1024 },
{ plan_2048_len, plan_2048 },
{ plan_4096_len, plan_4096 },
{ plan_8192_len, plan_8192 },
};
}
}
/*
Desired ratio: 2
<====== BEST ======>
Stage 0 : 2 : 2 ( 69 taps)
<==================> 4.5464
Desired ratio: 4
<====== BEST ======>
Stage 0 : 4 : 4 ( 139 taps)
<==================> 4.0912
Desired ratio: 8
<====== BEST ======>
Stage 0 : 8 : 4 ( 32 taps)
Stage 1 : 2 : 2 ( 69 taps)
<==================> 2.5073
Desired ratio: 16
<====== BEST ======>
Stage 0 : 16 : 8 ( 64 taps)
Stage 1 : 2 : 2 ( 69 taps)
<==================> 1.417775
Desired ratio: 32
<====== BEST ======>
Stage 0 : 32 : 16 ( 128 taps)
Stage 1 : 2 : 2 ( 69 taps)
<==================> 0.897
Desired ratio: 64
<====== BEST ======>
Stage 0 : 64 : 32 ( 254 taps)
Stage 1 : 2 : 2 ( 69 taps)
<==================> 0.6991562499999999
Desired ratio: 128
<====== BEST ======>
Stage 0 : 128 : 32 ( 180 taps)
Stage 1 : 4 : 4 ( 139 taps)
<==================> 0.61851875
Desired ratio: 256
<====== BEST ======>
Stage 0 : 256 : 64 ( 356 taps)
Stage 1 : 4 : 4 ( 139 taps)
<==================> 0.4696125
Desired ratio: 512
<====== BEST ======>
Stage 0 : 512 : 128 ( 711 taps)
Stage 1 : 4 : 4 ( 139 taps)
<==================> 0.38787734375
Desired ratio: 1024
<====== BEST ======>
Stage 0 : 1024 : 128 ( 565 taps)
Stage 1 : 8 : 4 ( 32 taps)
Stage 2 : 2 : 2 ( 69 taps)
<==================> 0.30618515625
Desired ratio: 2048
<====== BEST ======>
Stage 0 : 2048 : 128 ( 514 taps)
Stage 1 : 16 : 8 ( 64 taps)
Stage 2 : 2 : 2 ( 69 taps)
<==================> 0.2665748046875
Desired ratio: 4096
<====== BEST ======>
Stage 0 : 2048 : 128 ( 514 taps)
Stage 1 : 32 : 16 ( 128 taps)
Stage 2 : 2 : 2 ( 69 taps)
<==================> 0.26250625
Desired ratio: 8192
<====== BEST ======>
Stage 0 : 2048 : 128 ( 514 taps)
Stage 1 : 64 : 32 ( 254 taps)
Stage 2 : 2 : 2 ( 69 taps)
<==================> 0.260960595703125
*/

579
core/src/dsp/firdec/taps/fir_1024_128.h
Wyświetl plik

@ -1,579 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_1024_128_len = 565;
const float fir_1024_128_taps[] = {
-0.0000004327587f,
0.0000026997780f,
0.0000011158244f,
0.0000009851064f,
0.0000010818484f,
0.0000012233487f,
0.0000013829611f,
0.0000015574122f,
0.0000017469545f,
0.0000019523988f,
0.0000021746708f,
0.0000024147452f,
0.0000026736369f,
0.0000029524002f,
0.0000032521294f,
0.0000035739593f,
0.0000039190664f,
0.0000042886691f,
0.0000046840291f,
0.0000051064513f,
0.0000055572854f,
0.0000060379258f,
0.0000065498127f,
0.0000070944329f,
0.0000076733199f,
0.0000082880550f,
0.0000089402676f,
0.0000096316359f,
0.0000103638874f,
0.0000111387995f,
0.0000119581996f,
0.0000128239662f,
0.0000137380287f,
0.0000147023683f,
0.0000157190179f,
0.0000167900628f,
0.0000179176408f,
0.0000191039423f,
0.0000203512110f,
0.0000216617435f,
0.0000230378899f,
0.0000244820535f,
0.0000259966913f,
0.0000275843135f,
0.0000292474837f,
0.0000309888191f,
0.0000328109897f,
0.0000347167188f,
0.0000367087824f,
0.0000387900088f,
0.0000409632787f,
0.0000432315243f,
0.0000455977293f,
0.0000480649281f,
0.0000506362055f,
0.0000533146957f,
0.0000561035822f,
0.0000590060964f,
0.0000620255175f,
0.0000651651712f,
0.0000684284288f,
0.0000718187066f,
0.0000753394644f,
0.0000789942048f,
0.0000827864719f,
0.0000867198500f,
0.0000907979625f,
0.0000950244704f,
0.0000994030710f,
0.0001039374965f,
0.0001086315122f,
0.0001134889152f,
0.0001185135326f,
0.0001237092199f,
0.0001290798590f,
0.0001346293565f,
0.0001403616418f,
0.0001462806650f,
0.0001523903952f,
0.0001586948179f,
0.0001651979332f,
0.0001719037534f,
0.0001788163010f,
0.0001859396059f,
0.0001932777035f,
0.0002008346317f,
0.0002086144290f,
0.0002166211315f,
0.0002248587702f,
0.0002333313688f,
0.0002420429405f,
0.0002509974854f,
0.0002601989878f,
0.0002696514131f,
0.0002793587049f,
0.0002893247820f,
0.0002995535358f,
0.0003100488266f,
0.0003208144809f,
0.0003318542882f,
0.0003431719977f,
0.0003547713152f,
0.0003666559000f,
0.0003788293613f,
0.0003912952551f,
0.0004040570809f,
0.0004171182782f,
0.0004304822235f,
0.0004441522261f,
0.0004581315258f,
0.0004724232886f,
0.0004870306035f,
0.0005019564795f,
0.0005172038413f,
0.0005327755266f,
0.0005486742825f,
0.0005649027617f,
0.0005814635194f,
0.0005983590097f,
0.0006155915822f,
0.0006331634787f,
0.0006510768296f,
0.0006693336508f,
0.0006879358399f,
0.0007068851735f,
0.0007261833032f,
0.0007458317529f,
0.0007658319153f,
0.0007861850487f,
0.0008068922738f,
0.0008279545709f,
0.0008493727764f,
0.0008711475801f,
0.0008932795221f,
0.0009157689899f,
0.0009386162156f,
0.0009618212732f,
0.0009853840755f,
0.0010093043719f,
0.0010335817458f,
0.0010582156116f,
0.0010832052129f,
0.0011085496198f,
0.0011342477266f,
0.0011602982499f,
0.0011866997262f,
0.0012134505102f,
0.0012405487727f,
0.0012679924989f,
0.0012957794865f,
0.0013239073445f,
0.0013523734912f,
0.0013811751533f,
0.0014103093644f,
0.0014397729637f,
0.0014695625952f,
0.0014996747065f,
0.0015301055485f,
0.0015608511740f,
0.0015919074376f,
0.0016232699954f,
0.0016549343039f,
0.0016868956210f,
0.0017191490046f,
0.0017516893140f,
0.0017845112089f,
0.0018176091508f,
0.0018509774026f,
0.0018846100298f,
0.0019185009010f,
0.0019526436887f,
0.0019870318707f,
0.0020216587307f,
0.0020565173602f,
0.0020916006596f,
0.0021269013399f,
0.0021624119242f,
0.0021981247499f,
0.0022340319707f,
0.0022701255585f,
0.0023063973058f,
0.0023428388283f,
0.0023794415672f,
0.0024161967921f,
0.0024530956039f,
0.0024901289377f,
0.0025272875658f,
0.0025645621012f,
0.0026019430011f,
0.0026394205698f,
0.0026769849632f,
0.0027146261921f,
0.0027523341262f,
0.0027900984982f,
0.0028279089079f,
0.0028657548267f,
0.0029036256018f,
0.0029415104608f,
0.0029793985165f,
0.0030172787713f,
0.0030551401225f,
0.0030929713673f,
0.0031307612072f,
0.0031684982542f,
0.0032061710353f,
0.0032437679982f,
0.0032812775168f,
0.0033186878969f,
0.0033559873813f,
0.0033931641562f,
0.0034302063567f,
0.0034671020727f,
0.0035038393549f,
0.0035404062207f,
0.0035767906605f,
0.0036129806440f,
0.0036489641257f,
0.0036847290520f,
0.0037202633668f,
0.0037555550186f,
0.0037905919660f,
0.0038253621849f,
0.0038598536743f,
0.0038940544635f,
0.0039279526178f,
0.0039615362454f,
0.0039947935041f,
0.0040277126075f,
0.0040602818315f,
0.0040924895211f,
0.0041243240966f,
0.0041557740604f,
0.0041868280032f,
0.0042174746106f,
0.0042477026695f,
0.0042775010745f,
0.0043068588342f,
0.0043357650775f,
0.0043642090601f,
0.0043921801703f,
0.0044196679357f,
0.0044466620287f,
0.0044731522730f,
0.0044991286493f,
0.0045245813014f,
0.0045495005417f,
0.0045738768574f,
0.0045977009155f,
0.0046209635689f,
0.0046436558617f,
0.0046657690344f,
0.0046872945291f,
0.0047082239951f,
0.0047285492933f,
0.0047482625015f,
0.0047673559190f,
0.0047858220715f,
0.0048036537152f,
0.0048208438417f,
0.0048373856818f,
0.0048532727100f,
0.0048684986482f,
0.0048830574697f,
0.0048969434029f,
0.0049101509346f,
0.0049226748137f,
0.0049345100543f,
0.0049456519385f,
0.0049560960197f,
0.0049658381254f,
0.0049748743591f,
0.0049832011036f,
0.0049908150224f,
0.0049977130625f,
0.0050038924557f,
0.0050093507207f,
0.0050140856644f,
0.0050180953834f,
0.0050213782651f,
0.0050239329888f,
0.0050257585263f,
0.0050268541429f,
0.0050272193974f,
0.0050268541429f,
0.0050257585263f,
0.0050239329888f,
0.0050213782651f,
0.0050180953834f,
0.0050140856644f,
0.0050093507207f,
0.0050038924557f,
0.0049977130625f,
0.0049908150224f,
0.0049832011036f,
0.0049748743591f,
0.0049658381254f,
0.0049560960197f,
0.0049456519385f,
0.0049345100543f,
0.0049226748137f,
0.0049101509346f,
0.0048969434029f,
0.0048830574697f,
0.0048684986482f,
0.0048532727100f,
0.0048373856818f,
0.0048208438417f,
0.0048036537152f,
0.0047858220715f,
0.0047673559190f,
0.0047482625015f,
0.0047285492933f,
0.0047082239951f,
0.0046872945291f,
0.0046657690344f,
0.0046436558617f,
0.0046209635689f,
0.0045977009155f,
0.0045738768574f,
0.0045495005417f,
0.0045245813014f,
0.0044991286493f,
0.0044731522730f,
0.0044466620287f,
0.0044196679357f,
0.0043921801703f,
0.0043642090601f,
0.0043357650775f,
0.0043068588342f,
0.0042775010745f,
0.0042477026695f,
0.0042174746106f,
0.0041868280032f,
0.0041557740604f,
0.0041243240966f,
0.0040924895211f,
0.0040602818315f,
0.0040277126075f,
0.0039947935041f,
0.0039615362454f,
0.0039279526178f,
0.0038940544635f,
0.0038598536743f,
0.0038253621849f,
0.0037905919660f,
0.0037555550186f,
0.0037202633668f,
0.0036847290520f,
0.0036489641257f,
0.0036129806440f,
0.0035767906605f,
0.0035404062207f,
0.0035038393549f,
0.0034671020727f,
0.0034302063567f,
0.0033931641562f,
0.0033559873813f,
0.0033186878969f,
0.0032812775168f,
0.0032437679982f,
0.0032061710353f,
0.0031684982542f,
0.0031307612072f,
0.0030929713673f,
0.0030551401225f,
0.0030172787713f,
0.0029793985165f,
0.0029415104608f,
0.0029036256018f,
0.0028657548267f,
0.0028279089079f,
0.0027900984982f,
0.0027523341262f,
0.0027146261921f,
0.0026769849632f,
0.0026394205698f,
0.0026019430011f,
0.0025645621012f,
0.0025272875658f,
0.0024901289377f,
0.0024530956039f,
0.0024161967921f,
0.0023794415672f,
0.0023428388283f,
0.0023063973058f,
0.0022701255585f,
0.0022340319707f,
0.0021981247499f,
0.0021624119242f,
0.0021269013399f,
0.0020916006596f,
0.0020565173602f,
0.0020216587307f,
0.0019870318707f,
0.0019526436887f,
0.0019185009010f,
0.0018846100298f,
0.0018509774026f,
0.0018176091508f,
0.0017845112089f,
0.0017516893140f,
0.0017191490046f,
0.0016868956210f,
0.0016549343039f,
0.0016232699954f,
0.0015919074376f,
0.0015608511740f,
0.0015301055485f,
0.0014996747065f,
0.0014695625952f,
0.0014397729637f,
0.0014103093644f,
0.0013811751533f,
0.0013523734912f,
0.0013239073445f,
0.0012957794865f,
0.0012679924989f,
0.0012405487727f,
0.0012134505102f,
0.0011866997262f,
0.0011602982499f,
0.0011342477266f,
0.0011085496198f,
0.0010832052129f,
0.0010582156116f,
0.0010335817458f,
0.0010093043719f,
0.0009853840755f,
0.0009618212732f,
0.0009386162156f,
0.0009157689899f,
0.0008932795221f,
0.0008711475801f,
0.0008493727764f,
0.0008279545709f,
0.0008068922738f,
0.0007861850487f,
0.0007658319153f,
0.0007458317529f,
0.0007261833032f,
0.0007068851735f,
0.0006879358399f,
0.0006693336508f,
0.0006510768296f,
0.0006331634787f,
0.0006155915822f,
0.0005983590097f,
0.0005814635194f,
0.0005649027617f,
0.0005486742825f,
0.0005327755266f,
0.0005172038413f,
0.0005019564795f,
0.0004870306035f,
0.0004724232886f,
0.0004581315258f,
0.0004441522261f,
0.0004304822235f,
0.0004171182782f,
0.0004040570809f,
0.0003912952551f,
0.0003788293613f,
0.0003666559000f,
0.0003547713152f,
0.0003431719977f,
0.0003318542882f,
0.0003208144809f,
0.0003100488266f,
0.0002995535358f,
0.0002893247820f,
0.0002793587049f,
0.0002696514131f,
0.0002601989878f,
0.0002509974854f,
0.0002420429405f,
0.0002333313688f,
0.0002248587702f,
0.0002166211315f,
0.0002086144290f,
0.0002008346317f,
0.0001932777035f,
0.0001859396059f,
0.0001788163010f,
0.0001719037534f,
0.0001651979332f,
0.0001586948179f,
0.0001523903952f,
0.0001462806650f,
0.0001403616418f,
0.0001346293565f,
0.0001290798590f,
0.0001237092199f,
0.0001185135326f,
0.0001134889152f,
0.0001086315122f,
0.0001039374965f,
0.0000994030710f,
0.0000950244704f,
0.0000907979625f,
0.0000867198500f,
0.0000827864719f,
0.0000789942048f,
0.0000753394644f,
0.0000718187066f,
0.0000684284288f,
0.0000651651712f,
0.0000620255175f,
0.0000590060964f,
0.0000561035822f,
0.0000533146957f,
0.0000506362055f,
0.0000480649281f,
0.0000455977293f,
0.0000432315243f,
0.0000409632787f,
0.0000387900088f,
0.0000367087824f,
0.0000347167188f,
0.0000328109897f,
0.0000309888191f,
0.0000292474837f,
0.0000275843135f,
0.0000259966913f,
0.0000244820535f,
0.0000230378899f,
0.0000216617435f,
0.0000203512110f,
0.0000191039423f,
0.0000179176408f,
0.0000167900628f,
0.0000157190179f,
0.0000147023683f,
0.0000137380287f,
0.0000128239662f,
0.0000119581996f,
0.0000111387995f,
0.0000103638874f,
0.0000096316359f,
0.0000089402676f,
0.0000082880550f,
0.0000076733199f,
0.0000070944329f,
0.0000065498127f,
0.0000060379258f,
0.0000055572854f,
0.0000051064513f,
0.0000046840291f,
0.0000042886691f,
0.0000039190664f,
0.0000035739593f,
0.0000032521294f,
0.0000029524002f,
0.0000026736369f,
0.0000024147452f,
0.0000021746708f,
0.0000019523988f,
0.0000017469545f,
0.0000015574122f,
0.0000013829611f,
0.0000012233487f,
0.0000010818484f,
0.0000009851064f,
0.0000011158244f,
0.0000026997780f,
-0.0000004327587f,
};
}
}

141
core/src/dsp/firdec/taps/fir_1024_32.h
Wyświetl plik

@ -1,141 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_1024_32_len = 127;
const float fir_1024_32_taps[] = {
0.0000088623347f,
0.0000103966907f,
0.0000163498386f,
0.0000244235766f,
0.0000351129776f,
0.0000489833599f,
0.0000666735323f,
0.0000888982223f,
0.0001164495403f,
0.0001501973386f,
0.0001910883324f,
0.0002401438579f,
0.0002984561609f,
0.0003671831240f,
0.0004475413632f,
0.0005407976486f,
0.0006482586323f,
0.0007712588932f,
0.0009111473429f,
0.0010692720689f,
0.0012469637247f,
0.0014455176106f,
0.0016661746238f,
0.0019101012879f,
0.0021783691022f,
0.0024719334814f,
0.0027916125787f,
0.0031380663077f,
0.0035117758952f,
0.0039130243058f,
0.0043418778893f,
0.0047981695968f,
0.0052814841081f,
0.0057911451996f,
0.0063262056615f,
0.0068854400478f,
0.0074673405131f,
0.0080701159494f,
0.0086916945938f,
0.0093297302355f,
0.0099816120904f,
0.0106444783655f,
0.0113152334735f,
0.0119905688011f,
0.0126669868781f,
0.0133408287327f,
0.0140083041674f,
0.0146655246349f,
0.0153085383440f,
0.0159333671827f,
0.0165360450080f,
0.0171126568203f,
0.0176593783140f,
0.0181725152845f,
0.0186485423586f,
0.0190841405193f,
0.0194762329058f,
0.0198220183835f,
0.0201190024112f,
0.0203650247621f,
0.0205582836996f,
0.0206973562585f,
0.0207812143359f,
0.0208092363555f,
0.0207812143359f,
0.0206973562585f,
0.0205582836996f,
0.0203650247621f,
0.0201190024112f,
0.0198220183835f,
0.0194762329058f,
0.0190841405193f,
0.0186485423586f,
0.0181725152845f,
0.0176593783140f,
0.0171126568203f,
0.0165360450080f,
0.0159333671827f,
0.0153085383440f,
0.0146655246349f,
0.0140083041674f,
0.0133408287327f,
0.0126669868781f,
0.0119905688011f,
0.0113152334735f,
0.0106444783655f,
0.0099816120904f,
0.0093297302355f,
0.0086916945938f,
0.0080701159494f,
0.0074673405131f,
0.0068854400478f,
0.0063262056615f,
0.0057911451996f,
0.0052814841081f,
0.0047981695968f,
0.0043418778893f,
0.0039130243058f,
0.0035117758952f,
0.0031380663077f,
0.0027916125787f,
0.0024719334814f,
0.0021783691022f,
0.0019101012879f,
0.0016661746238f,
0.0014455176106f,
0.0012469637247f,
0.0010692720689f,
0.0009111473429f,
0.0007712588932f,
0.0006482586323f,
0.0005407976486f,
0.0004475413632f,
0.0003671831240f,
0.0002984561609f,
0.0002401438579f,
0.0001910883324f,
0.0001501973386f,
0.0001164495403f,
0.0000888982223f,
0.0000666735323f,
0.0000489833599f,
0.0000351129776f,
0.0000244235766f,
0.0000163498386f,
0.0000103966907f,
0.0000088623347f,
};
}
}

319
core/src/dsp/firdec/taps/fir_1024_64.h
Wyświetl plik

@ -1,319 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_1024_64_len = 305;
const float fir_1024_64_taps[] = {
-0.0000003266961f,
0.0000005644686f,
0.0000005207559f,
0.0000006201056f,
0.0000007969193f,
0.0000010314179f,
0.0000013207983f,
0.0000016688347f,
0.0000020821477f,
0.0000025688841f,
0.0000031382689f,
0.0000038004715f,
0.0000045665874f,
0.0000054486602f,
0.0000064597188f,
0.0000076138203f,
0.0000089260936f,
0.0000104127838f,
0.0000120912955f,
0.0000139802356f,
0.0000160994544f,
0.0000184700853f,
0.0000211145831f,
0.0000240567590f,
0.0000273218150f,
0.0000309363737f,
0.0000349285069f,
0.0000393277598f,
0.0000441651722f,
0.0000494732958f,
0.0000552862073f,
0.0000616395176f,
0.0000685703757f,
0.0000761174680f,
0.0000843210124f,
0.0000932227473f,
0.0001028659142f,
0.0001132952349f,
0.0001245568823f,
0.0001366984450f,
0.0001497688854f,
0.0001638184908f,
0.0001788988175f,
0.0001950626288f,
0.0002123638243f,
0.0002308573636f,
0.0002505991815f,
0.0002716460964f,
0.0002940557114f,
0.0003178863073f,
0.0003431967298f,
0.0003700462674f,
0.0003984945244f,
0.0004286012850f,
0.0004604263715f,
0.0004940294961f,
0.0005294701054f,
0.0005668072195f,
0.0006060992649f,
0.0006474039021f,
0.0006907778476f,
0.0007362766917f,
0.0007839547115f,
0.0008338646804f,
0.0008860576734f,
0.0009405828709f,
0.0009974873584f,
0.0010568159258f,
0.0011186108652f,
0.0011829117671f,
0.0012497553185f,
0.0013191750998f,
0.0013912013845f,
0.0014658609399f,
0.0015431768319f,
0.0016231682316f,
0.0017058502277f,
0.0017912336426f,
0.0018793248552f,
0.0019701256291f,
0.0020636329490f,
0.0021598388638f,
0.0022587303394f,
0.0023602891198f,
0.0024644915987f,
0.0025713087020f,
0.0026807057805f,
0.0027926425160f,
0.0029070728383f,
0.0030239448570f,
0.0031432008054f,
0.0032647769995f,
0.0033886038113f,
0.0035146056570f,
0.0036427010010f,
0.0037728023754f,
0.0039048164157f,
0.0040386439125f,
0.0041741798805f,
0.0043113136430f,
0.0044499289348f,
0.0045899040199f,
0.0047311118279f,
0.0048734201058f,
0.0050166915869f,
0.0051607841763f,
0.0053055511521f,
0.0054508413827f,
0.0055964995596f,
0.0057423664451f,
0.0058882791347f,
0.0060340713337f,
0.0061795736469f,
0.0063246138814f,
0.0064690173614f,
0.0066126072545f,
0.0067552049086f,
0.0068966301982f,
0.0070367018801f,
0.0071752379566f,
0.0073120560462f,
0.0074469737596f,
0.0075798090815f,
0.0077103807554f,
0.0078385086722f,
0.0079640142599f,
0.0080867208743f,
0.0082064541886f,
0.0083230425826f,
0.0084363175276f,
0.0085461139687f,
0.0086522707012f,
0.0087546307414f,
0.0088530416894f,
0.0089473560847f,
0.0090374317506f,
0.0091231321298f,
0.0092043266071f,
0.0092808908203f,
0.0093527069569f,
0.0094196640373f,
0.0094816581810f,
0.0095385928587f,
0.0095903791253f,
0.0096369358365f,
0.0096781898465f,
0.0097140761868f,
0.0097445382248f,
0.0097695278031f,
0.0097890053575f,
0.0098029400143f,
0.0098113096665f,
0.0098141010281f,
0.0098113096665f,
0.0098029400143f,
0.0097890053575f,
0.0097695278031f,
0.0097445382248f,
0.0097140761868f,
0.0096781898465f,
0.0096369358365f,
0.0095903791253f,
0.0095385928587f,
0.0094816581810f,
0.0094196640373f,
0.0093527069569f,
0.0092808908203f,
0.0092043266071f,
0.0091231321298f,
0.0090374317506f,
0.0089473560847f,
0.0088530416894f,
0.0087546307414f,
0.0086522707012f,
0.0085461139687f,
0.0084363175276f,
0.0083230425826f,
0.0082064541886f,
0.0080867208743f,
0.0079640142599f,
0.0078385086722f,
0.0077103807554f,
0.0075798090815f,
0.0074469737596f,
0.0073120560462f,
0.0071752379566f,
0.0070367018801f,
0.0068966301982f,
0.0067552049086f,
0.0066126072545f,
0.0064690173614f,
0.0063246138814f,
0.0061795736469f,
0.0060340713337f,
0.0058882791347f,
0.0057423664451f,
0.0055964995596f,
0.0054508413827f,
0.0053055511521f,
0.0051607841763f,
0.0050166915869f,
0.0048734201058f,
0.0047311118279f,
0.0045899040199f,
0.0044499289348f,
0.0043113136430f,
0.0041741798805f,
0.0040386439125f,
0.0039048164157f,
0.0037728023754f,
0.0036427010010f,
0.0035146056570f,
0.0033886038113f,
0.0032647769995f,
0.0031432008054f,
0.0030239448570f,
0.0029070728383f,
0.0027926425160f,
0.0026807057805f,
0.0025713087020f,
0.0024644915987f,
0.0023602891198f,
0.0022587303394f,
0.0021598388638f,
0.0020636329490f,
0.0019701256291f,
0.0018793248552f,
0.0017912336426f,
0.0017058502277f,
0.0016231682316f,
0.0015431768319f,
0.0014658609399f,
0.0013912013845f,
0.0013191750998f,
0.0012497553185f,
0.0011829117671f,
0.0011186108652f,
0.0010568159258f,
0.0009974873584f,
0.0009405828709f,
0.0008860576734f,
0.0008338646804f,
0.0007839547115f,
0.0007362766917f,
0.0006907778476f,
0.0006474039021f,
0.0006060992649f,
0.0005668072195f,
0.0005294701054f,
0.0004940294961f,
0.0004604263715f,
0.0004286012850f,
0.0003984945244f,
0.0003700462674f,
0.0003431967298f,
0.0003178863073f,
0.0002940557114f,
0.0002716460964f,
0.0002505991815f,
0.0002308573636f,
0.0002123638243f,
0.0001950626288f,
0.0001788988175f,
0.0001638184908f,
0.0001497688854f,
0.0001366984450f,
0.0001245568823f,
0.0001132952349f,
0.0001028659142f,
0.0000932227473f,
0.0000843210124f,
0.0000761174680f,
0.0000685703757f,
0.0000616395176f,
0.0000552862073f,
0.0000494732958f,
0.0000441651722f,
0.0000393277598f,
0.0000349285069f,
0.0000309363737f,
0.0000273218150f,
0.0000240567590f,
0.0000211145831f,
0.0000184700853f,
0.0000160994544f,
0.0000139802356f,
0.0000120912955f,
0.0000104127838f,
0.0000089260936f,
0.0000076138203f,
0.0000064597188f,
0.0000054486602f,
0.0000045665874f,
0.0000038004715f,
0.0000031382689f,
0.0000025688841f,
0.0000020821477f,
0.0000016688347f,
0.0000013207983f,
0.0000010314179f,
0.0000007969193f,
0.0000006201056f,
0.0000005207559f,
0.0000005644686f,
-0.0000003266961f,
};
}
}

85
core/src/dsp/firdec/taps/fir_128_16.h
Wyświetl plik

@ -1,85 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_128_16_len = 71;
const float fir_128_16_taps[] = {
0.0000064694540f,
0.0000182067578f,
0.0000368085722f,
0.0000719935366f,
0.0001252867548f,
0.0002081925226f,
0.0003273131837f,
0.0004962053053f,
0.0007259672049f,
0.0010324295967f,
0.0014300214273f,
0.0019359256876f,
0.0025658768245f,
0.0033363360449f,
0.0042614372892f,
0.0053539132757f,
0.0066227902827f,
0.0080736193595f,
0.0097067738877f,
0.0115174330954f,
0.0134944842883f,
0.0156206149876f,
0.0178718768069f,
0.0202181371097f,
0.0226233377697f,
0.0250464274976f,
0.0274422678072f,
0.0297630224211f,
0.0319595549880f,
0.0339831151557f,
0.0357869729439f,
0.0373281403598f,
0.0385689282047f,
0.0394784014454f,
0.0400335473450f,
0.0402201936432f,
0.0400335473450f,
0.0394784014454f,
0.0385689282047f,
0.0373281403598f,
0.0357869729439f,
0.0339831151557f,
0.0319595549880f,
0.0297630224211f,
0.0274422678072f,
0.0250464274976f,
0.0226233377697f,
0.0202181371097f,
0.0178718768069f,
0.0156206149876f,
0.0134944842883f,
0.0115174330954f,
0.0097067738877f,
0.0080736193595f,
0.0066227902827f,
0.0053539132757f,
0.0042614372892f,
0.0033363360449f,
0.0025658768245f,
0.0019359256876f,
0.0014300214273f,
0.0010324295967f,
0.0007259672049f,
0.0004962053053f,
0.0003273131837f,
0.0002081925226f,
0.0001252867548f,
0.0000719935366f,
0.0000368085722f,
0.0000182067578f,
0.0000064694540f,
};
}
}

194
core/src/dsp/firdec/taps/fir_128_32.h
Wyświetl plik

@ -1,194 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_128_32_len = 180;
const float fir_128_32_taps[] = {
-0.0000073470522f,
-0.0000069110271f,
-0.0000100675012f,
-0.0000140912235f,
-0.0000191269472f,
-0.0000253238429f,
-0.0000328428415f,
-0.0000418456044f,
-0.0000525009779f,
-0.0000649731010f,
-0.0000794269134f,
-0.0000960153923f,
-0.0001148841160f,
-0.0001361576878f,
-0.0001599434282f,
-0.0001863171187f,
-0.0002153259738f,
-0.0002469739186f,
-0.0002812240728f,
-0.0003179838558f,
-0.0003571072928f,
-0.0003983803151f,
-0.0004415232676f,
-0.0004861768325f,
-0.0005319051695f,
-0.0005781829346f,
-0.0006243995153f,
-0.0006698476317f,
-0.0007137291329f,
-0.0007551456568f,
-0.0007931064250f,
-0.0008265213926f,
-0.0008542114175f,
-0.0008749042532f,
-0.0008872473744f,
-0.0008898070530f,
-0.0008810839958f,
-0.0008595156045f,
-0.0008234944283f,
-0.0007713735444f,
-0.0007014876566f,
-0.0006121613543f,
-0.0005017325051f,
-0.0003685629664f,
-0.0002110637384f,
-0.0000277075239f,
0.0001829450626f,
0.0004222318502f,
0.0006913626978f,
0.0009914056595f,
0.0013232613264f,
0.0016876497890f,
0.0020850867621f,
0.0025158723705f,
0.0029800700983f,
0.0034774984108f,
0.0040077135249f,
0.0045700048063f,
0.0051633822546f,
0.0057865764825f,
0.0064380316487f,
0.0071159106399f,
0.0078180939705f,
0.0085421905540f,
0.0092855428368f,
0.0100452432731f,
0.0108181456753f,
0.0116008872163f,
0.0123899056779f,
0.0131814665052f,
0.0139716853391f,
0.0147565593567f,
0.0155319941959f,
0.0162938385551f,
0.0170379143753f,
0.0177600534535f,
0.0184561295564f,
0.0191220956422f,
0.0197540164501f,
0.0203481048339f,
0.0209007533176f,
0.0214085680250f,
0.0218683977139f,
0.0222773638505f,
0.0226328857338f,
0.0229327054015f,
0.0231749076307f,
0.0233579385724f,
0.0234806196554f,
0.0235421591137f,
0.0235421591137f,
0.0234806196554f,
0.0233579385724f,
0.0231749076307f,
0.0229327054015f,
0.0226328857338f,
0.0222773638505f,
0.0218683977139f,
0.0214085680250f,
0.0209007533176f,
0.0203481048339f,
0.0197540164501f,
0.0191220956422f,
0.0184561295564f,
0.0177600534535f,
0.0170379143753f,
0.0162938385551f,
0.0155319941959f,
0.0147565593567f,
0.0139716853391f,
0.0131814665052f,
0.0123899056779f,
0.0116008872163f,
0.0108181456753f,
0.0100452432731f,
0.0092855428368f,
0.0085421905540f,
0.0078180939705f,
0.0071159106399f,
0.0064380316487f,
0.0057865764825f,
0.0051633822546f,
0.0045700048063f,
0.0040077135249f,
0.0034774984108f,
0.0029800700983f,
0.0025158723705f,
0.0020850867621f,
0.0016876497890f,
0.0013232613264f,
0.0009914056595f,
0.0006913626978f,
0.0004222318502f,
0.0001829450626f,
-0.0000277075239f,
-0.0002110637384f,
-0.0003685629664f,
-0.0005017325051f,
-0.0006121613543f,
-0.0007014876566f,
-0.0007713735444f,
-0.0008234944283f,
-0.0008595156045f,
-0.0008810839958f,
-0.0008898070530f,
-0.0008872473744f,
-0.0008749042532f,
-0.0008542114175f,
-0.0008265213926f,
-0.0007931064250f,
-0.0007551456568f,
-0.0007137291329f,
-0.0006698476317f,
-0.0006243995153f,
-0.0005781829346f,
-0.0005319051695f,
-0.0004861768325f,
-0.0004415232676f,
-0.0003983803151f,
-0.0003571072928f,
-0.0003179838558f,
-0.0002812240728f,
-0.0002469739186f,
-0.0002153259738f,
-0.0001863171187f,
-0.0001599434282f,
-0.0001361576878f,
-0.0001148841160f,
-0.0000960153923f,
-0.0000794269134f,
-0.0000649731010f,
-0.0000525009779f,
-0.0000418456044f,
-0.0000328428415f,
-0.0000253238429f,
-0.0000191269472f,
-0.0000140912235f,
-0.0000100675012f,
-0.0000069110271f,
-0.0000073470522f,
};
}
}

30
core/src/dsp/firdec/taps/fir_128_4.h
Wyświetl plik

@ -1,30 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_128_4_len = 16;
const float fir_128_4_taps[] = {
0.0003502294673f,
0.0025622621714f,
0.0100604175711f,
0.0274832811630f,
0.0576540582560f,
0.0975667617613f,
0.1368722747794f,
0.1615718864375f,
0.1615718864375f,
0.1368722747794f,
0.0975667617613f,
0.0576540582560f,
0.0274832811630f,
0.0100604175711f,
0.0025622621714f,
0.0003502294673f,
};
}
}

521
core/src/dsp/firdec/taps/fir_128_64.h
Wyświetl plik

@ -1,521 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_128_64_len = 507;
const float fir_128_64_taps[] = {
0.0000059328143f,
0.0000021865747f,
0.0000025830027f,
0.0000030222125f,
0.0000035067628f,
0.0000040392284f,
0.0000046221895f,
0.0000052582199f,
0.0000059498747f,
0.0000066996765f,
0.0000075101016f,
0.0000083835652f,
0.0000093224054f,
0.0000103288670f,
0.0000114050841f,
0.0000125530626f,
0.0000137746613f,
0.0000150715728f,
0.0000164453038f,
0.0000178971548f,
0.0000194281990f,
0.0000210392611f,
0.0000227308957f,
0.0000245033648f,
0.0000263566159f,
0.0000282902593f,
0.0000303035451f,
0.0000323953405f,
0.0000345641075f,
0.0000368078793f,
0.0000391242389f,
0.0000415102957f,
0.0000439626648f,
0.0000464774447f,
0.0000490501970f,
0.0000516759262f,
0.0000543490601f,
0.0000570634318f,
0.0000598122618f,
0.0000625881417f,
0.0000653830194f,
0.0000681881850f,
0.0000709942585f,
0.0000737911790f,
0.0000765681960f,
0.0000793138614f,
0.0000820160247f,
0.0000846618292f,
0.0000872377109f,
0.0000897293998f,
0.0000921219225f,
0.0000943996085f,
0.0000965460984f,
0.0000985443543f,
0.0001003766741f,
0.0001020247075f,
0.0001034694753f,
0.0001046913914f,
0.0001056702886f,
0.0001063854463f,
0.0001068156220f,
0.0001069390861f,
0.0001067336594f,
0.0001061767539f,
0.0001052454174f,
0.0001039163805f,
0.0001021661074f,
0.0000999708498f,
0.0000973067041f,
0.0000941496711f,
0.0000904757201f,
0.0000862608548f,
0.0000814811826f,
0.0000761129878f,
0.0000701328055f,
0.0000635175006f,
0.0000562443479f,
0.0000482911149f,
0.0000396361475f,
0.0000302584574f,
0.0000201378119f,
0.0000092548251f,
-0.0000024089487f,
-0.0000148709202f,
-0.0000281473694f,
-0.0000422533485f,
-0.0000572025836f,
-0.0000730073769f,
-0.0000896785070f,
-0.0001072251303f,
-0.0001256546823f,
-0.0001449727787f,
-0.0001651831180f,
-0.0001862873844f,
-0.0002082851526f,
-0.0002311737938f,
-0.0002549483834f,
-0.0002796016114f,
-0.0003051236947f,
-0.0003315022928f,
-0.0003587224261f,
-0.0003867663977f,
-0.0004156137196f,
-0.0004452410417f,
-0.0004756220865f,
-0.0005067275876f,
-0.0005385252334f,
-0.0005709796161f,
-0.0006040521866f,
-0.0006377012146f,
-0.0006718817554f,
-0.0007065456227f,
-0.0007416413688f,
-0.0007771142706f,
-0.0008129063239f,
-0.0008489562441f,
-0.0008851994755f,
-0.0009215682077f,
-0.0009579914002f,
-0.0009943948149f,
-0.0010307010577f,
-0.0010668296278f,
-0.0011026969756f,
-0.0011382165698f,
-0.0011732989726f,
-0.0012078519242f,
-0.0012417804357f,
-0.0012749868911f,
-0.0013073711584f,
-0.0013388307085f,
-0.0013692607440f,
-0.0013985543359f,
-0.0014266025695f,
-0.0014532946976f,
-0.0014785183035f,
-0.0015021594706f,
-0.0015241029610f,
-0.0015442324013f,
-0.0015624304759f,
-0.0015785791272f,
-0.0015925597630f,
-0.0016042534706f,
-0.0016135412362f,
-0.0016203041714f,
-0.0016244237439f,
-0.0016257820138f,
-0.0016242618751f,
-0.0016197472998f,
-0.0016121235873f,
-0.0016012776158f,
-0.0015870980974f,
-0.0015694758340f,
-0.0015483039764f,
-0.0015234782833f,
-0.0014948973813f,
-0.0014624630249f,
-0.0014260803553f,
-0.0013856581588f,
-0.0013411091226f,
-0.0012923500886f,
-0.0012393023038f,
-0.0011818916675f,
-0.0011200489733f,
-0.0010537101473f,
-0.0009828164799f,
-0.0009073148519f,
-0.0008271579535f,
-0.0007423044962f,
-0.0006527194165f,
-0.0005583740715f,
-0.0004592464247f,
-0.0003553212224f,
-0.0002465901604f,
-0.0001330520388f,
-0.0000147129070f,
0.0001084138051f,
0.0002363071656f,
0.0003689386344f,
0.0005062719681f,
0.0006482631397f,
0.0007948602715f,
0.0009460035829f,
0.0011016253518f,
0.0012616498923f,
0.0014259935461f,
0.0015945646903f,
0.0017672637604f,
0.0019439832887f,
0.0021246079593f,
0.0023090146782f,
0.0024970726603f,
0.0026886435316f,
0.0028835814481f,
0.0030817332298f,
0.0032829385117f,
0.0034870299096f,
0.0036938332018f,
0.0039031675262f,
0.0041148455925f,
0.0043286739091f,
0.0045444530249f,
0.0047619777845f,
0.0049810375985f,
0.0052014167253f,
0.0054228945678f,
0.0056452459812f,
0.0058682415926f,
0.0060916481332f,
0.0063152287796f,
0.0065387435067f,
0.0067619494488f,
0.0069846012704f,
0.0072064515449f,
0.0074272511403f,
0.0076467496121f,
0.0078646956013f,
0.0080808372388f,
0.0082949225525f,
0.0085066998790f,
0.0087159182778f,
0.0089223279466f,
0.0091256806387f,
0.0093257300791f,
0.0095222323814f,
0.0097149464619f,
0.0099036344516f,
0.0100880621047f,
0.0102679992034f,
0.0104432199569f,
0.0106135033952f,
0.0107786337550f,
0.0109384008597f,
0.0110926004890f,
0.0112410347414f,
0.0113835123847f,
0.0115198491970f,
0.0116498682958f,
0.0117734004551f,
0.0118902844090f,
0.0120003671424f,
0.0121035041671f,
0.0121995597832f,
0.0122884073249f,
0.0123699293904f,
0.0124440180558f,
0.0125105750712f,
0.0125695120403f,
0.0126207505817f,
0.0126642224718f,
0.0126998697703f,
0.0127276449258f,
0.0127475108633f,
0.0127594410518f,
0.0127634195532f,
0.0127594410518f,
0.0127475108633f,
0.0127276449258f,
0.0126998697703f,
0.0126642224718f,
0.0126207505817f,
0.0125695120403f,
0.0125105750712f,
0.0124440180558f,
0.0123699293904f,
0.0122884073249f,
0.0121995597832f,
0.0121035041671f,
0.0120003671424f,
0.0118902844090f,
0.0117734004551f,
0.0116498682958f,
0.0115198491970f,
0.0113835123847f,
0.0112410347414f,
0.0110926004890f,
0.0109384008597f,
0.0107786337550f,
0.0106135033952f,
0.0104432199569f,
0.0102679992034f,
0.0100880621047f,
0.0099036344516f,
0.0097149464619f,
0.0095222323814f,
0.0093257300791f,
0.0091256806387f,
0.0089223279466f,
0.0087159182778f,
0.0085066998790f,
0.0082949225525f,
0.0080808372388f,
0.0078646956013f,
0.0076467496121f,
0.0074272511403f,
0.0072064515449f,
0.0069846012704f,
0.0067619494488f,
0.0065387435067f,
0.0063152287796f,
0.0060916481332f,
0.0058682415926f,
0.0056452459812f,
0.0054228945678f,
0.0052014167253f,
0.0049810375985f,
0.0047619777845f,
0.0045444530249f,
0.0043286739091f,
0.0041148455925f,
0.0039031675262f,
0.0036938332018f,
0.0034870299096f,
0.0032829385117f,
0.0030817332298f,
0.0028835814481f,
0.0026886435316f,
0.0024970726603f,
0.0023090146782f,
0.0021246079593f,
0.0019439832887f,
0.0017672637604f,
0.0015945646903f,
0.0014259935461f,
0.0012616498923f,
0.0011016253518f,
0.0009460035829f,
0.0007948602715f,
0.0006482631397f,
0.0005062719681f,
0.0003689386344f,
0.0002363071656f,
0.0001084138051f,
-0.0000147129070f,
-0.0001330520388f,
-0.0002465901604f,
-0.0003553212224f,
-0.0004592464247f,
-0.0005583740715f,
-0.0006527194165f,
-0.0007423044962f,
-0.0008271579535f,
-0.0009073148519f,
-0.0009828164799f,
-0.0010537101473f,
-0.0011200489733f,
-0.0011818916675f,
-0.0012393023038f,
-0.0012923500886f,
-0.0013411091226f,
-0.0013856581588f,
-0.0014260803553f,
-0.0014624630249f,
-0.0014948973813f,
-0.0015234782833f,
-0.0015483039764f,
-0.0015694758340f,
-0.0015870980974f,
-0.0016012776158f,
-0.0016121235873f,
-0.0016197472998f,
-0.0016242618751f,
-0.0016257820138f,
-0.0016244237439f,
-0.0016203041714f,
-0.0016135412362f,
-0.0016042534706f,
-0.0015925597630f,
-0.0015785791272f,
-0.0015624304759f,
-0.0015442324013f,
-0.0015241029610f,
-0.0015021594706f,
-0.0014785183035f,
-0.0014532946976f,
-0.0014266025695f,
-0.0013985543359f,
-0.0013692607440f,
-0.0013388307085f,
-0.0013073711584f,
-0.0012749868911f,
-0.0012417804357f,
-0.0012078519242f,
-0.0011732989726f,
-0.0011382165698f,
-0.0011026969756f,
-0.0010668296278f,
-0.0010307010577f,
-0.0009943948149f,
-0.0009579914002f,
-0.0009215682077f,
-0.0008851994755f,
-0.0008489562441f,
-0.0008129063239f,
-0.0007771142706f,
-0.0007416413688f,
-0.0007065456227f,
-0.0006718817554f,
-0.0006377012146f,
-0.0006040521866f,
-0.0005709796161f,
-0.0005385252334f,
-0.0005067275876f,
-0.0004756220865f,
-0.0004452410417f,
-0.0004156137196f,
-0.0003867663977f,
-0.0003587224261f,
-0.0003315022928f,
-0.0003051236947f,
-0.0002796016114f,
-0.0002549483834f,
-0.0002311737938f,
-0.0002082851526f,
-0.0001862873844f,
-0.0001651831180f,
-0.0001449727787f,
-0.0001256546823f,
-0.0001072251303f,
-0.0000896785070f,
-0.0000730073769f,
-0.0000572025836f,
-0.0000422533485f,
-0.0000281473694f,
-0.0000148709202f,
-0.0000024089487f,
0.0000092548251f,
0.0000201378119f,
0.0000302584574f,
0.0000396361475f,
0.0000482911149f,
0.0000562443479f,
0.0000635175006f,
0.0000701328055f,
0.0000761129878f,
0.0000814811826f,
0.0000862608548f,
0.0000904757201f,
0.0000941496711f,
0.0000973067041f,
0.0000999708498f,
0.0001021661074f,
0.0001039163805f,
0.0001052454174f,
0.0001061767539f,
0.0001067336594f,
0.0001069390861f,
0.0001068156220f,
0.0001063854463f,
0.0001056702886f,
0.0001046913914f,
0.0001034694753f,
0.0001020247075f,
0.0001003766741f,
0.0000985443543f,
0.0000965460984f,
0.0000943996085f,
0.0000921219225f,
0.0000897293998f,
0.0000872377109f,
0.0000846618292f,
0.0000820160247f,
0.0000793138614f,
0.0000765681960f,
0.0000737911790f,
0.0000709942585f,
0.0000681881850f,
0.0000653830194f,
0.0000625881417f,
0.0000598122618f,
0.0000570634318f,
0.0000543490601f,
0.0000516759262f,
0.0000490501970f,
0.0000464774447f,
0.0000439626648f,
0.0000415102957f,
0.0000391242389f,
0.0000368078793f,
0.0000345641075f,
0.0000323953405f,
0.0000303035451f,
0.0000282902593f,
0.0000263566159f,
0.0000245033648f,
0.0000227308957f,
0.0000210392611f,
0.0000194281990f,
0.0000178971548f,
0.0000164453038f,
0.0000150715728f,
0.0000137746613f,
0.0000125530626f,
0.0000114050841f,
0.0000103288670f,
0.0000093224054f,
0.0000083835652f,
0.0000075101016f,
0.0000066996765f,
0.0000059498747f,
0.0000052582199f,
0.0000046221895f,
0.0000040392284f,
0.0000035067628f,
0.0000030222125f,
0.0000025830027f,
0.0000021865747f,
0.0000059328143f,
};
}
}

47
core/src/dsp/firdec/taps/fir_128_8.h
Wyświetl plik

@ -1,47 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_128_8_len = 33;
const float fir_128_8_taps[] = {
0.0000402645396f,
0.0001776497260f,
0.0005328099895f,
0.0012889952275f,
0.0026955140465f,
0.0050490564879f,
0.0086535181818f,
0.0137600626254f,
0.0204960424230f,
0.0287971941582f,
0.0383605456257f,
0.0486341848839f,
0.0588539901422f,
0.0681275795918f,
0.0755543850679f,
0.0803608914008f,
0.0820245881555f,
0.0803608914008f,
0.0755543850679f,
0.0681275795918f,
0.0588539901422f,
0.0486341848839f,
0.0383605456257f,
0.0287971941582f,
0.0204960424230f,
0.0137600626254f,
0.0086535181818f,
0.0050490564879f,
0.0026955140465f,
0.0012889952275f,
0.0005328099895f,
0.0001776497260f,
0.0000402645396f,
};
}
}

566
core/src/dsp/firdec/taps/fir_16_16.h
Wyświetl plik

@ -1,566 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_16_16_len = 552;
const float fir_16_16_taps[] = {
0.0000083199827f,
0.0000084881676f,
0.0000125885567f,
0.0000177804634f,
0.0000241852833f,
0.0000319042337f,
0.0000410140885f,
0.0000515556971f,
0.0000635293624f,
0.0000768836058f,
0.0000915114120f,
0.0001072405937f,
0.0001238323243f,
0.0001409745652f,
0.0001582843174f,
0.0001753054713f,
0.0001915159849f,
0.0002063311677f,
0.0002191165223f,
0.0002291968856f,
0.0002358749754f,
0.0002384460258f,
0.0002362212252f,
0.0002285465848f,
0.0002148295414f,
0.0001945599050f,
0.0001673370635f,
0.0001328901081f,
0.0000911024573f,
0.0000420277999f,
-0.0000140913087f,
-0.0000768150927f,
-0.0001454972457f,
-0.0002192871274f,
-0.0002971322962f,
-0.0003777932686f,
-0.0004598592590f,
-0.0005417761096f,
-0.0006218750188f,
-0.0006984125260f,
-0.0007696102015f,
-0.0008337037348f,
-0.0008889897559f,
-0.0009338793741f,
-0.0009669467668f,
-0.0009869812183f,
-0.0009930311084f,
-0.0009844478476f,
-0.0009609186466f,
-0.0009224959242f,
-0.0008696128718f,
-0.0008030930096f,
-0.0007241441121f,
-0.0006343445666f,
-0.0005356135898f,
-0.0004301737349f,
-0.0003204982716f,
-0.0002092522968f,
-0.0000992213271f,
0.0000067633979f,
0.0001059080771f,
0.0001955385388f,
0.0002731857749f,
0.0003366654366f,
0.0003841550469f,
0.0004142599400f,
0.0004260714830f,
0.0004192093552f,
0.0003938516106f,
0.0003507454223f,
0.0002912027367f,
0.0002170751467f,
0.0001307129555f,
0.0000349043239f,
-0.0000671996814f,
-0.0001721766401f,
-0.0002764343270f,
-0.0003763233051f,
-0.0004682533995f,
-0.0005488139662f,
-0.0006148906121f,
-0.0006637776003f,
-0.0006932789118f,
-0.0007017970554f,
-0.0006884034538f,
-0.0006528899123f,
-0.0005957963722f,
-0.0005184153646f,
-0.0004227701586f,
-0.0003115682847f,
-0.0001881294675f,
-0.0000562910721f,
0.0000797078370f,
0.0002153593731f,
0.0003460336990f,
0.0004671344133f,
0.0005742581225f,
0.0006633522280f,
0.0007308658562f,
0.0007738881585f,
0.0007902689274f,
0.0007787167083f,
0.0007388701444f,
0.0006713394034f,
0.0005777148960f,
0.0004605423719f,
0.0003232635598f,
0.0001701240020f,
0.0000060494092f,
-0.0001635052308f,
-0.0003327304257f,
-0.0004956543392f,
-0.0006463473881f,
-0.0007791311572f,
-0.0008887858391f,
-0.0009707473406f,
-0.0010212883637f,
-0.0010376748928f,
-0.0010182935142f,
-0.0009627423256f,
-0.0008718829334f,
-0.0007478485121f,
-0.0005940082363f,
-0.0004148858953f,
-0.0002160362179f,
-0.0000038797853f,
0.0002144967369f,
0.0004315713068f,
0.0006396386805f,
0.0008310780982f,
0.0009986251377f,
0.0011356405836f,
0.0012363642899f,
0.0012961469552f,
0.0013116484677f,
0.0012809971563f,
0.0012039006285f,
0.0010817051861f,
0.0009173976585f,
0.0007155502328f,
0.0004822060361f,
0.0002247101187f,
-0.0000485122542f,
-0.0003282213579f,
-0.0006046670924f,
-0.0008679194122f,
-0.0011082164816f,
-0.0013163164160f,
-0.0014838424648f,
-0.0016036069166f,
-0.0016699037326f,
-0.0016787563734f,
-0.0016281127287f,
-0.0015179765142f,
-0.0013504705242f,
-0.0011298254200f,
-0.0008622940855f,
-0.0005559904445f,
-0.0002206579656f,
0.0001326278146f,
0.0004918125002f,
0.0008442625446f,
0.0011771971009f,
0.0014781391329f,
0.0017353688983f,
0.0019383651103f,
0.0020782164138f,
0.0021479888549f,
0.0021430337774f,
0.0020612244406f,
0.0019031097610f,
0.0016719780803f,
0.0013738250803f,
0.0010172247913f,
0.0006131045972f,
0.0001744298610f,
-0.0002841939575f,
-0.0007469896914f,
-0.0011975333012f,
-0.0016193180225f,
-0.0019963392576f,
-0.0023136800202f,
-0.0025580762604f,
-0.0027184414762f,
-0.0027863306535f,
-0.0027563254360f,
-0.0026263241476f,
-0.0023977237973f,
-0.0020754837838f,
-0.0016680658389f,
-0.0011872477991f,
-0.0006478144405f,
-0.0000671315905f,
0.0005353843889f,
0.0011388873506f,
0.0017217924441f,
0.0022625165854f,
0.0027402428016f,
0.0031356836285f,
0.0034318155224f,
0.0036145589782f,
0.0036733773953f,
0.0036017725718f,
0.0033976546025f,
0.0030635707180f,
0.0026067787615f,
0.0020391592667f,
0.0013769620179f,
0.0006403921219f,
-0.0001469573694f,
-0.0009588099622f,
-0.0017670296747f,
-0.0025425381258f,
-0.0032562984671f,
-0.0038803325839f,
-0.0043887399877f,
-0.0047586814357f,
-0.0049712946658f,
-0.0050125064331f,
-0.0048737118489f,
-0.0045522909896f,
-0.0040519418186f,
-0.0033828092770f,
-0.0025614012271f,
-0.0016102839965f,
-0.0005575620934f,
0.0005638508289f,
0.0017171507753f,
0.0028627309673f,
0.0039594061171f,
0.0049657407264f,
0.0058414394672f,
0.0065487591885f,
0.0070538953140f,
0.0073282995418f,
0.0073498818543f,
0.0071040568482f,
0.0065845934106f,
0.0057942364555f,
0.0047450710480f,
0.0034586110723f,
0.0019655981535f,
0.0003055096637f,
-0.0014742207991f,
-0.0033192537092f,
-0.0051696434604f,
-0.0069613540836f,
-0.0086279538448f,
-0.0101024412833f,
-0.0113191540820f,
-0.0122157045903f,
-0.0127348875124f,
-0.0128265011561f,
-0.0124490285360f,
-0.0115711241461f,
-0.0101728602554f,
-0.0082466894895f,
-0.0057980911592f,
-0.0028458744398f,
0.0005778759911f,
0.0044282188570f,
0.0086481335451f,
0.0131696415938f,
0.0179152456807f,
0.0227996521306f,
0.0277317322133f,
0.0326166721023f,
0.0373582535356f,
0.0418612046008f,
0.0460335559188f,
0.0497889382248f,
0.0530487572435f,
0.0557441859425f,
0.0578179180988f,
0.0592256344327f,
0.0599371398233f,
0.0599371398233f,
0.0592256344327f,
0.0578179180988f,
0.0557441859425f,
0.0530487572435f,
0.0497889382248f,
0.0460335559188f,
0.0418612046008f,
0.0373582535356f,
0.0326166721023f,
0.0277317322133f,
0.0227996521306f,
0.0179152456807f,
0.0131696415938f,
0.0086481335451f,
0.0044282188570f,
0.0005778759911f,
-0.0028458744398f,
-0.0057980911592f,
-0.0082466894895f,
-0.0101728602554f,
-0.0115711241461f,
-0.0124490285360f,
-0.0128265011561f,
-0.0127348875124f,
-0.0122157045903f,
-0.0113191540820f,
-0.0101024412833f,
-0.0086279538448f,
-0.0069613540836f,
-0.0051696434604f,
-0.0033192537092f,
-0.0014742207991f,
0.0003055096637f,
0.0019655981535f,
0.0034586110723f,
0.0047450710480f,
0.0057942364555f,
0.0065845934106f,
0.0071040568482f,
0.0073498818543f,
0.0073282995418f,
0.0070538953140f,
0.0065487591885f,
0.0058414394672f,
0.0049657407264f,
0.0039594061171f,
0.0028627309673f,
0.0017171507753f,
0.0005638508289f,
-0.0005575620934f,
-0.0016102839965f,
-0.0025614012271f,
-0.0033828092770f,
-0.0040519418186f,
-0.0045522909896f,
-0.0048737118489f,
-0.0050125064331f,
-0.0049712946658f,
-0.0047586814357f,
-0.0043887399877f,
-0.0038803325839f,
-0.0032562984671f,
-0.0025425381258f,
-0.0017670296747f,
-0.0009588099622f,
-0.0001469573694f,
0.0006403921219f,
0.0013769620179f,
0.0020391592667f,
0.0026067787615f,
0.0030635707180f,
0.0033976546025f,
0.0036017725718f,
0.0036733773953f,
0.0036145589782f,
0.0034318155224f,
0.0031356836285f,
0.0027402428016f,
0.0022625165854f,
0.0017217924441f,
0.0011388873506f,
0.0005353843889f,
-0.0000671315905f,
-0.0006478144405f,
-0.0011872477991f,
-0.0016680658389f,
-0.0020754837838f,
-0.0023977237973f,
-0.0026263241476f,
-0.0027563254360f,
-0.0027863306535f,
-0.0027184414762f,
-0.0025580762604f,
-0.0023136800202f,
-0.0019963392576f,
-0.0016193180225f,
-0.0011975333012f,
-0.0007469896914f,
-0.0002841939575f,
0.0001744298610f,
0.0006131045972f,
0.0010172247913f,
0.0013738250803f,
0.0016719780803f,
0.0019031097610f,
0.0020612244406f,
0.0021430337774f,
0.0021479888549f,
0.0020782164138f,
0.0019383651103f,
0.0017353688983f,
0.0014781391329f,
0.0011771971009f,
0.0008442625446f,
0.0004918125002f,
0.0001326278146f,
-0.0002206579656f,
-0.0005559904445f,
-0.0008622940855f,
-0.0011298254200f,
-0.0013504705242f,
-0.0015179765142f,
-0.0016281127287f,
-0.0016787563734f,
-0.0016699037326f,
-0.0016036069166f,
-0.0014838424648f,
-0.0013163164160f,
-0.0011082164816f,
-0.0008679194122f,
-0.0006046670924f,
-0.0003282213579f,
-0.0000485122542f,
0.0002247101187f,
0.0004822060361f,
0.0007155502328f,
0.0009173976585f,
0.0010817051861f,
0.0012039006285f,
0.0012809971563f,
0.0013116484677f,
0.0012961469552f,
0.0012363642899f,
0.0011356405836f,
0.0009986251377f,
0.0008310780982f,
0.0006396386805f,
0.0004315713068f,
0.0002144967369f,
-0.0000038797853f,
-0.0002160362179f,
-0.0004148858953f,
-0.0005940082363f,
-0.0007478485121f,
-0.0008718829334f,
-0.0009627423256f,
-0.0010182935142f,
-0.0010376748928f,
-0.0010212883637f,
-0.0009707473406f,
-0.0008887858391f,
-0.0007791311572f,
-0.0006463473881f,
-0.0004956543392f,
-0.0003327304257f,
-0.0001635052308f,
0.0000060494092f,
0.0001701240020f,
0.0003232635598f,
0.0004605423719f,
0.0005777148960f,
0.0006713394034f,
0.0007388701444f,
0.0007787167083f,
0.0007902689274f,
0.0007738881585f,
0.0007308658562f,
0.0006633522280f,
0.0005742581225f,
0.0004671344133f,
0.0003460336990f,
0.0002153593731f,
0.0000797078370f,
-0.0000562910721f,
-0.0001881294675f,
-0.0003115682847f,
-0.0004227701586f,
-0.0005184153646f,
-0.0005957963722f,
-0.0006528899123f,
-0.0006884034538f,
-0.0007017970554f,
-0.0006932789118f,
-0.0006637776003f,
-0.0006148906121f,
-0.0005488139662f,
-0.0004682533995f,
-0.0003763233051f,
-0.0002764343270f,
-0.0001721766401f,
-0.0000671996814f,
0.0000349043239f,
0.0001307129555f,
0.0002170751467f,
0.0002912027367f,
0.0003507454223f,
0.0003938516106f,
0.0004192093552f,
0.0004260714830f,
0.0004142599400f,
0.0003841550469f,
0.0003366654366f,
0.0002731857749f,
0.0001955385388f,
0.0001059080771f,
0.0000067633979f,
-0.0000992213271f,
-0.0002092522968f,
-0.0003204982716f,
-0.0004301737349f,
-0.0005356135898f,
-0.0006343445666f,
-0.0007241441121f,
-0.0008030930096f,
-0.0008696128718f,
-0.0009224959242f,
-0.0009609186466f,
-0.0009844478476f,
-0.0009930311084f,
-0.0009869812183f,
-0.0009669467668f,
-0.0009338793741f,
-0.0008889897559f,
-0.0008337037348f,
-0.0007696102015f,
-0.0006984125260f,
-0.0006218750188f,
-0.0005417761096f,
-0.0004598592590f,
-0.0003777932686f,
-0.0002971322962f,
-0.0002192871274f,
-0.0001454972457f,
-0.0000768150927f,
-0.0000140913087f,
0.0000420277999f,
0.0000911024573f,
0.0001328901081f,
0.0001673370635f,
0.0001945599050f,
0.0002148295414f,
0.0002285465848f,
0.0002362212252f,
0.0002384460258f,
0.0002358749754f,
0.0002291968856f,
0.0002191165223f,
0.0002063311677f,
0.0001915159849f,
0.0001753054713f,
0.0001582843174f,
0.0001409745652f,
0.0001238323243f,
0.0001072405937f,
0.0000915114120f,
0.0000768836058f,
0.0000635293624f,
0.0000515556971f,
0.0000410140885f,
0.0000319042337f,
0.0000241852833f,
0.0000177804634f,
0.0000125885567f,
0.0000084881676f,
0.0000083199827f,
};
}
}

20
core/src/dsp/firdec/taps/fir_16_2.h
Wyświetl plik

@ -1,20 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_16_2_len = 6;
const float fir_16_2_taps[] = {
0.0314633937131f,
0.1579813285983f,
0.3165763689208f,
0.3165763689208f,
0.1579813285983f,
0.0314633937131f,
};
}
}

36
core/src/dsp/firdec/taps/fir_16_4.h
Wyświetl plik

@ -1,36 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_16_4_len = 22;
const float fir_16_4_taps[] = {
-0.0002023708919f,
-0.0011062368313f,
-0.0032163920847f,
-0.0059942384543f,
-0.0065224236296f,
0.0007775124540f,
0.0220383093327f,
0.0596819563778f,
0.1084838507550f,
0.1553460280327f,
0.1842685402388f,
0.1842685402388f,
0.1553460280327f,
0.1084838507550f,
0.0596819563778f,
0.0220383093327f,
0.0007775124540f,
-0.0065224236296f,
-0.0059942384543f,
-0.0032163920847f,
-0.0011062368313f,
-0.0002023708919f,
};
}
}

78
core/src/dsp/firdec/taps/fir_16_8.h
Wyświetl plik

@ -1,78 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_16_8_len = 64;
const float fir_16_8_taps[] = {
0.0000212056278f,
0.0000592989663f,
0.0001311135234f,
0.0002438111297f,
0.0003985063745f,
0.0005834891258f,
0.0007686964633f,
0.0009019314371f,
0.0009086374568f,
0.0006969087115f,
0.0001688400440f,
-0.0007617044022f,
-0.0021461871891f,
-0.0039761281907f,
-0.0061595555220f,
-0.0085040839445f,
-0.0107115695084f,
-0.0123883739229f,
-0.0130733894948f,
-0.0122833118289f,
-0.0095715783432f,
-0.0045944308163f,
0.0028247220059f,
0.0126425561455f,
0.0245641604270f,
0.0380398062836f,
0.0522939777968f,
0.0663859606669f,
0.0792964905438f,
0.0900306798861f,
0.0977244326410f,
0.1017403886275f,
0.1017403886275f,
0.0977244326410f,
0.0900306798861f,
0.0792964905438f,
0.0663859606669f,
0.0522939777968f,
0.0380398062836f,
0.0245641604270f,
0.0126425561455f,
0.0028247220059f,
-0.0045944308163f,
-0.0095715783432f,
-0.0122833118289f,
-0.0130733894948f,
-0.0123883739229f,
-0.0107115695084f,
-0.0085040839445f,
-0.0061595555220f,
-0.0039761281907f,
-0.0021461871891f,
-0.0007617044022f,
0.0001688400440f,
0.0006969087115f,
0.0009086374568f,
0.0009019314371f,
0.0007686964633f,
0.0005834891258f,
0.0003985063745f,
0.0002438111297f,
0.0001311135234f,
0.0000592989663f,
0.0000212056278f,
};
}
}

528
core/src/dsp/firdec/taps/fir_2048_128.h
Wyświetl plik

@ -1,528 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_2048_128_len = 514;
const float fir_2048_128_taps[] = {
0.0000056977543f,
0.0000016519060f,
0.0000018900898f,
0.0000021498690f,
0.0000024330160f,
0.0000027405173f,
0.0000030742515f,
0.0000034353223f,
0.0000038257163f,
0.0000042466607f,
0.0000047002521f,
0.0000051878472f,
0.0000057116542f,
0.0000062731650f,
0.0000068747009f,
0.0000075178944f,
0.0000082051812f,
0.0000089383392f,
0.0000097199199f,
0.0000105518511f,
0.0000114368007f,
0.0000123768507f,
0.0000133747862f,
0.0000144328464f,
0.0000155539344f,
0.0000167404496f,
0.0000179954131f,
0.0000193213868f,
0.0000207215097f,
0.0000221985076f,
0.0000237556374f,
0.0000253957896f,
0.0000271223379f,
0.0000289383380f,
0.0000308472794f,
0.0000328523820f,
0.0000349572499f,
0.0000371652659f,
0.0000394801467f,
0.0000419054357f,
0.0000444449599f,
0.0000471024204f,
0.0000498817519f,
0.0000527868089f,
0.0000558216304f,
0.0000589902202f,
0.0000622967176f,
0.0000657452697f,
0.0000693401121f,
0.0000730855287f,
0.0000769858465f,
0.0000810454789f,
0.0000852688387f,
0.0000896604605f,
0.0000942248370f,
0.0000989666149f,
0.0001038903598f,
0.0001090008210f,
0.0001143026296f,
0.0001198006263f,
0.0001254994998f,
0.0001314041710f,
0.0001375193773f,
0.0001438501072f,
0.0001504011376f,
0.0001571775115f,
0.0001641840351f,
0.0001714257921f,
0.0001789076072f,
0.0001866345903f,
0.0001946115730f,
0.0002028436762f,
0.0002113357263f,
0.0002200928393f,
0.0002291198237f,
0.0002384217741f,
0.0002480034673f,
0.0002578699598f,
0.0002680259827f,
0.0002784765367f,
0.0002892262923f,
0.0003002801771f,
0.0003116427850f,
0.0003233189523f,
0.0003353131809f,
0.0003476301967f,
0.0003602743932f,
0.0003732503673f,
0.0003865623868f,
0.0004002149008f,
0.0004142120341f,
0.0004285580685f,
0.0004432569680f,
0.0004583128281f,
0.0004737294337f,
0.0004895106749f,
0.0005056601389f,
0.0005221814910f,
0.0005390781024f,
0.0005563533944f,
0.0005740105034f,
0.0005920525879f,
0.0006104825303f,
0.0006293032077f,
0.0006485172300f,
0.0006681271742f,
0.0006881353590f,
0.0007085440434f,
0.0007293552362f,
0.0007505708607f,
0.0007721925977f,
0.0007942220177f,
0.0008166604553f,
0.0008395091117f,
0.0008627689581f,
0.0008864408102f,
0.0009105252585f,
0.0009350227185f,
0.0009599333834f,
0.0009852572538f,
0.0010109941099f,
0.0010371435239f,
0.0010637048482f,
0.0010906772135f,
0.0011180595302f,
0.0011458504759f,
0.0011740485059f,
0.0012026518338f,
0.0012316584473f,
0.0012610660863f,
0.0012908722603f,
0.0013210742267f,
0.0013516690064f,
0.0013826533670f,
0.0014140238326f,
0.0014457766743f,
0.0014779079120f,
0.0015104133153f,
0.0015432883942f,
0.0015765284129f,
0.0016101283668f,
0.0016440830124f,
0.0016783868277f,
0.0017130340602f,
0.0017480186691f,
0.0017833343933f,
0.0018189746732f,
0.0018549327411f,
0.0018912015203f,
0.0019277737394f,
0.0019646418086f,
0.0020017979573f,
0.0020392340874f,
0.0020769419357f,
0.0021149129027f,
0.0021531382398f,
0.0021916088550f,
0.0022303155238f,
0.0022692486717f,
0.0023083986089f,
0.0023477552904f,
0.0023873085737f,
0.0024270479569f,
0.0024669628584f,
0.0025070423351f,
0.0025472753813f,
0.0025876506298f,
0.0026281566678f,
0.0026687817225f,
0.0027095139925f,
0.0027503413194f,
0.0027912515330f,
0.0028322321111f,
0.0028732705358f,
0.0029143539447f,
0.0029554694944f,
0.0029966040069f,
0.0030377443376f,
0.0030788770187f,
0.0031199886295f,
0.0031610654399f,
0.0032020937793f,
0.0032430596841f,
0.0032839492614f,
0.0033247483433f,
0.0033654428438f,
0.0034060184215f,
0.0034464608266f,
0.0034867555758f,
0.0035268882866f,
0.0035668443662f,
0.0036066093308f,
0.0036461685116f,
0.0036855073558f,
0.0037246111522f,
0.0037634653125f,
0.0038020551175f,
0.0038403659769f,
0.0038783831984f,
0.0039160922239f,
0.0039534784232f,
0.0039905273052f,
0.0040272243371f,
0.0040635551298f,
0.0040995052831f,
0.0041350605451f,
0.0041702066839f,
0.0042049296200f,
0.0042392153249f,
0.0042730499268f,
0.0043064196357f,
0.0043393108225f,
0.0043717099704f,
0.0044036037280f,
0.0044349788856f,
0.0044658224039f,
0.0044961214142f,
0.0045258632233f,
0.0045550353360f,
0.0045836254386f,
0.0046116214419f,
0.0046390114441f,
0.0046657837931f,
0.0046919270308f,
0.0047174299722f,
0.0047422816340f,
0.0047664713274f,
0.0047899885734f,
0.0048128232074f,
0.0048349652830f,
0.0048564051867f,
0.0048771335320f,
0.0048971412812f,
0.0049164196340f,
0.0049349601525f,
0.0049527546463f,
0.0049697952998f,
0.0049860745555f,
0.0050015852406f,
0.0050163204516f,
0.0050302736774f,
0.0050434386878f,
0.0050558096508f,
0.0050673810271f,
0.0050781476793f,
0.0050881047743f,
0.0050972478830f,
0.0051055728926f,
0.0051130760938f,
0.0051197541055f,
0.0051256039484f,
0.0051306229828f,
0.0051348089672f,
0.0051381600106f,
0.0051406746155f,
0.0051423516450f,
0.0051431903494f,
0.0051431903494f,
0.0051423516450f,
0.0051406746155f,
0.0051381600106f,
0.0051348089672f,
0.0051306229828f,
0.0051256039484f,
0.0051197541055f,
0.0051130760938f,
0.0051055728926f,
0.0050972478830f,
0.0050881047743f,
0.0050781476793f,
0.0050673810271f,
0.0050558096508f,
0.0050434386878f,
0.0050302736774f,
0.0050163204516f,
0.0050015852406f,
0.0049860745555f,
0.0049697952998f,
0.0049527546463f,
0.0049349601525f,
0.0049164196340f,
0.0048971412812f,
0.0048771335320f,
0.0048564051867f,
0.0048349652830f,
0.0048128232074f,
0.0047899885734f,
0.0047664713274f,
0.0047422816340f,
0.0047174299722f,
0.0046919270308f,
0.0046657837931f,
0.0046390114441f,
0.0046116214419f,
0.0045836254386f,
0.0045550353360f,
0.0045258632233f,
0.0044961214142f,
0.0044658224039f,
0.0044349788856f,
0.0044036037280f,
0.0043717099704f,
0.0043393108225f,
0.0043064196357f,
0.0042730499268f,
0.0042392153249f,
0.0042049296200f,
0.0041702066839f,
0.0041350605451f,
0.0040995052831f,
0.0040635551298f,
0.0040272243371f,
0.0039905273052f,
0.0039534784232f,
0.0039160922239f,
0.0038783831984f,
0.0038403659769f,
0.0038020551175f,
0.0037634653125f,
0.0037246111522f,
0.0036855073558f,
0.0036461685116f,
0.0036066093308f,
0.0035668443662f,
0.0035268882866f,
0.0034867555758f,
0.0034464608266f,
0.0034060184215f,
0.0033654428438f,
0.0033247483433f,
0.0032839492614f,
0.0032430596841f,
0.0032020937793f,
0.0031610654399f,
0.0031199886295f,
0.0030788770187f,
0.0030377443376f,
0.0029966040069f,
0.0029554694944f,
0.0029143539447f,
0.0028732705358f,
0.0028322321111f,
0.0027912515330f,
0.0027503413194f,
0.0027095139925f,
0.0026687817225f,
0.0026281566678f,
0.0025876506298f,
0.0025472753813f,
0.0025070423351f,
0.0024669628584f,
0.0024270479569f,
0.0023873085737f,
0.0023477552904f,
0.0023083986089f,
0.0022692486717f,
0.0022303155238f,
0.0021916088550f,
0.0021531382398f,
0.0021149129027f,
0.0020769419357f,
0.0020392340874f,
0.0020017979573f,
0.0019646418086f,
0.0019277737394f,
0.0018912015203f,
0.0018549327411f,
0.0018189746732f,
0.0017833343933f,
0.0017480186691f,
0.0017130340602f,
0.0016783868277f,
0.0016440830124f,
0.0016101283668f,
0.0015765284129f,
0.0015432883942f,
0.0015104133153f,
0.0014779079120f,
0.0014457766743f,
0.0014140238326f,
0.0013826533670f,
0.0013516690064f,
0.0013210742267f,
0.0012908722603f,
0.0012610660863f,
0.0012316584473f,
0.0012026518338f,
0.0011740485059f,
0.0011458504759f,
0.0011180595302f,
0.0010906772135f,
0.0010637048482f,
0.0010371435239f,
0.0010109941099f,
0.0009852572538f,
0.0009599333834f,
0.0009350227185f,
0.0009105252585f,
0.0008864408102f,
0.0008627689581f,
0.0008395091117f,
0.0008166604553f,
0.0007942220177f,
0.0007721925977f,
0.0007505708607f,
0.0007293552362f,
0.0007085440434f,
0.0006881353590f,
0.0006681271742f,
0.0006485172300f,
0.0006293032077f,
0.0006104825303f,
0.0005920525879f,
0.0005740105034f,
0.0005563533944f,
0.0005390781024f,
0.0005221814910f,
0.0005056601389f,
0.0004895106749f,
0.0004737294337f,
0.0004583128281f,
0.0004432569680f,
0.0004285580685f,
0.0004142120341f,
0.0004002149008f,
0.0003865623868f,
0.0003732503673f,
0.0003602743932f,
0.0003476301967f,
0.0003353131809f,
0.0003233189523f,
0.0003116427850f,
0.0003002801771f,
0.0002892262923f,
0.0002784765367f,
0.0002680259827f,
0.0002578699598f,
0.0002480034673f,
0.0002384217741f,
0.0002291198237f,
0.0002200928393f,
0.0002113357263f,
0.0002028436762f,
0.0001946115730f,
0.0001866345903f,
0.0001789076072f,
0.0001714257921f,
0.0001641840351f,
0.0001571775115f,
0.0001504011376f,
0.0001438501072f,
0.0001375193773f,
0.0001314041710f,
0.0001254994998f,
0.0001198006263f,
0.0001143026296f,
0.0001090008210f,
0.0001038903598f,
0.0000989666149f,
0.0000942248370f,
0.0000896604605f,
0.0000852688387f,
0.0000810454789f,
0.0000769858465f,
0.0000730855287f,
0.0000693401121f,
0.0000657452697f,
0.0000622967176f,
0.0000589902202f,
0.0000558216304f,
0.0000527868089f,
0.0000498817519f,
0.0000471024204f,
0.0000444449599f,
0.0000419054357f,
0.0000394801467f,
0.0000371652659f,
0.0000349572499f,
0.0000328523820f,
0.0000308472794f,
0.0000289383380f,
0.0000271223379f,
0.0000253957896f,
0.0000237556374f,
0.0000221985076f,
0.0000207215097f,
0.0000193213868f,
0.0000179954131f,
0.0000167404496f,
0.0000155539344f,
0.0000144328464f,
0.0000133747862f,
0.0000123768507f,
0.0000114368007f,
0.0000105518511f,
0.0000097199199f,
0.0000089383392f,
0.0000082051812f,
0.0000075178944f,
0.0000068747009f,
0.0000062731650f,
0.0000057116542f,
0.0000051878472f,
0.0000047002521f,
0.0000042466607f,
0.0000038257163f,
0.0000034353223f,
0.0000030742515f,
0.0000027405173f,
0.0000024330160f,
0.0000021498690f,
0.0000018900898f,
0.0000016519060f,
0.0000056977543f,
};
}
}

267
core/src/dsp/firdec/taps/fir_2048_64.h
Wyświetl plik

@ -1,267 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_2048_64_len = 253;
const float fir_2048_64_taps[] = {
0.0000066902983f,
0.0000039334795f,
0.0000050760344f,
0.0000064280051f,
0.0000080150883f,
0.0000098649890f,
0.0000120074887f,
0.0000144745098f,
0.0000173001750f,
0.0000205208620f,
0.0000241752518f,
0.0000283043713f,
0.0000329516280f,
0.0000381628381f,
0.0000439862461f,
0.0000504725357f,
0.0000576748313f,
0.0000656486906f,
0.0000744520862f,
0.0000841453767f,
0.0000947912669f,
0.0001064547563f,
0.0001192030760f,
0.0001331056125f,
0.0001482338200f,
0.0001646611193f,
0.0001824627837f,
0.0002017158118f,
0.0002224987872f,
0.0002448917247f,
0.0002689759031f,
0.0002948336849f,
0.0003225483233f,
0.0003522037550f,
0.0003838843823f,
0.0004176748409f,
0.0004536597574f,
0.0004919234940f,
0.0005325498835f,
0.0005756219531f,
0.0006212216387f,
0.0006694294907f,
0.0007203243711f,
0.0007739831434f,
0.0008304803565f,
0.0008898879232f,
0.0009522747932f,
0.0010177066247f,
0.0010862454523f,
0.0011579493544f,
0.0012328721212f,
0.0013110629237f,
0.0013925659858f,
0.0014774202601f,
0.0015656591097f,
0.0016573099965f,
0.0017523941775f,
0.0018509264108f,
0.0019529146726f,
0.0020583598864f,
0.0021672556657f,
0.0022795880718f,
0.0023953353879f,
0.0025144679106f,
0.0026369477603f,
0.0027627287116f,
0.0028917560447f,
0.0030239664192f,
0.0031592877711f,
0.0032976392339f,
0.0034389310850f,
0.0035830647179f,
0.0037299326406f,
0.0038794185025f,
0.0040313971475f,
0.0041857346968f,
0.0043422886590f,
0.0045009080704f,
0.0046614336629f,
0.0048236980620f,
0.0049875260128f,
0.0051527346356f,
0.0053191337090f,
0.0054865259818f,
0.0056547075111f,
0.0058234680287f,
0.0059925913320f,
0.0061618557011f,
0.0063310343392f,
0.0064998958364f,
0.0066682046550f,
0.0068357216352f,
0.0070022045210f,
0.0071674085013f,
0.0073310867697f,
0.0074929910962f,
0.0076528724136f,
0.0078104814129f,
0.0079655691490f,
0.0081178876519f,
0.0082671905449f,
0.0084132336638f,
0.0085557756782f,
0.0086945787115f,
0.0088294089578f,
0.0089600372929f,
0.0090862398788f,
0.0092077987584f,
0.0093245024384f,
0.0094361464590f,
0.0095425339481f,
0.0096434761582f,
0.0097387929827f,
0.0098283134530f,
0.0099118762107f,
0.0099893299564f,
0.0100605338714f,
0.0101253580118f,
0.0101836836737f,
0.0102354037271f,
0.0102804229187f,
0.0103186581413f,
0.0103500386692f,
0.0103745063596f,
0.0103920158177f,
0.0104025345256f,
0.0104060429356f,
0.0104025345256f,
0.0103920158177f,
0.0103745063596f,
0.0103500386692f,
0.0103186581413f,
0.0102804229187f,
0.0102354037271f,
0.0101836836737f,
0.0101253580118f,
0.0100605338714f,
0.0099893299564f,
0.0099118762107f,
0.0098283134530f,
0.0097387929827f,
0.0096434761582f,
0.0095425339481f,
0.0094361464590f,
0.0093245024384f,
0.0092077987584f,
0.0090862398788f,
0.0089600372929f,
0.0088294089578f,
0.0086945787115f,
0.0085557756782f,
0.0084132336638f,
0.0082671905449f,
0.0081178876519f,
0.0079655691490f,
0.0078104814129f,
0.0076528724136f,
0.0074929910962f,
0.0073310867697f,
0.0071674085013f,
0.0070022045210f,
0.0068357216352f,
0.0066682046550f,
0.0064998958364f,
0.0063310343392f,
0.0061618557011f,
0.0059925913320f,
0.0058234680287f,
0.0056547075111f,
0.0054865259818f,
0.0053191337090f,
0.0051527346356f,
0.0049875260128f,
0.0048236980620f,
0.0046614336629f,
0.0045009080704f,
0.0043422886590f,
0.0041857346968f,
0.0040313971475f,
0.0038794185025f,
0.0037299326406f,
0.0035830647179f,
0.0034389310850f,
0.0032976392339f,
0.0031592877711f,
0.0030239664192f,
0.0028917560447f,
0.0027627287116f,
0.0026369477603f,
0.0025144679106f,
0.0023953353879f,
0.0022795880718f,
0.0021672556657f,
0.0020583598864f,
0.0019529146726f,
0.0018509264108f,
0.0017523941775f,
0.0016573099965f,
0.0015656591097f,
0.0014774202601f,
0.0013925659858f,
0.0013110629237f,
0.0012328721212f,
0.0011579493544f,
0.0010862454523f,
0.0010177066247f,
0.0009522747932f,
0.0008898879232f,
0.0008304803565f,
0.0007739831434f,
0.0007203243711f,
0.0006694294907f,
0.0006212216387f,
0.0005756219531f,
0.0005325498835f,
0.0004919234940f,
0.0004536597574f,
0.0004176748409f,
0.0003838843823f,
0.0003522037550f,
0.0003225483233f,
0.0002948336849f,
0.0002689759031f,
0.0002448917247f,
0.0002224987872f,
0.0002017158118f,
0.0001824627837f,
0.0001646611193f,
0.0001482338200f,
0.0001331056125f,
0.0001192030760f,
0.0001064547563f,
0.0000947912669f,
0.0000841453767f,
0.0000744520862f,
0.0000656486906f,
0.0000576748313f,
0.0000504725357f,
0.0000439862461f,
0.0000381628381f,
0.0000329516280f,
0.0000283043713f,
0.0000241752518f,
0.0000205208620f,
0.0000173001750f,
0.0000144745098f,
0.0000120074887f,
0.0000098649890f,
0.0000080150883f,
0.0000064280051f,
0.0000050760344f,
0.0000039334795f,
0.0000066902983f,
};
}
}

1026
core/src/dsp/firdec/taps/fir_256_128.h
Wyświetl plik

Plik diff jest za duży Load Diff

90
core/src/dsp/firdec/taps/fir_256_16.h
Wyświetl plik

@ -1,90 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_256_16_len = 76;
const float fir_256_16_taps[] = {
0.0000015142320f,
0.0000056182880f,
0.0000124498946f,
0.0000260499212f,
0.0000484430498f,
0.0000846870575f,
0.0001399358873f,
0.0002214698093f,
0.0003376597827f,
0.0004986987881f,
0.0007161460168f,
0.0010030447437f,
0.0013735255533f,
0.0018425379543f,
0.0024253148288f,
0.0031368140196f,
0.0039910067755f,
0.0050001228341f,
0.0061738297617f,
0.0075184160910f,
0.0090360019122f,
0.0107238349685f,
0.0125737121967f,
0.0145715758254f,
0.0166973209914f,
0.0189248478075f,
0.0212223774387f,
0.0235530403051f,
0.0258757292104f,
0.0281461957951f,
0.0303183537669f,
0.0323457392931f,
0.0341830677768f,
0.0357878183250f,
0.0371217728573f,
0.0381524365951f,
0.0388542706370f,
0.0392096753967f,
0.0392096753967f,
0.0388542706370f,
0.0381524365951f,
0.0371217728573f,
0.0357878183250f,
0.0341830677768f,
0.0323457392931f,
0.0303183537669f,
0.0281461957951f,
0.0258757292104f,
0.0235530403051f,
0.0212223774387f,
0.0189248478075f,
0.0166973209914f,
0.0145715758254f,
0.0125737121967f,
0.0107238349685f,
0.0090360019122f,
0.0075184160910f,
0.0061738297617f,
0.0050001228341f,
0.0039910067755f,
0.0031368140196f,
0.0024253148288f,
0.0018425379543f,
0.0013735255533f,
0.0010030447437f,
0.0007161460168f,
0.0004986987881f,
0.0003376597827f,
0.0002214698093f,
0.0001399358873f,
0.0000846870575f,
0.0000484430498f,
0.0000260499212f,
0.0000124498946f,
0.0000056182880f,
0.0000015142320f,
};
}
}

156
core/src/dsp/firdec/taps/fir_256_32.h
Wyświetl plik

@ -1,156 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_256_32_len = 142;
const float fir_256_32_taps[] = {
0.0000017688668f,
0.0000059240292f,
0.0000063419158f,
0.0000109315134f,
0.0000155620383f,
0.0000222451938f,
0.0000306499257f,
0.0000414255079f,
0.0000549053491f,
0.0000716171275f,
0.0000920857379f,
0.0001169121085f,
0.0001467432458f,
0.0001822838505f,
0.0002242905946f,
0.0002735720047f,
0.0003309848921f,
0.0003974308010f,
0.0004738510608f,
0.0005612209568f,
0.0006605427983f,
0.0007728379742f,
0.0008991379865f,
0.0010404745144f,
0.0011978685639f,
0.0013723187831f,
0.0015647890362f,
0.0017761953523f,
0.0020073923789f,
0.0022591594875f,
0.0025321866931f,
0.0028270605623f,
0.0031442502958f,
0.0034840941781f,
0.0038467865966f,
0.0042323658308f,
0.0046407028156f,
0.0050714910778f,
0.0055242380402f,
0.0059982578748f,
0.0064926660779f,
0.0070063759201f,
0.0075380969064f,
0.0080863353601f,
0.0086493972198f,
0.0092253931090f,
0.0098122457142f,
0.0104076994722f,
0.0110093325391f,
0.0116145709801f,
0.0122207050884f,
0.0128249077089f,
0.0134242544118f,
0.0140157453332f,
0.0145963284712f,
0.0151629242012f,
0.0157124507544f,
0.0162418503801f,
0.0167481159032f,
0.0172283173722f,
0.0176796284881f,
0.0180993525027f,
0.0184849472748f,
0.0188340491797f,
0.0191444955798f,
0.0194143455756f,
0.0196418987797f,
0.0198257118761f,
0.0199646127554f,
0.0200577120472f,
0.0201044119003f,
0.0201044119003f,
0.0200577120472f,
0.0199646127554f,
0.0198257118761f,
0.0196418987797f,
0.0194143455756f,
0.0191444955798f,
0.0188340491797f,
0.0184849472748f,
0.0180993525027f,
0.0176796284881f,
0.0172283173722f,
0.0167481159032f,
0.0162418503801f,
0.0157124507544f,
0.0151629242012f,
0.0145963284712f,
0.0140157453332f,
0.0134242544118f,
0.0128249077089f,
0.0122207050884f,
0.0116145709801f,
0.0110093325391f,
0.0104076994722f,
0.0098122457142f,
0.0092253931090f,
0.0086493972198f,
0.0080863353601f,
0.0075380969064f,
0.0070063759201f,
0.0064926660779f,
0.0059982578748f,
0.0055242380402f,
0.0050714910778f,
0.0046407028156f,
0.0042323658308f,
0.0038467865966f,
0.0034840941781f,
0.0031442502958f,
0.0028270605623f,
0.0025321866931f,
0.0022591594875f,
0.0020073923789f,
0.0017761953523f,
0.0015647890362f,
0.0013723187831f,
0.0011978685639f,
0.0010404745144f,
0.0008991379865f,
0.0007728379742f,
0.0006605427983f,
0.0005612209568f,
0.0004738510608f,
0.0003974308010f,
0.0003309848921f,
0.0002735720047f,
0.0002242905946f,
0.0001822838505f,
0.0001467432458f,
0.0001169121085f,
0.0000920857379f,
0.0000716171275f,
0.0000549053491f,
0.0000414255079f,
0.0000306499257f,
0.0000222451938f,
0.0000155620383f,
0.0000109315134f,
0.0000063419158f,
0.0000059240292f,
0.0000017688668f,
};
}
}

370
core/src/dsp/firdec/taps/fir_256_64.h
Wyświetl plik

@ -1,370 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_256_64_len = 356;
const float fir_256_64_taps[] = {
-0.0000062681742f,
-0.0000029140762f,
-0.0000035815110f,
-0.0000043422553f,
-0.0000052049053f,
-0.0000061772939f,
-0.0000072686109f,
-0.0000084872485f,
-0.0000098429063f,
-0.0000113444414f,
-0.0000130019541f,
-0.0000148246460f,
-0.0000168228827f,
-0.0000190060632f,
-0.0000213846550f,
-0.0000239680794f,
-0.0000267667146f,
-0.0000297898005f,
-0.0000330474067f,
-0.0000365483596f,
-0.0000403021726f,
-0.0000443169994f,
-0.0000486015224f,
-0.0000531629366f,
-0.0000580087933f,
-0.0000631450183f,
-0.0000685777077f,
-0.0000743111852f,
-0.0000803497472f,
-0.0000866957632f,
-0.0000933513680f,
-0.0001003166088f,
-0.0001075910834f,
-0.0001151721377f,
-0.0001230564481f,
-0.0001312382737f,
-0.0001397109815f,
-0.0001484653574f,
-0.0001574910729f,
-0.0001667750594f,
-0.0001763029154f,
-0.0001860573478f,
-0.0001960195192f,
-0.0002061675607f,
-0.0002164778583f,
-0.0002269236408f,
-0.0002374762065f,
-0.0002481035885f,
-0.0002587717224f,
-0.0002694431931f,
-0.0002800783421f,
-0.0002906341007f,
-0.0003010650378f,
-0.0003113222805f,
-0.0003213545042f,
-0.0003311069438f,
-0.0003405223259f,
-0.0003495399742f,
-0.0003580966832f,
-0.0003661259202f,
-0.0003735586428f,
-0.0003803225975f,
-0.0003863430819f,
-0.0003915423426f,
-0.0003958402819f,
-0.0003991539556f,
-0.0004013982252f,
-0.0004024853566f,
-0.0004023256179f,
-0.0004008269786f,
-0.0003978956543f,
-0.0003934359050f,
-0.0003873505277f,
-0.0003795407527f,
-0.0003699066836f,
-0.0003583472905f,
-0.0003447607977f,
-0.0003290447712f,
-0.0003110964540f,
-0.0002908129452f,
-0.0002680914824f,
-0.0002428297099f,
-0.0002149259070f,
-0.0001842793414f,
-0.0001507904431f,
-0.0001143612390f,
-0.0000748954712f,
-0.0000322991074f,
0.0000135195964f,
0.0000626495149f,
0.0001151766480f,
0.0001711834750f,
0.0002307490067f,
0.0002939480814f,
0.0003608514761f,
0.0004315251498f,
0.0005060304153f,
0.0005844231367f,
0.0006667539631f,
0.0007530674871f,
0.0008434025410f,
0.0009377913237f,
0.0010362597605f,
0.0011388266053f,
0.0012455038652f,
0.0013562958844f,
0.0014711998354f,
0.0015902047905f,
0.0017132922802f,
0.0018404353607f,
0.0019715992373f,
0.0021067403358f,
0.0022458069916f,
0.0023887385299f,
0.0025354660208f,
0.0026859113741f,
0.0028399881592f,
0.0029976007211f,
0.0031586450629f,
0.0033230079887f,
0.0034905680464f,
0.0036611947020f,
0.0038347493416f,
0.0040110844803f,
0.0041900448203f,
0.0043714664990f,
0.0045551781983f,
0.0047410004367f,
0.0049287467249f,
0.0051182229035f,
0.0053092283419f,
0.0055015553224f,
0.0056949902776f,
0.0058893132225f,
0.0060842990234f,
0.0062797168802f,
0.0064753316199f,
0.0066709032288f,
0.0068661881644f,
0.0070609389367f,
0.0072549054317f,
0.0074478345403f,
0.0076394714860f,
0.0078295595003f,
0.0080178411460f,
0.0082040580375f,
0.0083879521517f,
0.0085692655900f,
0.0087477418693f,
0.0089231257234f,
0.0090951643643f,
0.0092636073201f,
0.0094282076595f,
0.0095887218614f,
0.0097449109950f,
0.0098965406177f,
0.0100433819014f,
0.0101852115568f,
0.0103218128967f,
0.0104529757832f,
0.0105784976211f,
0.0106981833229f,
0.0108118462264f,
0.0109193080737f,
0.0110203998455f,
0.0111149617515f,
0.0112028439747f,
0.0112839066704f,
0.0113580206147f,
0.0114250672088f,
0.0114849390277f,
0.0115375398269f,
0.0115827849866f,
0.0116206015194f,
0.0116509284062f,
0.0116737166029f,
0.0116889292662f,
0.0116965417578f,
0.0116965417578f,
0.0116889292662f,
0.0116737166029f,
0.0116509284062f,
0.0116206015194f,
0.0115827849866f,
0.0115375398269f,
0.0114849390277f,
0.0114250672088f,
0.0113580206147f,
0.0112839066704f,
0.0112028439747f,
0.0111149617515f,
0.0110203998455f,
0.0109193080737f,
0.0108118462264f,
0.0106981833229f,
0.0105784976211f,
0.0104529757832f,
0.0103218128967f,
0.0101852115568f,
0.0100433819014f,
0.0098965406177f,
0.0097449109950f,
0.0095887218614f,
0.0094282076595f,
0.0092636073201f,
0.0090951643643f,
0.0089231257234f,
0.0087477418693f,
0.0085692655900f,
0.0083879521517f,
0.0082040580375f,
0.0080178411460f,
0.0078295595003f,
0.0076394714860f,
0.0074478345403f,
0.0072549054317f,
0.0070609389367f,
0.0068661881644f,
0.0066709032288f,
0.0064753316199f,
0.0062797168802f,
0.0060842990234f,
0.0058893132225f,
0.0056949902776f,
0.0055015553224f,
0.0053092283419f,
0.0051182229035f,
0.0049287467249f,
0.0047410004367f,
0.0045551781983f,
0.0043714664990f,
0.0041900448203f,
0.0040110844803f,
0.0038347493416f,
0.0036611947020f,
0.0034905680464f,
0.0033230079887f,
0.0031586450629f,
0.0029976007211f,
0.0028399881592f,
0.0026859113741f,
0.0025354660208f,
0.0023887385299f,
0.0022458069916f,
0.0021067403358f,
0.0019715992373f,
0.0018404353607f,
0.0017132922802f,
0.0015902047905f,
0.0014711998354f,
0.0013562958844f,
0.0012455038652f,
0.0011388266053f,
0.0010362597605f,
0.0009377913237f,
0.0008434025410f,
0.0007530674871f,
0.0006667539631f,
0.0005844231367f,
0.0005060304153f,
0.0004315251498f,
0.0003608514761f,
0.0002939480814f,
0.0002307490067f,
0.0001711834750f,
0.0001151766480f,
0.0000626495149f,
0.0000135195964f,
-0.0000322991074f,
-0.0000748954712f,
-0.0001143612390f,
-0.0001507904431f,
-0.0001842793414f,
-0.0002149259070f,
-0.0002428297099f,
-0.0002680914824f,
-0.0002908129452f,
-0.0003110964540f,
-0.0003290447712f,
-0.0003447607977f,
-0.0003583472905f,
-0.0003699066836f,
-0.0003795407527f,
-0.0003873505277f,
-0.0003934359050f,
-0.0003978956543f,
-0.0004008269786f,
-0.0004023256179f,
-0.0004024853566f,
-0.0004013982252f,
-0.0003991539556f,
-0.0003958402819f,
-0.0003915423426f,
-0.0003863430819f,
-0.0003803225975f,
-0.0003735586428f,
-0.0003661259202f,
-0.0003580966832f,
-0.0003495399742f,
-0.0003405223259f,
-0.0003311069438f,
-0.0003213545042f,
-0.0003113222805f,
-0.0003010650378f,
-0.0002906341007f,
-0.0002800783421f,
-0.0002694431931f,
-0.0002587717224f,
-0.0002481035885f,
-0.0002374762065f,
-0.0002269236408f,
-0.0002164778583f,
-0.0002061675607f,
-0.0001960195192f,
-0.0001860573478f,
-0.0001763029154f,
-0.0001667750594f,
-0.0001574910729f,
-0.0001484653574f,
-0.0001397109815f,
-0.0001312382737f,
-0.0001230564481f,
-0.0001151721377f,
-0.0001075910834f,
-0.0001003166088f,
-0.0000933513680f,
-0.0000866957632f,
-0.0000803497472f,
-0.0000743111852f,
-0.0000685777077f,
-0.0000631450183f,
-0.0000580087933f,
-0.0000531629366f,
-0.0000486015224f,
-0.0000443169994f,
-0.0000403021726f,
-0.0000365483596f,
-0.0000330474067f,
-0.0000297898005f,
-0.0000267667146f,
-0.0000239680794f,
-0.0000213846550f,
-0.0000190060632f,
-0.0000168228827f,
-0.0000148246460f,
-0.0000130019541f,
-0.0000113444414f,
-0.0000098429063f,
-0.0000084872485f,
-0.0000072686109f,
-0.0000061772939f,
-0.0000052049053f,
-0.0000043422553f,
-0.0000035815110f,
-0.0000029140762f,
-0.0000062681742f,
};
}
}

46
core/src/dsp/firdec/taps/fir_256_8.h
Wyświetl plik

@ -1,46 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_256_8_len = 32;
const float fir_256_8_taps[] = {
0.0000481199958f,
0.0002120253977f,
0.0006339322060f,
0.0015268611634f,
0.0031751774844f,
0.0059080996632f,
0.0100482128498f,
0.0158389158363f,
0.0233630301033f,
0.0324710705948f,
0.0427398820012f,
0.0534789041603f,
0.0637922520572f,
0.0726919132761f,
0.0792439704433f,
0.0827196815814f,
0.0827196815814f,
0.0792439704433f,
0.0726919132761f,
0.0637922520572f,
0.0534789041603f,
0.0427398820012f,
0.0324710705948f,
0.0233630301033f,
0.0158389158363f,
0.0100482128498f,
0.0059080996632f,
0.0031751774844f,
0.0015268611634f,
0.0006339322060f,
0.0002120253977f,
0.0000481199958f,
};
}
}

83
core/src/dsp/firdec/taps/fir_2_2.h
Wyświetl plik

@ -1,83 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_2_2_len = 69;
const float fir_2_2_taps[] = {
0.0004006336249f,
0.0020755985056f,
0.0048563649567f,
0.0059790166982f,
0.0026229226079f,
-0.0027182591526f,
-0.0033815336714f,
0.0016386385398f,
0.0040818147060f,
-0.0009840292282f,
-0.0051209884701f,
0.0001774409073f,
0.0064258526620f,
0.0010093516023f,
-0.0079128279100f,
-0.0027137006752f,
0.0095093112574f,
0.0050706357235f,
-0.0111540204771f,
-0.0082460599199f,
0.0127857167873f,
0.0124879068372f,
-0.0143474523867f,
-0.0182057708485f,
0.0157818585768f,
0.0261723747167f,
-0.0170376434096f,
-0.0380514893049f,
0.0180670706247f,
0.0582124126716f,
-0.0188323041841f,
-0.1027724866049f,
0.0193031650356f,
0.3171894887336f,
0.4805375200904f,
0.3171894887336f,
0.0193031650356f,
-0.1027724866049f,
-0.0188323041841f,
0.0582124126716f,
0.0180670706247f,
-0.0380514893049f,
-0.0170376434096f,
0.0261723747167f,
0.0157818585768f,
-0.0182057708485f,
-0.0143474523867f,
0.0124879068372f,
0.0127857167873f,
-0.0082460599199f,
-0.0111540204771f,
0.0050706357235f,
0.0095093112574f,
-0.0027137006752f,
-0.0079128279100f,
0.0010093516023f,
0.0064258526620f,
0.0001774409073f,
-0.0051209884701f,
-0.0009840292282f,
0.0040818147060f,
0.0016386385398f,
-0.0033815336714f,
-0.0027182591526f,
0.0026229226079f,
0.0059790166982f,
0.0048563649567f,
0.0020755985056f,
0.0004006336249f,
};
}
}

142
core/src/dsp/firdec/taps/fir_32_16.h
Wyświetl plik

@ -1,142 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_32_16_len = 128;
const float fir_32_16_taps[] = {
0.0000099342222f,
0.0000146490348f,
0.0000247646101f,
0.0000387541309f,
0.0000572736657f,
0.0000808761926f,
0.0001099349979f,
0.0001445574213f,
0.0001844922748f,
0.0002290353727f,
0.0002769386619f,
0.0003263293316f,
0.0003746459569f,
0.0004185990900f,
0.0004541637106f,
0.0004766105134f,
0.0004805821127f,
0.0004602188681f,
0.0004093371919f,
0.0003216609257f,
0.0001911037388f,
0.0000120976033f,
-0.0002200406423f,
-0.0005087156694f,
-0.0008556468821f,
-0.0012604649511f,
-0.0017203301735f,
-0.0022295925790f,
-0.0027795143093f,
-0.0033580744939f,
-0.0039498755635f,
-0.0045361676357f,
-0.0050950043052f,
-0.0056015389258f,
-0.0060284654152f,
-0.0063466019019f,
-0.0065256093963f,
-0.0065348313327f,
-0.0063442336013f,
-0.0059254188348f,
-0.0052526835481f,
-0.0043040825207f,
-0.0030624618152f,
-0.0015164202550f,
0.0003388408046f,
0.0025008178935f,
0.0049591911398f,
0.0076955253725f,
0.0106832101994f,
0.0138876548446f,
0.0172667447174f,
0.0207715571925f,
0.0243473242916f,
0.0279346202686f,
0.0314707429314f,
0.0348912492894f,
0.0381315991625f,
0.0411288550641f,
0.0438233832299f,
0.0461604993011f,
0.0480920029752f,
0.0495775489259f,
0.0505858063661f,
0.0510953666101f,
0.0510953666101f,
0.0505858063661f,
0.0495775489259f,
0.0480920029752f,
0.0461604993011f,
0.0438233832299f,
0.0411288550641f,
0.0381315991625f,
0.0348912492894f,
0.0314707429314f,
0.0279346202686f,
0.0243473242916f,
0.0207715571925f,
0.0172667447174f,
0.0138876548446f,
0.0106832101994f,
0.0076955253725f,
0.0049591911398f,
0.0025008178935f,
0.0003388408046f,
-0.0015164202550f,
-0.0030624618152f,
-0.0043040825207f,
-0.0052526835481f,
-0.0059254188348f,
-0.0063442336013f,
-0.0065348313327f,
-0.0065256093963f,
-0.0063466019019f,
-0.0060284654152f,
-0.0056015389258f,
-0.0050950043052f,
-0.0045361676357f,
-0.0039498755635f,
-0.0033580744939f,
-0.0027795143093f,
-0.0022295925790f,
-0.0017203301735f,
-0.0012604649511f,
-0.0008556468821f,
-0.0005087156694f,
-0.0002200406423f,
0.0000120976033f,
0.0001911037388f,
0.0003216609257f,
0.0004093371919f,
0.0004602188681f,
0.0004805821127f,
0.0004766105134f,
0.0004541637106f,
0.0004185990900f,
0.0003746459569f,
0.0003263293316f,
0.0002769386619f,
0.0002290353727f,
0.0001844922748f,
0.0001445574213f,
0.0001099349979f,
0.0000808761926f,
0.0000572736657f,
0.0000387541309f,
0.0000247646101f,
0.0000146490348f,
0.0000099342222f,
};
}
}

20
core/src/dsp/firdec/taps/fir_32_2.h
Wyświetl plik

@ -1,20 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_32_2_len = 6;
const float fir_32_2_taps[] = {
0.0303426484663f,
0.1557222116669f,
0.3154225044548f,
0.3154225044548f,
0.1557222116669f,
0.0303426484663f,
};
}
}

1117
core/src/dsp/firdec/taps/fir_32_32.h
Wyświetl plik

Plik diff jest za duży Load Diff

31
core/src/dsp/firdec/taps/fir_32_4.h
Wyświetl plik

@ -1,31 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_32_4_len = 17;
const float fir_32_4_taps[] = {
0.0002602343386f,
0.0019197560804f,
0.0076270554566f,
0.0212647832351f,
0.0459374309886f,
0.0808345515056f,
0.1191594258092f,
0.1495554802033f,
0.1611781123721f,
0.1495554802033f,
0.1191594258092f,
0.0808345515056f,
0.0459374309886f,
0.0212647832351f,
0.0076270554566f,
0.0019197560804f,
0.0002602343386f,
};
}
}

59
core/src/dsp/firdec/taps/fir_32_8.h
Wyświetl plik

@ -1,59 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_32_8_len = 45;
const float fir_32_8_taps[] = {
-0.0000309582228f,
-0.0001079580167f,
-0.0002728448293f,
-0.0005651806741f,
-0.0010146553103f,
-0.0016201042973f,
-0.0023253502129f,
-0.0029961993139f,
-0.0034054389929f,
-0.0032331082459f,
-0.0020878393215f,
0.0004484139474f,
0.0047549865150f,
0.0110947837587f,
0.0195373899494f,
0.0298988087157f,
0.0417130694495f,
0.0542467727184f,
0.0665603957204f,
0.0776111715593f,
0.0863835049898f,
0.0920262381310f,
0.0939733024676f,
0.0920262381310f,
0.0863835049898f,
0.0776111715593f,
0.0665603957204f,
0.0542467727184f,
0.0417130694495f,
0.0298988087157f,
0.0195373899494f,
0.0110947837587f,
0.0047549865150f,
0.0004484139474f,
-0.0020878393215f,
-0.0032331082459f,
-0.0034054389929f,
-0.0029961993139f,
-0.0023253502129f,
-0.0016201042973f,
-0.0010146553103f,
-0.0005651806741f,
-0.0002728448293f,
-0.0001079580167f,
-0.0000309582228f,
};
}
}

701
core/src/dsp/firdec/taps/fir_4096_128.h
Wyświetl plik

@ -1,701 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_4096_128_len = 687;
const float fir_4096_128_taps[] = {
-0.0000001853079f,
-0.0000000346264f,
-0.0000000376411f,
-0.0000000406683f,
-0.0000000436847f,
-0.0000000466640f,
-0.0000000495767f,
-0.0000000523896f,
-0.0000000550661f,
-0.0000000575654f,
-0.0000000598428f,
-0.0000000618489f,
-0.0000000635299f,
-0.0000000648269f,
-0.0000000656757f,
-0.0000000660068f,
-0.0000000657448f,
-0.0000000648081f,
-0.0000000631089f,
-0.0000000605524f,
-0.0000000570369f,
-0.0000000524531f,
-0.0000000466841f,
-0.0000000396046f,
-0.0000000310810f,
-0.0000000209706f,
-0.0000000091215f,
0.0000000046280f,
0.0000000204496f,
0.0000000385257f,
0.0000000590497f,
0.0000000822264f,
0.0000001082725f,
0.0000001374170f,
0.0000001699018f,
0.0000002059821f,
0.0000002459268f,
0.0000002900194f,
0.0000003385579f,
0.0000003918557f,
0.0000004502420f,
0.0000005140626f,
0.0000005836800f,
0.0000006594741f,
0.0000007418430f,
0.0000008312033f,
0.0000009279907f,
0.0000010326607f,
0.0000011456888f,
0.0000012675717f,
0.0000013988273f,
0.0000015399957f,
0.0000016916395f,
0.0000018543446f,
0.0000020287205f,
0.0000022154015f,
0.0000024150466f,
0.0000026283404f,
0.0000028559940f,
0.0000030987450f,
0.0000033573588f,
0.0000036326283f,
0.0000039253756f,
0.0000042364515f,
0.0000045667370f,
0.0000049171433f,
0.0000052886125f,
0.0000056821186f,
0.0000060986673f,
0.0000065392974f,
0.0000070050805f,
0.0000074971223f,
0.0000080165629f,
0.0000085645769f,
0.0000091423747f,
0.0000097512023f,
0.0000103923421f,
0.0000110671135f,
0.0000117768730f,
0.0000125230151f,
0.0000133069722f,
0.0000141302156f,
0.0000149942554f,
0.0000159006412f,
0.0000168509623f,
0.0000178468480f,
0.0000188899682f,
0.0000199820332f,
0.0000211247945f,
0.0000223200446f,
0.0000235696176f,
0.0000248753891f,
0.0000262392764f,
0.0000276632389f,
0.0000291492778f,
0.0000306994366f,
0.0000323158008f,
0.0000340004981f,
0.0000357556983f,
0.0000375836134f,
0.0000394864972f,
0.0000414666457f,
0.0000435263962f,
0.0000456681279f,
0.0000478942611f,
0.0000502072572f,
0.0000526096182f,
0.0000551038867f,
0.0000576926449f,
0.0000603785150f,
0.0000631641580f,
0.0000660522733f,
0.0000690455987f,
0.0000721469091f,
0.0000753590162f,
0.0000786847678f,
0.0000821270469f,
0.0000856887711f,
0.0000893728917f,
0.0000931823927f,
0.0000971202902f,
0.0001011896310f,
0.0001053934918f,
0.0001097349782f,
0.0001142172235f,
0.0001188433875f,
0.0001236166552f,
0.0001285402359f,
0.0001336173613f,
0.0001388512848f,
0.0001442452795f,
0.0001498026371f,
0.0001555266664f,
0.0001614206914f,
0.0001674880501f,
0.0001737320925f,
0.0001801561792f,
0.0001867636795f,
0.0001935579694f,
0.0002005424304f,
0.0002077204468f,
0.0002150954042f,
0.0002226706877f,
0.0002304496792f,
0.0002384357564f,
0.0002466322894f,
0.0002550426396f,
0.0002636701572f,
0.0002725181784f,
0.0002815900242f,
0.0002908889972f,
0.0003004183794f,
0.0003101814303f,
0.0003201813839f,
0.0003304214468f,
0.0003409047951f,
0.0003516345723f,
0.0003626138868f,
0.0003738458092f,
0.0003853333694f,
0.0003970795547f,
0.0004090873065f,
0.0004213595178f,
0.0004338990308f,
0.0004467086339f,
0.0004597910591f,
0.0004731489791f,
0.0004867850049f,
0.0005007016827f,
0.0005149014913f,
0.0005293868393f,
0.0005441600623f,
0.0005592234204f,
0.0005745790947f,
0.0005902291855f,
0.0006061757086f,
0.0006224205933f,
0.0006389656791f,
0.0006558127133f,
0.0006729633479f,
0.0006904191373f,
0.0007081815354f,
0.0007262518929f,
0.0007446314546f,
0.0007633213568f,
0.0007823226250f,
0.0008016361709f,
0.0008212627897f,
0.0008412031585f,
0.0008614578327f,
0.0008820272443f,
0.0009029116994f,
0.0009241113755f,
0.0009456263198f,
0.0009674564462f,
0.0009896015337f,
0.0010120612242f,
0.0010348350198f,
0.0010579222817f,
0.0010813222275f,
0.0011050339296f,
0.0011290563132f,
0.0011533881548f,
0.0011780280801f,
0.0012029745628f,
0.0012282259227f,
0.0012537803242f,
0.0012796357754f,
0.0013057901260f,
0.0013322410668f,
0.0013589861279f,
0.0013860226783f,
0.0014133479243f,
0.0014409589089f,
0.0014688525111f,
0.0014970254450f,
0.0015254742592f,
0.0015541953364f,
0.0015831848930f,
0.0016124389787f,
0.0016419534764f,
0.0016717241017f,
0.0017017464036f,
0.0017320157641f,
0.0017625273983f,
0.0017932763553f,
0.0018242575180f,
0.0018554656041f,
0.0018868951663f,
0.0019185405936f,
0.0019503961118f,
0.0019824557844f,
0.0020147135141f,
0.0020471630437f,
0.0020797979574f,
0.0021126116823f,
0.0021455974903f,
0.0021787484991f,
0.0022120576745f,
0.0022455178321f,
0.0022791216394f,
0.0023128616177f,
0.0023467301445f,
0.0023807194560f,
0.0024148216493f,
0.0024490286850f,
0.0024833323899f,
0.0025177244601f,
0.0025521964633f,
0.0025867398422f,
0.0026213459177f,
0.0026560058918f,
0.0026907108512f,
0.0027254517703f,
0.0027602195153f,
0.0027950048475f,
0.0028297984269f,
0.0028645908163f,
0.0028993724850f,
0.0029341338127f,
0.0029688650939f,
0.0030035565421f,
0.0030381982934f,
0.0030727804117f,
0.0031072928924f,
0.0031417256676f,
0.0031760686099f,
0.0032103115375f,
0.0032444442190f,
0.0032784563779f,
0.0033123376974f,
0.0033460778257f,
0.0033796663804f,
0.0034130929541f,
0.0034463471189f,
0.0034794184319f,
0.0035122964401f,
0.0035449706860f,
0.0035774307122f,
0.0036096660671f,
0.0036416663102f,
0.0036734210173f,
0.0037049197858f,
0.0037361522402f,
0.0037671080372f,
0.0037977768717f,
0.0038281484815f,
0.0038582126530f,
0.0038879592268f,
0.0039173781029f,
0.0039464592460f,
0.0039751926911f,
0.0040035685488f,
0.0040315770105f,
0.0040592083542f,
0.0040864529492f,
0.0041133012618f,
0.0041397438603f,
0.0041657714205f,
0.0041913747306f,
0.0042165446965f,
0.0042412723466f,
0.0042655488373f,
0.0042893654574f,
0.0043127136335f,
0.0043355849347f,
0.0043579710770f,
0.0043798639286f,
0.0044012555142f,
0.0044221380197f,
0.0044425037963f,
0.0044623453655f,
0.0044816554230f,
0.0045004268430f,
0.0045186526821f,
0.0045363261840f,
0.0045534407824f,
0.0045699901059f,
0.0045859679809f,
0.0046013684356f,
0.0046161857032f,
0.0046304142258f,
0.0046440486570f,
0.0046570838656f,
0.0046695149383f,
0.0046813371826f,
0.0046925461296f,
0.0047031375370f,
0.0047131073910f,
0.0047224519091f,
0.0047311675420f,
0.0047392509762f,
0.0047466991355f,
0.0047535091831f,
0.0047596785231f,
0.0047652048022f,
0.0047700859110f,
0.0047743199853f,
0.0047779054073f,
0.0047808408063f,
0.0047831250597f,
0.0047847572939f,
0.0047857368844f,
0.0047860634562f,
0.0047857368844f,
0.0047847572939f,
0.0047831250597f,
0.0047808408063f,
0.0047779054073f,
0.0047743199853f,
0.0047700859110f,
0.0047652048022f,
0.0047596785231f,
0.0047535091831f,
0.0047466991355f,
0.0047392509762f,
0.0047311675420f,
0.0047224519091f,
0.0047131073910f,
0.0047031375370f,
0.0046925461296f,
0.0046813371826f,
0.0046695149383f,
0.0046570838656f,
0.0046440486570f,
0.0046304142258f,
0.0046161857032f,
0.0046013684356f,
0.0045859679809f,
0.0045699901059f,
0.0045534407824f,
0.0045363261840f,
0.0045186526821f,
0.0045004268430f,
0.0044816554230f,
0.0044623453655f,
0.0044425037963f,
0.0044221380197f,
0.0044012555142f,
0.0043798639286f,
0.0043579710770f,
0.0043355849347f,
0.0043127136335f,
0.0042893654574f,
0.0042655488373f,
0.0042412723466f,
0.0042165446965f,
0.0041913747306f,
0.0041657714205f,
0.0041397438603f,
0.0041133012618f,
0.0040864529492f,
0.0040592083542f,
0.0040315770105f,
0.0040035685488f,
0.0039751926911f,
0.0039464592460f,
0.0039173781029f,
0.0038879592268f,
0.0038582126530f,
0.0038281484815f,
0.0037977768717f,
0.0037671080372f,
0.0037361522402f,
0.0037049197858f,
0.0036734210173f,
0.0036416663102f,
0.0036096660671f,
0.0035774307122f,
0.0035449706860f,
0.0035122964401f,
0.0034794184319f,
0.0034463471189f,
0.0034130929541f,
0.0033796663804f,
0.0033460778257f,
0.0033123376974f,
0.0032784563779f,
0.0032444442190f,
0.0032103115375f,
0.0031760686099f,
0.0031417256676f,
0.0031072928924f,
0.0030727804117f,
0.0030381982934f,
0.0030035565421f,
0.0029688650939f,
0.0029341338127f,
0.0028993724850f,
0.0028645908163f,
0.0028297984269f,
0.0027950048475f,
0.0027602195153f,
0.0027254517703f,
0.0026907108512f,
0.0026560058918f,
0.0026213459177f,
0.0025867398422f,
0.0025521964633f,
0.0025177244601f,
0.0024833323899f,
0.0024490286850f,
0.0024148216493f,
0.0023807194560f,
0.0023467301445f,
0.0023128616177f,
0.0022791216394f,
0.0022455178321f,
0.0022120576745f,
0.0021787484991f,
0.0021455974903f,
0.0021126116823f,
0.0020797979574f,
0.0020471630437f,
0.0020147135141f,
0.0019824557844f,
0.0019503961118f,
0.0019185405936f,
0.0018868951663f,
0.0018554656041f,
0.0018242575180f,
0.0017932763553f,
0.0017625273983f,
0.0017320157641f,
0.0017017464036f,
0.0016717241017f,
0.0016419534764f,
0.0016124389787f,
0.0015831848930f,
0.0015541953364f,
0.0015254742592f,
0.0014970254450f,
0.0014688525111f,
0.0014409589089f,
0.0014133479243f,
0.0013860226783f,
0.0013589861279f,
0.0013322410668f,
0.0013057901260f,
0.0012796357754f,
0.0012537803242f,
0.0012282259227f,
0.0012029745628f,
0.0011780280801f,
0.0011533881548f,
0.0011290563132f,
0.0011050339296f,
0.0010813222275f,
0.0010579222817f,
0.0010348350198f,
0.0010120612242f,
0.0009896015337f,
0.0009674564462f,
0.0009456263198f,
0.0009241113755f,
0.0009029116994f,
0.0008820272443f,
0.0008614578327f,
0.0008412031585f,
0.0008212627897f,
0.0008016361709f,
0.0007823226250f,
0.0007633213568f,
0.0007446314546f,
0.0007262518929f,
0.0007081815354f,
0.0006904191373f,
0.0006729633479f,
0.0006558127133f,
0.0006389656791f,
0.0006224205933f,
0.0006061757086f,
0.0005902291855f,
0.0005745790947f,
0.0005592234204f,
0.0005441600623f,
0.0005293868393f,
0.0005149014913f,
0.0005007016827f,
0.0004867850049f,
0.0004731489791f,
0.0004597910591f,
0.0004467086339f,
0.0004338990308f,
0.0004213595178f,
0.0004090873065f,
0.0003970795547f,
0.0003853333694f,
0.0003738458092f,
0.0003626138868f,
0.0003516345723f,
0.0003409047951f,
0.0003304214468f,
0.0003201813839f,
0.0003101814303f,
0.0003004183794f,
0.0002908889972f,
0.0002815900242f,
0.0002725181784f,
0.0002636701572f,
0.0002550426396f,
0.0002466322894f,
0.0002384357564f,
0.0002304496792f,
0.0002226706877f,
0.0002150954042f,
0.0002077204468f,
0.0002005424304f,
0.0001935579694f,
0.0001867636795f,
0.0001801561792f,
0.0001737320925f,
0.0001674880501f,
0.0001614206914f,
0.0001555266664f,
0.0001498026371f,
0.0001442452795f,
0.0001388512848f,
0.0001336173613f,
0.0001285402359f,
0.0001236166552f,
0.0001188433875f,
0.0001142172235f,
0.0001097349782f,
0.0001053934918f,
0.0001011896310f,
0.0000971202902f,
0.0000931823927f,
0.0000893728917f,
0.0000856887711f,
0.0000821270469f,
0.0000786847678f,
0.0000753590162f,
0.0000721469091f,
0.0000690455987f,
0.0000660522733f,
0.0000631641580f,
0.0000603785150f,
0.0000576926449f,
0.0000551038867f,
0.0000526096182f,
0.0000502072572f,
0.0000478942611f,
0.0000456681279f,
0.0000435263962f,
0.0000414666457f,
0.0000394864972f,
0.0000375836134f,
0.0000357556983f,
0.0000340004981f,
0.0000323158008f,
0.0000306994366f,
0.0000291492778f,
0.0000276632389f,
0.0000262392764f,
0.0000248753891f,
0.0000235696176f,
0.0000223200446f,
0.0000211247945f,
0.0000199820332f,
0.0000188899682f,
0.0000178468480f,
0.0000168509623f,
0.0000159006412f,
0.0000149942554f,
0.0000141302156f,
0.0000133069722f,
0.0000125230151f,
0.0000117768730f,
0.0000110671135f,
0.0000103923421f,
0.0000097512023f,
0.0000091423747f,
0.0000085645769f,
0.0000080165629f,
0.0000074971223f,
0.0000070050805f,
0.0000065392974f,
0.0000060986673f,
0.0000056821186f,
0.0000052886125f,
0.0000049171433f,
0.0000045667370f,
0.0000042364515f,
0.0000039253756f,
0.0000036326283f,
0.0000033573588f,
0.0000030987450f,
0.0000028559940f,
0.0000026283404f,
0.0000024150466f,
0.0000022154015f,
0.0000020287205f,
0.0000018543446f,
0.0000016916395f,
0.0000015399957f,
0.0000013988273f,
0.0000012675717f,
0.0000011456888f,
0.0000010326607f,
0.0000009279907f,
0.0000008312033f,
0.0000007418430f,
0.0000006594741f,
0.0000005836800f,
0.0000005140626f,
0.0000004502420f,
0.0000003918557f,
0.0000003385579f,
0.0000002900194f,
0.0000002459268f,
0.0000002059821f,
0.0000001699018f,
0.0000001374170f,
0.0000001082725f,
0.0000000822264f,
0.0000000590497f,
0.0000000385257f,
0.0000000204496f,
0.0000000046280f,
-0.0000000091215f,
-0.0000000209706f,
-0.0000000310810f,
-0.0000000396046f,
-0.0000000466841f,
-0.0000000524531f,
-0.0000000570369f,
-0.0000000605524f,
-0.0000000631089f,
-0.0000000648081f,
-0.0000000657448f,
-0.0000000660068f,
-0.0000000656757f,
-0.0000000648269f,
-0.0000000635299f,
-0.0000000618489f,
-0.0000000598428f,
-0.0000000575654f,
-0.0000000550661f,
-0.0000000523896f,
-0.0000000495767f,
-0.0000000466640f,
-0.0000000436847f,
-0.0000000406683f,
-0.0000000376411f,
-0.0000000346264f,
-0.0000001853079f,
};
}
}

29
core/src/dsp/firdec/taps/fir_4_2.h
Wyświetl plik

@ -1,29 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_4_2_len = 15;
const float fir_4_2_taps[] = {
0.0021282968604f,
0.0076473554450f,
0.0006460703751f,
-0.0368053147543f,
-0.0516552094180f,
0.0659607033051f,
0.2951835298658f,
0.4189947458581f,
0.2951835298658f,
0.0659607033051f,
-0.0516552094180f,
-0.0368053147543f,
0.0006460703751f,
0.0076473554450f,
0.0021282968604f,
};
}
}

153
core/src/dsp/firdec/taps/fir_4_4.h
Wyświetl plik

@ -1,153 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_4_4_len = 139;
const float fir_4_4_taps[] = {
0.0000421670468f,
0.0001624808733f,
0.0004134748309f,
0.0008154887363f,
0.0013234848969f,
0.0018039325195f,
0.0020508055942f,
0.0018514767578f,
0.0010883586950f,
-0.0001655988021f,
-0.0016128396844f,
-0.0027991727988f,
-0.0032807371963f,
-0.0028309298807f,
-0.0015892963679f,
-0.0000601423367f,
0.0010721577127f,
0.0012520595571f,
0.0003467812959f,
-0.0012334913120f,
-0.0026828654998f,
-0.0031783401077f,
-0.0023201194397f,
-0.0004020929064f,
0.0016614376925f,
0.0027617271233f,
0.0021869815035f,
0.0000713073547f,
-0.0025708936840f,
-0.0043015122742f,
-0.0040150945520f,
-0.0016068800323f,
0.0018386741176f,
0.0045100483540f,
0.0048045475259f,
0.0022668636218f,
-0.0020047039996f,
-0.0057855488980f,
-0.0068496560241f,
-0.0042397202795f,
0.0010243185376f,
0.0062751930360f,
0.0085115122341f,
0.0060706031243f,
-0.0002476114409f,
-0.0073175117999f,
-0.0111703368494f,
-0.0091526981761f,
-0.0016211575907f,
0.0078514356977f,
0.0140732387192f,
0.0129726920823f,
0.0040874732850f,
-0.0086349542834f,
-0.0184139640743f,
-0.0190500116861f,
-0.0085456264258f,
0.0090399664680f,
0.0247932831806f,
0.0290341811985f,
0.0165603631688f,
-0.0095223462745f,
-0.0375695624710f,
-0.0514111407319f,
-0.0372217902165f,
0.0096794936561f,
0.0812862136678f,
0.1585522999585f,
0.2179171693939f,
0.2401648350457f,
0.2179171693939f,
0.1585522999585f,
0.0812862136678f,
0.0096794936561f,
-0.0372217902165f,
-0.0514111407319f,
-0.0375695624710f,
-0.0095223462745f,
0.0165603631688f,
0.0290341811985f,
0.0247932831806f,
0.0090399664680f,
-0.0085456264258f,
-0.0190500116861f,
-0.0184139640743f,
-0.0086349542834f,
0.0040874732850f,
0.0129726920823f,
0.0140732387192f,
0.0078514356977f,
-0.0016211575907f,
-0.0091526981761f,
-0.0111703368494f,
-0.0073175117999f,
-0.0002476114409f,
0.0060706031243f,
0.0085115122341f,
0.0062751930360f,
0.0010243185376f,
-0.0042397202795f,
-0.0068496560241f,
-0.0057855488980f,
-0.0020047039996f,
0.0022668636218f,
0.0048045475259f,
0.0045100483540f,
0.0018386741176f,
-0.0016068800323f,
-0.0040150945520f,
-0.0043015122742f,
-0.0025708936840f,
0.0000713073547f,
0.0021869815035f,
0.0027617271233f,
0.0016614376925f,
-0.0004020929064f,
-0.0023201194397f,
-0.0031783401077f,
-0.0026828654998f,
-0.0012334913120f,
0.0003467812959f,
0.0012520595571f,
0.0010721577127f,
-0.0000601423367f,
-0.0015892963679f,
-0.0028309298807f,
-0.0032807371963f,
-0.0027991727988f,
-0.0016128396844f,
-0.0001655988021f,
0.0010883586950f,
0.0018514767578f,
0.0020508055942f,
0.0018039325195f,
0.0013234848969f,
0.0008154887363f,
0.0004134748309f,
0.0001624808733f,
0.0000421670468f,
};
}
}

725
core/src/dsp/firdec/taps/fir_512_128.h
Wyświetl plik

@ -1,725 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_512_128_len = 711;
const float fir_512_128_taps[] = {
-0.0000055896992f,
-0.0000013001543f,
-0.0000014502329f,
-0.0000016110215f,
-0.0000017829984f,
-0.0000019666521f,
-0.0000021624812f,
-0.0000023709942f,
-0.0000025927091f,
-0.0000028281532f,
-0.0000030778629f,
-0.0000033423834f,
-0.0000036222682f,
-0.0000039180789f,
-0.0000042303847f,
-0.0000045597620f,
-0.0000049067942f,
-0.0000052720710f,
-0.0000056561877f,
-0.0000060597452f,
-0.0000064833493f,
-0.0000069276099f,
-0.0000073931405f,
-0.0000078805577f,
-0.0000083904807f,
-0.0000089235302f,
-0.0000094803279f,
-0.0000100614958f,
-0.0000106676557f,
-0.0000112994278f,
-0.0000119574304f,
-0.0000126422788f,
-0.0000133545848f,
-0.0000140949552f,
-0.0000148639914f,
-0.0000156622882f,
-0.0000164904329f,
-0.0000173490044f,
-0.0000182385717f,
-0.0000191596936f,
-0.0000201129171f,
-0.0000210987761f,
-0.0000221177911f,
-0.0000231704670f,
-0.0000242572927f,
-0.0000253787397f,
-0.0000265352606f,
-0.0000277272881f,
-0.0000289552338f,
-0.0000302194865f,
-0.0000315204114f,
-0.0000328583485f,
-0.0000342336112f,
-0.0000356464850f,
-0.0000370972263f,
-0.0000385860605f,
-0.0000401131811f,
-0.0000416787480f,
-0.0000432828861f,
-0.0000449256839f,
-0.0000466071919f,
-0.0000483274213f,
-0.0000500863422f,
-0.0000518838825f,
-0.0000537199261f,
-0.0000555943117f,
-0.0000575068307f,
-0.0000594572265f,
-0.0000614451922f,
-0.0000634703697f,
-0.0000655323476f,
-0.0000676306604f,
-0.0000697647864f,
-0.0000719341464f,
-0.0000741381022f,
-0.0000763759553f,
-0.0000786469450f,
-0.0000809502475f,
-0.0000832849740f,
-0.0000856501695f,
-0.0000880448112f,
-0.0000904678075f,
-0.0000929179961f,
-0.0000953941432f,
-0.0000978949415f,
-0.0001004190099f,
-0.0001029648911f,
-0.0001055310512f,
-0.0001081158783f,
-0.0001107176810f,
-0.0001133346877f,
-0.0001159650452f,
-0.0001186068179f,
-0.0001212579865f,
-0.0001239164473f,
-0.0001265800111f,
-0.0001292464023f,
-0.0001319132583f,
-0.0001345781284f,
-0.0001372384734f,
-0.0001398916645f,
-0.0001425349833f,
-0.0001451656204f,
-0.0001477806759f,
-0.0001503771580f,
-0.0001529519831f,
-0.0001555019757f,
-0.0001580238676f,
-0.0001605142982f,
-0.0001629698139f,
-0.0001653868686f,
-0.0001677618232f,
-0.0001700909463f,
-0.0001723704138f,
-0.0001745963094f,
-0.0001767646249f,
-0.0001788712607f,
-0.0001809120262f,
-0.0001828826403f,
-0.0001847787321f,
-0.0001865958418f,
-0.0001883294212f,
-0.0001899748350f,
-0.0001915273613f,
-0.0001929821931f,
-0.0001943344392f,
-0.0001955791256f,
-0.0001967111968f,
-0.0001977255172f,
-0.0001986168726f,
-0.0001993799720f,
-0.0002000094489f,
-0.0002004998634f,
-0.0002008457042f,
-0.0002010413902f,
-0.0002010812729f,
-0.0002009596382f,
-0.0002006707090f,
-0.0002002086476f,
-0.0001995675575f,
-0.0001987414866f,
-0.0001977244297f,
-0.0001965103308f,
-0.0001950930862f,
-0.0001934665474f,
-0.0001916245241f,
-0.0001895607869f,
-0.0001872690707f,
-0.0001847430782f,
-0.0001819764827f,
-0.0001789629316f,
-0.0001756960501f,
-0.0001721694447f,
-0.0001683767065f,
-0.0001643114154f,
-0.0001599671433f,
-0.0001553374586f,
-0.0001504159297f,
-0.0001451961290f,
-0.0001396716370f,
-0.0001338360466f,
-0.0001276829672f,
-0.0001212060287f,
-0.0001143988861f,
-0.0001072552238f,
-0.0000997687600f,
-0.0000919332511f,
-0.0000837424964f,
-0.0000751903422f,
-0.0000662706872f,
-0.0000569774862f,
-0.0000473047557f,
-0.0000372465778f,
-0.0000267971056f,
-0.0000159505676f,
-0.0000047012723f,
0.0000069563861f,
0.0000190279240f,
0.0000315187628f,
0.0000444342241f,
0.0000577795252f,
0.0000715597739f,
0.0000857799638f,
0.0001004449692f,
0.0001155595405f,
0.0001311282992f,
0.0001471557332f,
0.0001636461917f,
0.0001806038808f,
0.0001980328584f,
0.0002159370295f,
0.0002343201416f,
0.0002531857801f,
0.0002725373634f,
0.0002923781387f,
0.0003127111768f,
0.0003335393686f,
0.0003548654197f,
0.0003766918469f,
0.0003990209730f,
0.0004218549234f,
0.0004451956214f,
0.0004690447845f,
0.0004934039201f,
0.0005182743216f,
0.0005436570649f,
0.0005695530043f,
0.0005959627692f,
0.0006228867602f,
0.0006503251459f,
0.0006782778596f,
0.0007067445959f,
0.0007357248078f,
0.0007652177037f,
0.0007952222443f,
0.0008257371403f,
0.0008567608492f,
0.0008882915736f,
0.0009203272580f,
0.0009528655873f,
0.0009859039843f,
0.0010194396081f,
0.0010534693522f,
0.0010879898425f,
0.0011229974367f,
0.0011584882220f,
0.0011944580146f,
0.0012309023586f,
0.0012678165250f,
0.0013051955110f,
0.0013430340397f,
0.0013813265595f,
0.0014200672442f,
0.0014592499929f,
0.0014988684300f,
0.0015389159058f,
0.0015793854968f,
0.0016202700068f,
0.0016615619670f,
0.0017032536381f,
0.0017453370105f,
0.0017878038064f,
0.0018306454814f,
0.0018738532257f,
0.0019174179666f,
0.0019613303706f,
0.0020055808454f,
0.0020501595428f,
0.0020950563610f,
0.0021402609477f,
0.0021857627034f,
0.0022315507840f,
0.0022776141047f,
0.0023239413434f,
0.0023705209447f,
0.0024173411233f,
0.0024643898688f,
0.0025116549495f,
0.0025591239169f,
0.0026067841107f,
0.0026546226632f,
0.0027026265043f,
0.0027507823669f,
0.0027990767918f,
0.0028474961335f,
0.0028960265655f,
0.0029446540864f,
0.0029933645254f,
0.0030421435486f,
0.0030909766650f,
0.0031398492332f,
0.0031887464674f,
0.0032376534443f,
0.0032865551097f,
0.0033354362854f,
0.0033842816762f,
0.0034330758769f,
0.0034818033796f,
0.0035304485810f,
0.0035789957896f,
0.0036274292338f,
0.0036757330686f,
0.0037238913843f,
0.0037718882136f,
0.0038197075396f,
0.0038673333040f,
0.0039147494150f,
0.0039619397550f,
0.0040088881896f,
0.0040555785748f,
0.0041019947660f,
0.0041481206260f,
0.0041939400332f,
0.0042394368905f,
0.0042845951330f,
0.0043293987369f,
0.0043738317277f,
0.0044178781890f,
0.0044615222704f,
0.0045047481964f,
0.0045475402748f,
0.0045898829050f,
0.0046317605863f,
0.0046731579268f,
0.0047140596512f,
0.0047544506094f,
0.0047943157851f,
0.0048336403032f,
0.0048724094390f,
0.0049106086256f,
0.0049482234626f,
0.0049852397233f,
0.0050216433634f,
0.0050574205286f,
0.0050925575621f,
0.0051270410128f,
0.0051608576423f,
0.0051939944329f,
0.0052264385945f,
0.0052581775725f,
0.0052891990541f,
0.0053194909762f,
0.0053490415314f,
0.0053778391756f,
0.0054058726342f,
0.0054331309083f,
0.0054596032817f,
0.0054852793266f,
0.0055101489098f,
0.0055342021983f,
0.0055574296655f,
0.0055798220963f,
0.0056013705925f,
0.0056220665783f,
0.0056419018048f,
0.0056608683553f,
0.0056789586495f,
0.0056961654483f,
0.0057124818576f,
0.0057279013330f,
0.0057424176828f,
0.0057560250723f,
0.0057687180271f,
0.0057804914360f,
0.0057913405542f,
0.0058012610063f,
0.0058102487887f,
0.0058183002716f,
0.0058254122019f,
0.0058315817045f,
0.0058368062842f,
0.0058410838272f,
0.0058444126023f,
0.0058467912620f,
0.0058482188432f,
0.0058486947679f,
0.0058482188432f,
0.0058467912620f,
0.0058444126023f,
0.0058410838272f,
0.0058368062842f,
0.0058315817045f,
0.0058254122019f,
0.0058183002716f,
0.0058102487887f,
0.0058012610063f,
0.0057913405542f,
0.0057804914360f,
0.0057687180271f,
0.0057560250723f,
0.0057424176828f,
0.0057279013330f,
0.0057124818576f,
0.0056961654483f,
0.0056789586495f,
0.0056608683553f,
0.0056419018048f,
0.0056220665783f,
0.0056013705925f,
0.0055798220963f,
0.0055574296655f,
0.0055342021983f,
0.0055101489098f,
0.0054852793266f,
0.0054596032817f,
0.0054331309083f,
0.0054058726342f,
0.0053778391756f,
0.0053490415314f,
0.0053194909762f,
0.0052891990541f,
0.0052581775725f,
0.0052264385945f,
0.0051939944329f,
0.0051608576423f,
0.0051270410128f,
0.0050925575621f,
0.0050574205286f,
0.0050216433634f,
0.0049852397233f,
0.0049482234626f,
0.0049106086256f,
0.0048724094390f,
0.0048336403032f,
0.0047943157851f,
0.0047544506094f,
0.0047140596512f,
0.0046731579268f,
0.0046317605863f,
0.0045898829050f,
0.0045475402748f,
0.0045047481964f,
0.0044615222704f,
0.0044178781890f,
0.0043738317277f,
0.0043293987369f,
0.0042845951330f,
0.0042394368905f,
0.0041939400332f,
0.0041481206260f,
0.0041019947660f,
0.0040555785748f,
0.0040088881896f,
0.0039619397550f,
0.0039147494150f,
0.0038673333040f,
0.0038197075396f,
0.0037718882136f,
0.0037238913843f,
0.0036757330686f,
0.0036274292338f,
0.0035789957896f,
0.0035304485810f,
0.0034818033796f,
0.0034330758769f,
0.0033842816762f,
0.0033354362854f,
0.0032865551097f,
0.0032376534443f,
0.0031887464674f,
0.0031398492332f,
0.0030909766650f,
0.0030421435486f,
0.0029933645254f,
0.0029446540864f,
0.0028960265655f,
0.0028474961335f,
0.0027990767918f,
0.0027507823669f,
0.0027026265043f,
0.0026546226632f,
0.0026067841107f,
0.0025591239169f,
0.0025116549495f,
0.0024643898688f,
0.0024173411233f,
0.0023705209447f,
0.0023239413434f,
0.0022776141047f,
0.0022315507840f,
0.0021857627034f,
0.0021402609477f,
0.0020950563610f,
0.0020501595428f,
0.0020055808454f,
0.0019613303706f,
0.0019174179666f,
0.0018738532257f,
0.0018306454814f,
0.0017878038064f,
0.0017453370105f,
0.0017032536381f,
0.0016615619670f,
0.0016202700068f,
0.0015793854968f,
0.0015389159058f,
0.0014988684300f,
0.0014592499929f,
0.0014200672442f,
0.0013813265595f,
0.0013430340397f,
0.0013051955110f,
0.0012678165250f,
0.0012309023586f,
0.0011944580146f,
0.0011584882220f,
0.0011229974367f,
0.0010879898425f,
0.0010534693522f,
0.0010194396081f,
0.0009859039843f,
0.0009528655873f,
0.0009203272580f,
0.0008882915736f,
0.0008567608492f,
0.0008257371403f,
0.0007952222443f,
0.0007652177037f,
0.0007357248078f,
0.0007067445959f,
0.0006782778596f,
0.0006503251459f,
0.0006228867602f,
0.0005959627692f,
0.0005695530043f,
0.0005436570649f,
0.0005182743216f,
0.0004934039201f,
0.0004690447845f,
0.0004451956214f,
0.0004218549234f,
0.0003990209730f,
0.0003766918469f,
0.0003548654197f,
0.0003335393686f,
0.0003127111768f,
0.0002923781387f,
0.0002725373634f,
0.0002531857801f,
0.0002343201416f,
0.0002159370295f,
0.0001980328584f,
0.0001806038808f,
0.0001636461917f,
0.0001471557332f,
0.0001311282992f,
0.0001155595405f,
0.0001004449692f,
0.0000857799638f,
0.0000715597739f,
0.0000577795252f,
0.0000444342241f,
0.0000315187628f,
0.0000190279240f,
0.0000069563861f,
-0.0000047012723f,
-0.0000159505676f,
-0.0000267971056f,
-0.0000372465778f,
-0.0000473047557f,
-0.0000569774862f,
-0.0000662706872f,
-0.0000751903422f,
-0.0000837424964f,
-0.0000919332511f,
-0.0000997687600f,
-0.0001072552238f,
-0.0001143988861f,
-0.0001212060287f,
-0.0001276829672f,
-0.0001338360466f,
-0.0001396716370f,
-0.0001451961290f,
-0.0001504159297f,
-0.0001553374586f,
-0.0001599671433f,
-0.0001643114154f,
-0.0001683767065f,
-0.0001721694447f,
-0.0001756960501f,
-0.0001789629316f,
-0.0001819764827f,
-0.0001847430782f,
-0.0001872690707f,
-0.0001895607869f,
-0.0001916245241f,
-0.0001934665474f,
-0.0001950930862f,
-0.0001965103308f,
-0.0001977244297f,
-0.0001987414866f,
-0.0001995675575f,
-0.0002002086476f,
-0.0002006707090f,
-0.0002009596382f,
-0.0002010812729f,
-0.0002010413902f,
-0.0002008457042f,
-0.0002004998634f,
-0.0002000094489f,
-0.0001993799720f,
-0.0001986168726f,
-0.0001977255172f,
-0.0001967111968f,
-0.0001955791256f,
-0.0001943344392f,
-0.0001929821931f,
-0.0001915273613f,
-0.0001899748350f,
-0.0001883294212f,
-0.0001865958418f,
-0.0001847787321f,
-0.0001828826403f,
-0.0001809120262f,
-0.0001788712607f,
-0.0001767646249f,
-0.0001745963094f,
-0.0001723704138f,
-0.0001700909463f,
-0.0001677618232f,
-0.0001653868686f,
-0.0001629698139f,
-0.0001605142982f,
-0.0001580238676f,
-0.0001555019757f,
-0.0001529519831f,
-0.0001503771580f,
-0.0001477806759f,
-0.0001451656204f,
-0.0001425349833f,
-0.0001398916645f,
-0.0001372384734f,
-0.0001345781284f,
-0.0001319132583f,
-0.0001292464023f,
-0.0001265800111f,
-0.0001239164473f,
-0.0001212579865f,
-0.0001186068179f,
-0.0001159650452f,
-0.0001133346877f,
-0.0001107176810f,
-0.0001081158783f,
-0.0001055310512f,
-0.0001029648911f,
-0.0001004190099f,
-0.0000978949415f,
-0.0000953941432f,
-0.0000929179961f,
-0.0000904678075f,
-0.0000880448112f,
-0.0000856501695f,
-0.0000832849740f,
-0.0000809502475f,
-0.0000786469450f,
-0.0000763759553f,
-0.0000741381022f,
-0.0000719341464f,
-0.0000697647864f,
-0.0000676306604f,
-0.0000655323476f,
-0.0000634703697f,
-0.0000614451922f,
-0.0000594572265f,
-0.0000575068307f,
-0.0000555943117f,
-0.0000537199261f,
-0.0000518838825f,
-0.0000500863422f,
-0.0000483274213f,
-0.0000466071919f,
-0.0000449256839f,
-0.0000432828861f,
-0.0000416787480f,
-0.0000401131811f,
-0.0000385860605f,
-0.0000370972263f,
-0.0000356464850f,
-0.0000342336112f,
-0.0000328583485f,
-0.0000315204114f,
-0.0000302194865f,
-0.0000289552338f,
-0.0000277272881f,
-0.0000265352606f,
-0.0000253787397f,
-0.0000242572927f,
-0.0000231704670f,
-0.0000221177911f,
-0.0000210987761f,
-0.0000201129171f,
-0.0000191596936f,
-0.0000182385717f,
-0.0000173490044f,
-0.0000164904329f,
-0.0000156622882f,
-0.0000148639914f,
-0.0000140949552f,
-0.0000133545848f,
-0.0000126422788f,
-0.0000119574304f,
-0.0000112994278f,
-0.0000106676557f,
-0.0000100614958f,
-0.0000094803279f,
-0.0000089235302f,
-0.0000083904807f,
-0.0000078805577f,
-0.0000073931405f,
-0.0000069276099f,
-0.0000064833493f,
-0.0000060597452f,
-0.0000056561877f,
-0.0000052720710f,
-0.0000049067942f,
-0.0000045597620f,
-0.0000042303847f,
-0.0000039180789f,
-0.0000036222682f,
-0.0000033423834f,
-0.0000030778629f,
-0.0000028281532f,
-0.0000025927091f,
-0.0000023709942f,
-0.0000021624812f,
-0.0000019666521f,
-0.0000017829984f,
-0.0000016110215f,
-0.0000014502329f,
-0.0000013001543f,
-0.0000055896992f,
};
}
}

78
core/src/dsp/firdec/taps/fir_512_16.h
Wyświetl plik

@ -1,78 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_512_16_len = 64;
const float fir_512_16_taps[] = {
0.0000151940580f,
0.0000353162294f,
0.0000744053215f,
0.0001396086425f,
0.0002418195104f,
0.0003943662769f,
0.0006129837252f,
0.0009156126139f,
0.0013220032816f,
0.0018531099165f,
0.0025302756637f,
0.0033742244254f,
0.0044038919853f,
0.0056351456882f,
0.0070794569573f,
0.0087426030278f,
0.0106234821202f,
0.0127131288122f,
0.0149940128678f,
0.0174396949525f,
0.0200148967258f,
0.0226760214362f,
0.0253721355820f,
0.0280463940126f,
0.0306378619753f,
0.0330836601043f,
0.0353213343016f,
0.0372913337462f,
0.0389394684890f,
0.0402192143245f,
0.0410937374123f,
0.0415375243532f,
0.0415375243532f,
0.0410937374123f,
0.0402192143245f,
0.0389394684890f,
0.0372913337462f,
0.0353213343016f,
0.0330836601043f,
0.0306378619753f,
0.0280463940126f,
0.0253721355820f,
0.0226760214362f,
0.0200148967258f,
0.0174396949525f,
0.0149940128678f,
0.0127131288122f,
0.0106234821202f,
0.0087426030278f,
0.0070794569573f,
0.0056351456882f,
0.0044038919853f,
0.0033742244254f,
0.0025302756637f,
0.0018531099165f,
0.0013220032816f,
0.0009156126139f,
0.0006129837252f,
0.0003943662769f,
0.0002418195104f,
0.0001396086425f,
0.0000744053215f,
0.0000353162294f,
0.0000151940580f,
};
}
}

165
core/src/dsp/firdec/taps/fir_512_32.h
Wyświetl plik

@ -1,165 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_512_32_len = 151;
const float fir_512_32_taps[] = {
0.0000009251202f,
0.0000018465197f,
0.0000024464700f,
0.0000043159736f,
0.0000061801355f,
0.0000092195926f,
0.0000128748733f,
0.0000179050798f,
0.0000241667435f,
0.0000322353329f,
0.0000422298191f,
0.0000546726009f,
0.0000698676453f,
0.0000883565591f,
0.0001105894638f,
0.0001371665649f,
0.0001686634471f,
0.0002057583064f,
0.0002491382743f,
0.0002995652579f,
0.0003578243175f,
0.0004247560835f,
0.0005012264845f,
0.0005881405242f,
0.0006864223881f,
0.0007970184354f,
0.0009208819280f,
0.0010589694866f,
0.0012122275138f,
0.0013815845184f,
0.0015679378702f,
0.0017721434865f,
0.0019950024469f,
0.0022372491131f,
0.0024995376582f,
0.0027824295157f,
0.0030863801975f,
0.0034117269055f,
0.0037586762067f,
0.0041272926196f,
0.0045174878173f,
0.0049290109819f,
0.0053614402367f,
0.0058141755168f,
0.0062864329037f,
0.0067772406753f,
0.0072854371318f,
0.0078096703652f,
0.0083484000282f,
0.0088999012000f,
0.0094622703727f,
0.0100334335903f,
0.0106111567180f,
0.0111930578078f,
0.0117766214851f,
0.0123592152594f,
0.0129381076271f,
0.0135104878117f,
0.0140734869548f,
0.0146242005530f,
0.0151597119088f,
0.0156771163460f,
0.0161735459270f,
0.0166461943912f,
0.0170923420315f,
0.0175093802160f,
0.0178948352652f,
0.0182463913957f,
0.0185619124518f,
0.0188394621562f,
0.0190773226296f,
0.0192740109449f,
0.0194282935085f,
0.0195391980867f,
0.0196060233225f,
0.0196283456221f,
0.0196060233225f,
0.0195391980867f,
0.0194282935085f,
0.0192740109449f,
0.0190773226296f,
0.0188394621562f,
0.0185619124518f,
0.0182463913957f,
0.0178948352652f,
0.0175093802160f,
0.0170923420315f,
0.0166461943912f,
0.0161735459270f,
0.0156771163460f,
0.0151597119088f,
0.0146242005530f,
0.0140734869548f,
0.0135104878117f,
0.0129381076271f,
0.0123592152594f,
0.0117766214851f,
0.0111930578078f,
0.0106111567180f,
0.0100334335903f,
0.0094622703727f,
0.0088999012000f,
0.0083484000282f,
0.0078096703652f,
0.0072854371318f,
0.0067772406753f,
0.0062864329037f,
0.0058141755168f,
0.0053614402367f,
0.0049290109819f,
0.0045174878173f,
0.0041272926196f,
0.0037586762067f,
0.0034117269055f,
0.0030863801975f,
0.0027824295157f,
0.0024995376582f,
0.0022372491131f,
0.0019950024469f,
0.0017721434865f,
0.0015679378702f,
0.0013815845184f,
0.0012122275138f,
0.0010589694866f,
0.0009208819280f,
0.0007970184354f,
0.0006864223881f,
0.0005881405242f,
0.0005012264845f,
0.0004247560835f,
0.0003578243175f,
0.0002995652579f,
0.0002491382743f,
0.0002057583064f,
0.0001686634471f,
0.0001371665649f,
0.0001105894638f,
0.0000883565591f,
0.0000698676453f,
0.0000546726009f,
0.0000422298191f,
0.0000322353329f,
0.0000241667435f,
0.0000179050798f,
0.0000128748733f,
0.0000092195926f,
0.0000061801355f,
0.0000043159736f,
0.0000024464700f,
0.0000018465197f,
0.0000009251202f,
};
}
}

298
core/src/dsp/firdec/taps/fir_512_64.h
Wyświetl plik

@ -1,298 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_512_64_len = 284;
const float fir_512_64_taps[] = {
-0.0000003515813f,
0.0000031171026f,
0.0000020524162f,
0.0000024542289f,
0.0000031065207f,
0.0000038930134f,
0.0000048162506f,
0.0000058895006f,
0.0000071310597f,
0.0000085581431f,
0.0000101918418f,
0.0000120521359f,
0.0000141629532f,
0.0000165472024f,
0.0000192318152f,
0.0000222427880f,
0.0000256102026f,
0.0000293632777f,
0.0000335353640f,
0.0000381590070f,
0.0000432709128f,
0.0000489070228f,
0.0000551074473f,
0.0000619115526f,
0.0000693628586f,
0.0000775041409f,
0.0000863822872f,
0.0000960434161f,
0.0001065376894f,
0.0001179144487f,
0.0001302269805f,
0.0001435276713f,
0.0001578727234f,
0.0001733173295f,
0.0001899203366f,
0.0002077394422f,
0.0002268358025f,
0.0002472692536f,
0.0002691028607f,
0.0002923981667f,
0.0003172196808f,
0.0003436301558f,
0.0003716950150f,
0.0004014776616f,
0.0004330438412f,
0.0004664569860f,
0.0005017825128f,
0.0005390832050f,
0.0005784234446f,
0.0006198646358f,
0.0006634693699f,
0.0007092968953f,
0.0007574072145f,
0.0008078566037f,
0.0008607016429f,
0.0009159947893f,
0.0009737883402f,
0.0010341300646f,
0.0010970670999f,
0.0011626416466f,
0.0012308947989f,
0.0013018623072f,
0.0013755783437f,
0.0014520713385f,
0.0015313676803f,
0.0016134876310f,
0.0016984489635f,
0.0017862629594f,
0.0018769379853f,
0.0019704755784f,
0.0020668739631f,
0.0021661242292f,
0.0022682137899f,
0.0023731226581f,
0.0024808268465f,
0.0025912947466f,
0.0027044904730f,
0.0028203703485f,
0.0029388861938f,
0.0030599819237f,
0.0031835967820f,
0.0033096620532f,
0.0034381042430f,
0.0035688419092f,
0.0037017887878f,
0.0038368507462f,
0.0039739288549f,
0.0041129164657f,
0.0042537022285f,
0.0043961672967f,
0.0045401882879f,
0.0046856346183f,
0.0048323714068f,
0.0049802569384f,
0.0051291455099f,
0.0052788850244f,
0.0054293197749f,
0.0055802881698f,
0.0057316254533f,
0.0058831615603f,
0.0060347237702f,
0.0061861346909f,
0.0063372148423f,
0.0064877807676f,
0.0066376475425f,
0.0067866270121f,
0.0069345302214f,
0.0070811657753f,
0.0072263421851f,
0.0073698663497f,
0.0075115458128f,
0.0076511873613f,
0.0077885991889f,
0.0079235896075f,
0.0080559691125f,
0.0081855492031f,
0.0083121443425f,
0.0084355708848f,
0.0085556489242f,
0.0086722013236f,
0.0087850554475f,
0.0088940422881f,
0.0089989980770f,
0.0090997635037f,
0.0091961852010f,
0.0092881150520f,
0.0093754115438f,
0.0094579391596f,
0.0095355695951f,
0.0096081812323f,
0.0096756602138f,
0.0097378999951f,
0.0097948022733f,
0.0098462766138f,
0.0098922412299f,
0.0099326226814f,
0.0099673565022f,
0.0099963869681f,
0.0100196675703f,
0.0100371608503f,
0.0100488387168f,
0.0100546823476f,
0.0100546823476f,
0.0100488387168f,
0.0100371608503f,
0.0100196675703f,
0.0099963869681f,
0.0099673565022f,
0.0099326226814f,
0.0098922412299f,
0.0098462766138f,
0.0097948022733f,
0.0097378999951f,
0.0096756602138f,
0.0096081812323f,
0.0095355695951f,
0.0094579391596f,
0.0093754115438f,
0.0092881150520f,
0.0091961852010f,
0.0090997635037f,
0.0089989980770f,
0.0088940422881f,
0.0087850554475f,
0.0086722013236f,
0.0085556489242f,
0.0084355708848f,
0.0083121443425f,
0.0081855492031f,
0.0080559691125f,
0.0079235896075f,
0.0077885991889f,
0.0076511873613f,
0.0075115458128f,
0.0073698663497f,
0.0072263421851f,
0.0070811657753f,
0.0069345302214f,
0.0067866270121f,
0.0066376475425f,
0.0064877807676f,
0.0063372148423f,
0.0061861346909f,
0.0060347237702f,
0.0058831615603f,
0.0057316254533f,
0.0055802881698f,
0.0054293197749f,
0.0052788850244f,
0.0051291455099f,
0.0049802569384f,
0.0048323714068f,
0.0046856346183f,
0.0045401882879f,
0.0043961672967f,
0.0042537022285f,
0.0041129164657f,
0.0039739288549f,
0.0038368507462f,
0.0037017887878f,
0.0035688419092f,
0.0034381042430f,
0.0033096620532f,
0.0031835967820f,
0.0030599819237f,
0.0029388861938f,
0.0028203703485f,
0.0027044904730f,
0.0025912947466f,
0.0024808268465f,
0.0023731226581f,
0.0022682137899f,
0.0021661242292f,
0.0020668739631f,
0.0019704755784f,
0.0018769379853f,
0.0017862629594f,
0.0016984489635f,
0.0016134876310f,
0.0015313676803f,
0.0014520713385f,
0.0013755783437f,
0.0013018623072f,
0.0012308947989f,
0.0011626416466f,
0.0010970670999f,
0.0010341300646f,
0.0009737883402f,
0.0009159947893f,
0.0008607016429f,
0.0008078566037f,
0.0007574072145f,
0.0007092968953f,
0.0006634693699f,
0.0006198646358f,
0.0005784234446f,
0.0005390832050f,
0.0005017825128f,
0.0004664569860f,
0.0004330438412f,
0.0004014776616f,
0.0003716950150f,
0.0003436301558f,
0.0003172196808f,
0.0002923981667f,
0.0002691028607f,
0.0002472692536f,
0.0002268358025f,
0.0002077394422f,
0.0001899203366f,
0.0001733173295f,
0.0001578727234f,
0.0001435276713f,
0.0001302269805f,
0.0001179144487f,
0.0001065376894f,
0.0000960434161f,
0.0000863822872f,
0.0000775041409f,
0.0000693628586f,
0.0000619115526f,
0.0000551074473f,
0.0000489070228f,
0.0000432709128f,
0.0000381590070f,
0.0000335353640f,
0.0000293632777f,
0.0000256102026f,
0.0000222427880f,
0.0000192318152f,
0.0000165472024f,
0.0000141629532f,
0.0000120521359f,
0.0000101918418f,
0.0000085581431f,
0.0000071310597f,
0.0000058895006f,
0.0000048162506f,
0.0000038930134f,
0.0000031065207f,
0.0000024542289f,
0.0000020524162f,
0.0000031171026f,
-0.0000003515813f,
};
}
}

104
core/src/dsp/firdec/taps/fir_64_16.h
Wyświetl plik

@ -1,104 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_64_16_len = 90;
const float fir_64_16_taps[] = {
-0.0000120522386f,
-0.0000222544605f,
-0.0000415800824f,
-0.0000705601980f,
-0.0001117597283f,
-0.0001677821532f,
-0.0002410541699f,
-0.0003335536910f,
-0.0004464864558f,
-0.0005799214861f,
-0.0007324007475f,
-0.0009005433028f,
-0.0010786685830f,
-0.0012584667286f,
-0.0014287458994f,
-0.0015752866570f,
-0.0016808317559f,
-0.0017252357928f,
-0.0016857931470f,
-0.0015377546562f,
-0.0012550337974f,
-0.0008110922394f,
-0.0001799830654f,
0.0006624815809f,
0.0017374824702f,
0.0030619182176f,
0.0046471635731f,
0.0064979256976f,
0.0086112639295f,
0.0109758357695f,
0.0135714252753f,
0.0163687998961f,
0.0193299283477f,
0.0224085760310f,
0.0255512765146f,
0.0286986586848f,
0.0317870903592f,
0.0347505815535f,
0.0375228752484f,
0.0400396413686f,
0.0422406815901f,
0.0440720490748f,
0.0454879886598f,
0.0464526093979f,
0.0469412124342f,
0.0469412124342f,
0.0464526093979f,
0.0454879886598f,
0.0440720490748f,
0.0422406815901f,
0.0400396413686f,
0.0375228752484f,
0.0347505815535f,
0.0317870903592f,
0.0286986586848f,
0.0255512765146f,
0.0224085760310f,
0.0193299283477f,
0.0163687998961f,
0.0135714252753f,
0.0109758357695f,
0.0086112639295f,
0.0064979256976f,
0.0046471635731f,
0.0030619182176f,
0.0017374824702f,
0.0006624815809f,
-0.0001799830654f,
-0.0008110922394f,
-0.0012550337974f,
-0.0015377546562f,
-0.0016857931470f,
-0.0017252357928f,
-0.0016808317559f,
-0.0015752866570f,
-0.0014287458994f,
-0.0012584667286f,
-0.0010786685830f,
-0.0009005433028f,
-0.0007324007475f,
-0.0005799214861f,
-0.0004464864558f,
-0.0003335536910f,
-0.0002410541699f,
-0.0001677821532f,
-0.0001117597283f,
-0.0000705601980f,
-0.0000415800824f,
-0.0000222544605f,
-0.0000120522386f,
};
}
}

18
core/src/dsp/firdec/taps/fir_64_2.h
Wyświetl plik

@ -1,18 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_64_2_len = 4;
const float fir_64_2_taps[] = {
0.1238512125230f,
0.3713298898913f,
0.3713298898913f,
0.1238512125230f,
};
}
}

268
core/src/dsp/firdec/taps/fir_64_32.h
Wyświetl plik

@ -1,268 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_64_32_len = 254;
const float fir_64_32_taps[] = {
0.0000071177827f,
0.0000052360330f,
0.0000070999389f,
0.0000093491421f,
0.0000120258010f,
0.0000151698657f,
0.0000188213706f,
0.0000230162819f,
0.0000277885900f,
0.0000331659761f,
0.0000391717261f,
0.0000458202516f,
0.0000531188652f,
0.0000610632073f,
0.0000696389402f,
0.0000788171514f,
0.0000885560397f,
0.0000987963809f,
0.0001094632965f,
0.0001204618823f,
0.0001316791619f,
0.0001429799890f,
0.0001542092968f,
0.0001651883918f,
0.0001757176133f,
0.0001855731360f,
0.0001945101517f,
0.0002022602911f,
0.0002085354301f,
0.0002130258290f,
0.0002154046469f,
0.0002153268755f,
0.0002124346213f,
0.0002063568823f,
0.0001967156262f,
0.0001831264229f,
0.0001652053085f,
0.0001425702458f,
0.0001148487208f,
0.0000816799586f,
0.0000427231519f,
-0.0000023396876f,
-0.0000537950170f,
-0.0001118944427f,
-0.0001768457191f,
-0.0002488091749f,
-0.0003278886589f,
-0.0004141279672f,
-0.0005075020096f,
-0.0006079135226f,
-0.0007151847604f,
-0.0008290548018f,
-0.0009491720834f,
-0.0010750926197f,
-0.0012062737004f,
-0.0013420733382f,
-0.0014817454403f,
-0.0016244407789f,
-0.0017692039202f,
-0.0019149759766f,
-0.0020605935333f,
-0.0022047933917f,
-0.0023462136721f,
-0.0024834006928f,
-0.0026148123580f,
-0.0027388272354f,
-0.0028537502533f,
-0.0029578239527f,
-0.0030492364244f,
-0.0031261346152f,
-0.0031866343375f,
-0.0032288354106f,
-0.0032508334770f,
-0.0032507366611f,
-0.0032266788309f,
-0.0031768373662f,
-0.0030994474167f,
-0.0029928202893f,
-0.0028553581802f,
-0.0026855726253f,
-0.0024820991257f,
-0.0022437150570f,
-0.0019693535723f,
-0.0016581203414f,
-0.0013093061003f,
-0.0009224015920f,
-0.0004971081448f,
-0.0000333502105f,
0.0004687166063f,
0.0010086959640f,
0.0015859458172f,
0.0021995722597f,
0.0028484280438f,
0.0035311102220f,
0.0042459624638f,
0.0049910767459f,
0.0057642996479f,
0.0065632382031f,
0.0073852702104f,
0.0082275542093f,
0.0090870436937f,
0.0099605010219f,
0.0108445152647f,
0.0117355197089f,
0.0126298129235f,
0.0135235793719f,
0.0144129131434f,
0.0152938410591f,
0.0161623483955f,
0.0170144037611f,
0.0178459860423f,
0.0186531102422f,
0.0194318548104f,
0.0201783875831f,
0.0208889926181f,
0.0215600953536f,
0.0221882880668f,
0.0227703533794f,
0.0233032874883f,
0.0237843211931f,
0.0242109401088f,
0.0245809024718f,
0.0248922556389f,
0.0251433500349f,
0.0253328513679f,
0.0254597502167f,
0.0255233695354f,
0.0255233695354f,
0.0254597502167f,
0.0253328513679f,
0.0251433500349f,
0.0248922556389f,
0.0245809024718f,
0.0242109401088f,
0.0237843211931f,
0.0233032874883f,
0.0227703533794f,
0.0221882880668f,
0.0215600953536f,
0.0208889926181f,
0.0201783875831f,
0.0194318548104f,
0.0186531102422f,
0.0178459860423f,
0.0170144037611f,
0.0161623483955f,
0.0152938410591f,
0.0144129131434f,
0.0135235793719f,
0.0126298129235f,
0.0117355197089f,
0.0108445152647f,
0.0099605010219f,
0.0090870436937f,
0.0082275542093f,
0.0073852702104f,
0.0065632382031f,
0.0057642996479f,
0.0049910767459f,
0.0042459624638f,
0.0035311102220f,
0.0028484280438f,
0.0021995722597f,
0.0015859458172f,
0.0010086959640f,
0.0004687166063f,
-0.0000333502105f,
-0.0004971081448f,
-0.0009224015920f,
-0.0013093061003f,
-0.0016581203414f,
-0.0019693535723f,
-0.0022437150570f,
-0.0024820991257f,
-0.0026855726253f,
-0.0028553581802f,
-0.0029928202893f,
-0.0030994474167f,
-0.0031768373662f,
-0.0032266788309f,
-0.0032507366611f,
-0.0032508334770f,
-0.0032288354106f,
-0.0031866343375f,
-0.0031261346152f,
-0.0030492364244f,
-0.0029578239527f,
-0.0028537502533f,
-0.0027388272354f,
-0.0026148123580f,
-0.0024834006928f,
-0.0023462136721f,
-0.0022047933917f,
-0.0020605935333f,
-0.0019149759766f,
-0.0017692039202f,
-0.0016244407789f,
-0.0014817454403f,
-0.0013420733382f,
-0.0012062737004f,
-0.0010750926197f,
-0.0009491720834f,
-0.0008290548018f,
-0.0007151847604f,
-0.0006079135226f,
-0.0005075020096f,
-0.0004141279672f,
-0.0003278886589f,
-0.0002488091749f,
-0.0001768457191f,
-0.0001118944427f,
-0.0000537950170f,
-0.0000023396876f,
0.0000427231519f,
0.0000816799586f,
0.0001148487208f,
0.0001425702458f,
0.0001652053085f,
0.0001831264229f,
0.0001967156262f,
0.0002063568823f,
0.0002124346213f,
0.0002153268755f,
0.0002154046469f,
0.0002130258290f,
0.0002085354301f,
0.0002022602911f,
0.0001945101517f,
0.0001855731360f,
0.0001757176133f,
0.0001651883918f,
0.0001542092968f,
0.0001429799890f,
0.0001316791619f,
0.0001204618823f,
0.0001094632965f,
0.0000987963809f,
0.0000885560397f,
0.0000788171514f,
0.0000696389402f,
0.0000610632073f,
0.0000531188652f,
0.0000458202516f,
0.0000391717261f,
0.0000331659761f,
0.0000277885900f,
0.0000230162819f,
0.0000188213706f,
0.0000151698657f,
0.0000120258010f,
0.0000093491421f,
0.0000070999389f,
0.0000052360330f,
0.0000071177827f,
};
}
}

33
core/src/dsp/firdec/taps/fir_64_4.h
Wyświetl plik

@ -1,33 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_64_4_len = 19;
const float fir_64_4_taps[] = {
0.0000429609248f,
0.0004765567633f,
0.0024957623882f,
0.0086502620997f,
0.0224930555988f,
0.0467176748088f,
0.0803238710382f,
0.1168174685032f,
0.1455785879790f,
0.1565458506682f,
0.1455785879790f,
0.1168174685032f,
0.0803238710382f,
0.0467176748088f,
0.0224930555988f,
0.0086502620997f,
0.0024957623882f,
0.0004765567633f,
0.0000429609248f,
};
}
}

50
core/src/dsp/firdec/taps/fir_64_8.h
Wyświetl plik

@ -1,50 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_64_8_len = 36;
const float fir_64_8_taps[] = {
0.0000128128011f,
0.0000776899411f,
0.0002545373360f,
0.0006610024251f,
0.0014604787010f,
0.0028714653290f,
0.0051457499501f,
0.0085388881542f,
0.0132623498958f,
0.0194293686660f,
0.0270017805237f,
0.0357514664485f,
0.0452474908137f,
0.0548772985184f,
0.0639035753681f,
0.0715509180316f,
0.0771091525773f,
0.0800353323941f,
0.0800353323941f,
0.0771091525773f,
0.0715509180316f,
0.0639035753681f,
0.0548772985184f,
0.0452474908137f,
0.0357514664485f,
0.0270017805237f,
0.0194293686660f,
0.0132623498958f,
0.0085388881542f,
0.0051457499501f,
0.0028714653290f,
0.0014604787010f,
0.0006610024251f,
0.0002545373360f,
0.0000776899411f,
0.0000128128011f,
};
}
}

23
core/src/dsp/firdec/taps/fir_8_2.h
Wyświetl plik

@ -1,23 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_8_2_len = 9;
const float fir_8_2_taps[] = {
-0.0096855460565f,
-0.0196926482904f,
0.0627645107767f,
0.2740445488509f,
0.4025398240918f,
0.2740445488509f,
0.0627645107767f,
-0.0196926482904f,
-0.0096855460565f,
};
}
}

46
core/src/dsp/firdec/taps/fir_8_4.h
Wyświetl plik

@ -1,46 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_8_4_len = 32;
const float fir_8_4_taps[] = {
0.0000925825278f,
0.0004344995834f,
0.0011434673031f,
0.0019921953877f,
0.0021069453084f,
0.0000218242037f,
-0.0055687125738f,
-0.0144165472383f,
-0.0233747474180f,
-0.0262097913981f,
-0.0154074590383f,
0.0142533246733f,
0.0619133245834f,
0.1188703177504f,
0.1704338338746f,
0.2011522624092f,
0.2011522624092f,
0.1704338338746f,
0.1188703177504f,
0.0619133245834f,
0.0142533246733f,
-0.0154074590383f,
-0.0262097913981f,
-0.0233747474180f,
-0.0144165472383f,
-0.0055687125738f,
0.0000218242037f,
0.0021069453084f,
0.0019921953877f,
0.0011434673031f,
0.0004344995834f,
0.0000925825278f,
};
}
}

294
core/src/dsp/firdec/taps/fir_8_8.h
Wyświetl plik

@ -1,294 +0,0 @@
#pragma once
/*
This file was auto-generated by Ryzerth's magic optimized FIR script.
DO NOT EDIT MANUALLY!!!
*/
namespace dsp {
namespace firdec {
const unsigned int fir_8_8_len = 280;
const float fir_8_8_taps[] = {
0.0000052994842f,
0.0000236531982f,
0.0000454431541f,
0.0000866606150f,
0.0001454681461f,
0.0002276460304f,
0.0003345911923f,
0.0004668904560f,
0.0006220183860f,
0.0007944666281f,
0.0009753045793f,
0.0011524547932f,
0.0013112968761f,
0.0014357836468f,
0.0015099531702f,
0.0015197416085f,
0.0014549038561f,
0.0013108132368f,
0.0010898828479f,
0.0008023617978f,
0.0004663041298f,
0.0001065892726f,
-0.0002470172936f,
-0.0005626469270f,
-0.0008097088243f,
-0.0009625110041f,
-0.0010036852815f,
-0.0009269528060f,
-0.0007387999373f,
-0.0004587307896f,
-0.0001179165349f,
0.0002437426033f,
0.0005819117379f,
0.0008530352611f,
0.0010198667279f,
0.0010566109951f,
0.0009529624621f,
0.0007164088602f,
0.0003723511050f,
-0.0000381502360f,
-0.0004628817408f,
-0.0008447972550f,
-0.0011294256831f,
-0.0012724326538f,
-0.0012463078782f,
-0.0010451923796f,
-0.0006870442177f,
-0.0002126532093f,
0.0003185796904f,
0.0008357346058f,
0.0012655423999f,
0.0015424876979f,
0.0016184879319f,
0.0014707552431f,
0.0011066080375f,
0.0005643461992f,
-0.0000901977407f,
-0.0007712304481f,
-0.0013838905368f,
-0.0018371322225f,
-0.0020568961991f,
-0.0019977090699f,
-0.0016509537671f,
-0.0010484135134f,
-0.0002602767483f,
0.0006124690999f,
0.0014505273627f,
0.0021321900783f,
0.0025505844320f,
0.0026298818820f,
0.0023380802069f,
0.0016943083615f,
0.0007692604372f,
-0.0003217361360f,
-0.0014324858797f,
-0.0024049762894f,
-0.0030913100580f,
-0.0033755493545f,
-0.0031923301613f,
-0.0025393728936f,
-0.0014817135720f,
-0.0001465338471f,
0.0012912514887f,
0.0026311543404f,
0.0036743211895f,
0.0042521988692f,
0.0042526374291f,
0.0036395284429f,
0.0024627622943f,
0.0008564752688f,
-0.0009748928184f,
-0.0027814968415f,
-0.0043010655579f,
-0.0052957555102f,
-0.0055878599029f,
-0.0050892037537f,
-0.0038196329489f,
-0.0019112679623f,
0.0004029949855f,
0.0028161150389f,
0.0049858689474f,
0.0065814235194f,
0.0073314238254f,
0.0070669002384f,
0.0057525958483f,
0.0035015266976f,
0.0005695959447f,
-0.0026703422489f,
-0.0057727554561f,
-0.0082771418381f,
-0.0097720954139f,
-0.0099573040630f,
-0.0086947790176f,
-0.0060415019273f,
-0.0022576736745f,
0.0022123488358f,
0.0067858745476f,
0.0108103047042f,
0.0136467461009f,
0.0147589153736f,
0.0137961123447f,
0.0106590975496f,
0.0055392102924f,
-0.0010761158185f,
-0.0084344441235f,
-0.0155846252876f,
-0.0214724302300f,
-0.0250557443256f,
-0.0254266556205f,
-0.0219263229678f,
-0.0142387338262f,
-0.0024513843925f,
0.0129256469755f,
0.0309861862491f,
0.0504987785185f,
0.0700154216583f,
0.0880072662488f,
0.1030129814746f,
0.1137837576738f,
0.1194090364685f,
0.1194090364685f,
0.1137837576738f,
0.1030129814746f,
0.0880072662488f,
0.0700154216583f,
0.0504987785185f,
0.0309861862491f,
0.0129256469755f,
-0.0024513843925f,
-0.0142387338262f,
-0.0219263229678f,
-0.0254266556205f,
-0.0250557443256f,
-0.0214724302300f,
-0.0155846252876f,
-0.0084344441235f,
-0.0010761158185f,
0.0055392102924f,
0.0106590975496f,
0.0137961123447f,
0.0147589153736f,
0.0136467461009f,
0.0108103047042f,
0.0067858745476f,
0.0022123488358f,
-0.0022576736745f,
-0.0060415019273f,
-0.0086947790176f,
-0.0099573040630f,
-0.0097720954139f,
-0.0082771418381f,
-0.0057727554561f,
-0.0026703422489f,
0.0005695959447f,
0.0035015266976f,
0.0057525958483f,
0.0070669002384f,
0.0073314238254f,
0.0065814235194f,
0.0049858689474f,
0.0028161150389f,
0.0004029949855f,
-0.0019112679623f,
-0.0038196329489f,
-0.0050892037537f,
-0.0055878599029f,
-0.0052957555102f,
-0.0043010655579f,
-0.0027814968415f,
-0.0009748928184f,
0.0008564752688f,
0.0024627622943f,
0.0036395284429f,
0.0042526374291f,
0.0042521988692f,
0.0036743211895f,
0.0026311543404f,
0.0012912514887f,
-0.0001465338471f,
-0.0014817135720f,
-0.0025393728936f,
-0.0031923301613f,
-0.0033755493545f,
-0.0030913100580f,
-0.0024049762894f,
-0.0014324858797f,
-0.0003217361360f,
0.0007692604372f,
0.0016943083615f,
0.0023380802069f,
0.0026298818820f,
0.0025505844320f,
0.0021321900783f,
0.0014505273627f,
0.0006124690999f,
-0.0002602767483f,
-0.0010484135134f,
-0.0016509537671f,
-0.0019977090699f,
-0.0020568961991f,
-0.0018371322225f,
-0.0013838905368f,
-0.0007712304481f,
-0.0000901977407f,
0.0005643461992f,
0.0011066080375f,
0.0014707552431f,
0.0016184879319f,
0.0015424876979f,
0.0012655423999f,
0.0008357346058f,
0.0003185796904f,
-0.0002126532093f,
-0.0006870442177f,
-0.0010451923796f,
-0.0012463078782f,
-0.0012724326538f,
-0.0011294256831f,
-0.0008447972550f,
-0.0004628817408f,
-0.0000381502360f,
0.0003723511050f,
0.0007164088602f,
0.0009529624621f,
0.0010566109951f,
0.0010198667279f,
0.0008530352611f,
0.0005819117379f,
0.0002437426033f,
-0.0001179165349f,
-0.0004587307896f,
-0.0007387999373f,
-0.0009269528060f,
-0.0010036852815f,
-0.0009625110041f,
-0.0008097088243f,
-0.0005626469270f,
-0.0002470172936f,
0.0001065892726f,
0.0004663041298f,
0.0008023617978f,
0.0010898828479f,
0.0013108132368f,
0.0014549038561f,
0.0015197416085f,
0.0015099531702f,
0.0014357836468f,
0.0013112968761f,
0.0011524547932f,
0.0009753045793f,
0.0007944666281f,
0.0006220183860f,
0.0004668904560f,
0.0003345911923f,
0.0002276460304f,
0.0001454681461f,
0.0000866606150f,
0.0000454431541f,
0.0000236531982f,
0.0000052994842f,
};
}
}

136
core/src/dsp/interpolation_taps.h
Wyświetl plik

@ -1,136 +0,0 @@
#pragma once
const int INTERP_TAP_COUNT = 8;
const int INTERP_STEPS = 128;
const float INTERP_TAPS[INTERP_STEPS + 1][INTERP_TAP_COUNT] = {
{ 0.00000e+00, 0.00000e+00, 0.00000e+00, 1.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00 },
{ -1.98993e-04, 1.24642e-03, -5.41054e-03, 9.98534e-01, 7.89295e-03, -2.76968e-03, 8.53777e-04, -1.54700e-04 },
{ -3.96391e-04, 2.47942e-03, -1.07209e-02, 9.96891e-01, 1.58840e-02, -5.55134e-03, 1.70888e-03, -3.09412e-04 },
{ -5.92100e-04, 3.69852e-03, -1.59305e-02, 9.95074e-01, 2.39714e-02, -8.34364e-03, 2.56486e-03, -4.64053e-04 },
{ -7.86031e-04, 4.90322e-03, -2.10389e-02, 9.93082e-01, 3.21531e-02, -1.11453e-02, 3.42130e-03, -6.18544e-04 },
{ -9.78093e-04, 6.09305e-03, -2.60456e-02, 9.90917e-01, 4.04274e-02, -1.39548e-02, 4.27773e-03, -7.72802e-04 },
{ -1.16820e-03, 7.26755e-03, -3.09503e-02, 9.88580e-01, 4.87921e-02, -1.67710e-02, 5.13372e-03, -9.26747e-04 },
{ -1.35627e-03, 8.42626e-03, -3.57525e-02, 9.86071e-01, 5.72454e-02, -1.95925e-02, 5.98883e-03, -1.08030e-03 },
{ -1.54221e-03, 9.56876e-03, -4.04519e-02, 9.83392e-01, 6.57852e-02, -2.24178e-02, 6.84261e-03, -1.23337e-03 },
{ -1.72594e-03, 1.06946e-02, -4.50483e-02, 9.80543e-01, 7.44095e-02, -2.52457e-02, 7.69462e-03, -1.38589e-03 },
{ -1.90738e-03, 1.18034e-02, -4.95412e-02, 9.77526e-01, 8.31162e-02, -2.80746e-02, 8.54441e-03, -1.53777e-03 },
{ -2.08645e-03, 1.28947e-02, -5.39305e-02, 9.74342e-01, 9.19033e-02, -3.09033e-02, 9.39154e-03, -1.68894e-03 },
{ -2.26307e-03, 1.39681e-02, -5.82159e-02, 9.70992e-01, 1.00769e-01, -3.37303e-02, 1.02356e-02, -1.83931e-03 },
{ -2.43718e-03, 1.50233e-02, -6.23972e-02, 9.67477e-01, 1.09710e-01, -3.65541e-02, 1.10760e-02, -1.98880e-03 },
{ -2.60868e-03, 1.60599e-02, -6.64743e-02, 9.63798e-01, 1.18725e-01, -3.93735e-02, 1.19125e-02, -2.13733e-03 },
{ -2.77751e-03, 1.70776e-02, -7.04471e-02, 9.59958e-01, 1.27812e-01, -4.21869e-02, 1.27445e-02, -2.28483e-03 },
{ -2.94361e-03, 1.80759e-02, -7.43154e-02, 9.55956e-01, 1.36968e-01, -4.49929e-02, 1.35716e-02, -2.43121e-03 },
{ -3.10689e-03, 1.90545e-02, -7.80792e-02, 9.51795e-01, 1.46192e-01, -4.77900e-02, 1.43934e-02, -2.57640e-03 },
{ -3.26730e-03, 2.00132e-02, -8.17385e-02, 9.47477e-01, 1.55480e-01, -5.05770e-02, 1.52095e-02, -2.72032e-03 },
{ -3.42477e-03, 2.09516e-02, -8.52933e-02, 9.43001e-01, 1.64831e-01, -5.33522e-02, 1.60193e-02, -2.86289e-03 },
{ -3.57923e-03, 2.18695e-02, -8.87435e-02, 9.38371e-01, 1.74242e-01, -5.61142e-02, 1.68225e-02, -3.00403e-03 },
{ -3.73062e-03, 2.27664e-02, -9.20893e-02, 9.33586e-01, 1.83711e-01, -5.88617e-02, 1.76185e-02, -3.14367e-03 },
{ -3.87888e-03, 2.36423e-02, -9.53307e-02, 9.28650e-01, 1.93236e-01, -6.15931e-02, 1.84071e-02, -3.28174e-03 },
{ -4.02397e-03, 2.44967e-02, -9.84679e-02, 9.23564e-01, 2.02814e-01, -6.43069e-02, 1.91877e-02, -3.41815e-03 },
{ -4.16581e-03, 2.53295e-02, -1.01501e-01, 9.18329e-01, 2.12443e-01, -6.70018e-02, 1.99599e-02, -3.55283e-03 },
{ -4.30435e-03, 2.61404e-02, -1.04430e-01, 9.12947e-01, 2.22120e-01, -6.96762e-02, 2.07233e-02, -3.68570e-03 },
{ -4.43955e-03, 2.69293e-02, -1.07256e-01, 9.07420e-01, 2.31843e-01, -7.23286e-02, 2.14774e-02, -3.81671e-03 },
{ -4.57135e-03, 2.76957e-02, -1.09978e-01, 9.01749e-01, 2.41609e-01, -7.49577e-02, 2.22218e-02, -3.94576e-03 },
{ -4.69970e-03, 2.84397e-02, -1.12597e-01, 8.95936e-01, 2.51417e-01, -7.75620e-02, 2.29562e-02, -4.07279e-03 },
{ -4.82456e-03, 2.91609e-02, -1.15113e-01, 8.89984e-01, 2.61263e-01, -8.01399e-02, 2.36801e-02, -4.19774e-03 },
{ -4.94589e-03, 2.98593e-02, -1.17526e-01, 8.83893e-01, 2.71144e-01, -8.26900e-02, 2.43930e-02, -4.32052e-03 },
{ -5.06363e-03, 3.05345e-02, -1.19837e-01, 8.77666e-01, 2.81060e-01, -8.52109e-02, 2.50946e-02, -4.44107e-03 },
{ -5.17776e-03, 3.11866e-02, -1.22047e-01, 8.71305e-01, 2.91006e-01, -8.77011e-02, 2.57844e-02, -4.55932e-03 },
{ -5.28823e-03, 3.18153e-02, -1.24154e-01, 8.64812e-01, 3.00980e-01, -9.01591e-02, 2.64621e-02, -4.67520e-03 },
{ -5.39500e-03, 3.24205e-02, -1.26161e-01, 8.58189e-01, 3.10980e-01, -9.25834e-02, 2.71272e-02, -4.78866e-03 },
{ -5.49804e-03, 3.30021e-02, -1.28068e-01, 8.51437e-01, 3.21004e-01, -9.49727e-02, 2.77794e-02, -4.89961e-03 },
{ -5.59731e-03, 3.35600e-02, -1.29874e-01, 8.44559e-01, 3.31048e-01, -9.73254e-02, 2.84182e-02, -5.00800e-03 },
{ -5.69280e-03, 3.40940e-02, -1.31581e-01, 8.37557e-01, 3.41109e-01, -9.96402e-02, 2.90433e-02, -5.11376e-03 },
{ -5.78446e-03, 3.46042e-02, -1.33189e-01, 8.30432e-01, 3.51186e-01, -1.01915e-01, 2.96543e-02, -5.21683e-03 },
{ -5.87227e-03, 3.50903e-02, -1.34699e-01, 8.23188e-01, 3.61276e-01, -1.04150e-01, 3.02507e-02, -5.31716e-03 },
{ -5.95620e-03, 3.55525e-02, -1.36111e-01, 8.15826e-01, 3.71376e-01, -1.06342e-01, 3.08323e-02, -5.41467e-03 },
{ -6.03624e-03, 3.59905e-02, -1.37426e-01, 8.08348e-01, 3.81484e-01, -1.08490e-01, 3.13987e-02, -5.50931e-03 },
{ -6.11236e-03, 3.64044e-02, -1.38644e-01, 8.00757e-01, 3.91596e-01, -1.10593e-01, 3.19495e-02, -5.60103e-03 },
{ -6.18454e-03, 3.67941e-02, -1.39767e-01, 7.93055e-01, 4.01710e-01, -1.12650e-01, 3.24843e-02, -5.68976e-03 },
{ -6.25277e-03, 3.71596e-02, -1.40794e-01, 7.85244e-01, 4.11823e-01, -1.14659e-01, 3.30027e-02, -5.77544e-03 },
{ -6.31703e-03, 3.75010e-02, -1.41727e-01, 7.77327e-01, 4.21934e-01, -1.16618e-01, 3.35046e-02, -5.85804e-03 },
{ -6.37730e-03, 3.78182e-02, -1.42566e-01, 7.69305e-01, 4.32038e-01, -1.18526e-01, 3.39894e-02, -5.93749e-03 },
{ -6.43358e-03, 3.81111e-02, -1.43313e-01, 7.61181e-01, 4.42134e-01, -1.20382e-01, 3.44568e-02, -6.01374e-03 },
{ -6.48585e-03, 3.83800e-02, -1.43968e-01, 7.52958e-01, 4.52218e-01, -1.22185e-01, 3.49066e-02, -6.08674e-03 },
{ -6.53412e-03, 3.86247e-02, -1.44531e-01, 7.44637e-01, 4.62289e-01, -1.23933e-01, 3.53384e-02, -6.15644e-03 },
{ -6.57836e-03, 3.88454e-02, -1.45004e-01, 7.36222e-01, 4.72342e-01, -1.25624e-01, 3.57519e-02, -6.22280e-03 },
{ -6.61859e-03, 3.90420e-02, -1.45387e-01, 7.27714e-01, 4.82377e-01, -1.27258e-01, 3.61468e-02, -6.28577e-03 },
{ -6.65479e-03, 3.92147e-02, -1.45682e-01, 7.19116e-01, 4.92389e-01, -1.28832e-01, 3.65227e-02, -6.34530e-03 },
{ -6.68698e-03, 3.93636e-02, -1.45889e-01, 7.10431e-01, 5.02377e-01, -1.30347e-01, 3.68795e-02, -6.40135e-03 },
{ -6.71514e-03, 3.94886e-02, -1.46009e-01, 7.01661e-01, 5.12337e-01, -1.31800e-01, 3.72167e-02, -6.45388e-03 },
{ -6.73929e-03, 3.95900e-02, -1.46043e-01, 6.92808e-01, 5.22267e-01, -1.33190e-01, 3.75341e-02, -6.50285e-03 },
{ -6.75943e-03, 3.96678e-02, -1.45993e-01, 6.83875e-01, 5.32164e-01, -1.34515e-01, 3.78315e-02, -6.54823e-03 },
{ -6.77557e-03, 3.97222e-02, -1.45859e-01, 6.74865e-01, 5.42025e-01, -1.35775e-01, 3.81085e-02, -6.58996e-03 },
{ -6.78771e-03, 3.97532e-02, -1.45641e-01, 6.65779e-01, 5.51849e-01, -1.36969e-01, 3.83650e-02, -6.62802e-03 },
{ -6.79588e-03, 3.97610e-02, -1.45343e-01, 6.56621e-01, 5.61631e-01, -1.38094e-01, 3.86006e-02, -6.66238e-03 },
{ -6.80007e-03, 3.97458e-02, -1.44963e-01, 6.47394e-01, 5.71370e-01, -1.39150e-01, 3.88151e-02, -6.69300e-03 },
{ -6.80032e-03, 3.97077e-02, -1.44503e-01, 6.38099e-01, 5.81063e-01, -1.40136e-01, 3.90083e-02, -6.71985e-03 },
{ -6.79662e-03, 3.96469e-02, -1.43965e-01, 6.28739e-01, 5.90706e-01, -1.41050e-01, 3.91800e-02, -6.74291e-03 },
{ -6.78902e-03, 3.95635e-02, -1.43350e-01, 6.19318e-01, 6.00298e-01, -1.41891e-01, 3.93299e-02, -6.76214e-03 },
{ -6.77751e-03, 3.94578e-02, -1.42658e-01, 6.09836e-01, 6.09836e-01, -1.42658e-01, 3.94578e-02, -6.77751e-03 },
{ -6.76214e-03, 3.93299e-02, -1.41891e-01, 6.00298e-01, 6.19318e-01, -1.43350e-01, 3.95635e-02, -6.78902e-03 },
{ -6.74291e-03, 3.91800e-02, -1.41050e-01, 5.90706e-01, 6.28739e-01, -1.43965e-01, 3.96469e-02, -6.79662e-03 },
{ -6.71985e-03, 3.90083e-02, -1.40136e-01, 5.81063e-01, 6.38099e-01, -1.44503e-01, 3.97077e-02, -6.80032e-03 },
{ -6.69300e-03, 3.88151e-02, -1.39150e-01, 5.71370e-01, 6.47394e-01, -1.44963e-01, 3.97458e-02, -6.80007e-03 },
{ -6.66238e-03, 3.86006e-02, -1.38094e-01, 5.61631e-01, 6.56621e-01, -1.45343e-01, 3.97610e-02, -6.79588e-03 },
{ -6.62802e-03, 3.83650e-02, -1.36969e-01, 5.51849e-01, 6.65779e-01, -1.45641e-01, 3.97532e-02, -6.78771e-03 },
{ -6.58996e-03, 3.81085e-02, -1.35775e-01, 5.42025e-01, 6.74865e-01, -1.45859e-01, 3.97222e-02, -6.77557e-03 },
{ -6.54823e-03, 3.78315e-02, -1.34515e-01, 5.32164e-01, 6.83875e-01, -1.45993e-01, 3.96678e-02, -6.75943e-03 },
{ -6.50285e-03, 3.75341e-02, -1.33190e-01, 5.22267e-01, 6.92808e-01, -1.46043e-01, 3.95900e-02, -6.73929e-03 },
{ -6.45388e-03, 3.72167e-02, -1.31800e-01, 5.12337e-01, 7.01661e-01, -1.46009e-01, 3.94886e-02, -6.71514e-03 },
{ -6.40135e-03, 3.68795e-02, -1.30347e-01, 5.02377e-01, 7.10431e-01, -1.45889e-01, 3.93636e-02, -6.68698e-03 },
{ -6.34530e-03, 3.65227e-02, -1.28832e-01, 4.92389e-01, 7.19116e-01, -1.45682e-01, 3.92147e-02, -6.65479e-03 },
{ -6.28577e-03, 3.61468e-02, -1.27258e-01, 4.82377e-01, 7.27714e-01, -1.45387e-01, 3.90420e-02, -6.61859e-03 },
{ -6.22280e-03, 3.57519e-02, -1.25624e-01, 4.72342e-01, 7.36222e-01, -1.45004e-01, 3.88454e-02, -6.57836e-03 },
{ -6.15644e-03, 3.53384e-02, -1.23933e-01, 4.62289e-01, 7.44637e-01, -1.44531e-01, 3.86247e-02, -6.53412e-03 },
{ -6.08674e-03, 3.49066e-02, -1.22185e-01, 4.52218e-01, 7.52958e-01, -1.43968e-01, 3.83800e-02, -6.48585e-03 },
{ -6.01374e-03, 3.44568e-02, -1.20382e-01, 4.42134e-01, 7.61181e-01, -1.43313e-01, 3.81111e-02, -6.43358e-03 },
{ -5.93749e-03, 3.39894e-02, -1.18526e-01, 4.32038e-01, 7.69305e-01, -1.42566e-01, 3.78182e-02, -6.37730e-03 },
{ -5.85804e-03, 3.35046e-02, -1.16618e-01, 4.21934e-01, 7.77327e-01, -1.41727e-01, 3.75010e-02, -6.31703e-03 },
{ -5.77544e-03, 3.30027e-02, -1.14659e-01, 4.11823e-01, 7.85244e-01, -1.40794e-01, 3.71596e-02, -6.25277e-03 },
{ -5.68976e-03, 3.24843e-02, -1.12650e-01, 4.01710e-01, 7.93055e-01, -1.39767e-01, 3.67941e-02, -6.18454e-03 },
{ -5.60103e-03, 3.19495e-02, -1.10593e-01, 3.91596e-01, 8.00757e-01, -1.38644e-01, 3.64044e-02, -6.11236e-03 },
{ -5.50931e-03, 3.13987e-02, -1.08490e-01, 3.81484e-01, 8.08348e-01, -1.37426e-01, 3.59905e-02, -6.03624e-03 },
{ -5.41467e-03, 3.08323e-02, -1.06342e-01, 3.71376e-01, 8.15826e-01, -1.36111e-01, 3.55525e-02, -5.95620e-03 },
{ -5.31716e-03, 3.02507e-02, -1.04150e-01, 3.61276e-01, 8.23188e-01, -1.34699e-01, 3.50903e-02, -5.87227e-03 },
{ -5.21683e-03, 2.96543e-02, -1.01915e-01, 3.51186e-01, 8.30432e-01, -1.33189e-01, 3.46042e-02, -5.78446e-03 },
{ -5.11376e-03, 2.90433e-02, -9.96402e-02, 3.41109e-01, 8.37557e-01, -1.31581e-01, 3.40940e-02, -5.69280e-03 },
{ -5.00800e-03, 2.84182e-02, -9.73254e-02, 3.31048e-01, 8.44559e-01, -1.29874e-01, 3.35600e-02, -5.59731e-03 },
{ -4.89961e-03, 2.77794e-02, -9.49727e-02, 3.21004e-01, 8.51437e-01, -1.28068e-01, 3.30021e-02, -5.49804e-03 },
{ -4.78866e-03, 2.71272e-02, -9.25834e-02, 3.10980e-01, 8.58189e-01, -1.26161e-01, 3.24205e-02, -5.39500e-03 },
{ -4.67520e-03, 2.64621e-02, -9.01591e-02, 3.00980e-01, 8.64812e-01, -1.24154e-01, 3.18153e-02, -5.28823e-03 },
{ -4.55932e-03, 2.57844e-02, -8.77011e-02, 2.91006e-01, 8.71305e-01, -1.22047e-01, 3.11866e-02, -5.17776e-03 },
{ -4.44107e-03, 2.50946e-02, -8.52109e-02, 2.81060e-01, 8.77666e-01, -1.19837e-01, 3.05345e-02, -5.06363e-03 },
{ -4.32052e-03, 2.43930e-02, -8.26900e-02, 2.71144e-01, 8.83893e-01, -1.17526e-01, 2.98593e-02, -4.94589e-03 },
{ -4.19774e-03, 2.36801e-02, -8.01399e-02, 2.61263e-01, 8.89984e-01, -1.15113e-01, 2.91609e-02, -4.82456e-03 },
{ -4.07279e-03, 2.29562e-02, -7.75620e-02, 2.51417e-01, 8.95936e-01, -1.12597e-01, 2.84397e-02, -4.69970e-03 },
{ -3.94576e-03, 2.22218e-02, -7.49577e-02, 2.41609e-01, 9.01749e-01, -1.09978e-01, 2.76957e-02, -4.57135e-03 },
{ -3.81671e-03, 2.14774e-02, -7.23286e-02, 2.31843e-01, 9.07420e-01, -1.07256e-01, 2.69293e-02, -4.43955e-03 },
{ -3.68570e-03, 2.07233e-02, -6.96762e-02, 2.22120e-01, 9.12947e-01, -1.04430e-01, 2.61404e-02, -4.30435e-03 },
{ -3.55283e-03, 1.99599e-02, -6.70018e-02, 2.12443e-01, 9.18329e-01, -1.01501e-01, 2.53295e-02, -4.16581e-03 },
{ -3.41815e-03, 1.91877e-02, -6.43069e-02, 2.02814e-01, 9.23564e-01, -9.84679e-02, 2.44967e-02, -4.02397e-03 },
{ -3.28174e-03, 1.84071e-02, -6.15931e-02, 1.93236e-01, 9.28650e-01, -9.53307e-02, 2.36423e-02, -3.87888e-03 },
{ -3.14367e-03, 1.76185e-02, -5.88617e-02, 1.83711e-01, 9.33586e-01, -9.20893e-02, 2.27664e-02, -3.73062e-03 },
{ -3.00403e-03, 1.68225e-02, -5.61142e-02, 1.74242e-01, 9.38371e-01, -8.87435e-02, 2.18695e-02, -3.57923e-03 },
{ -2.86289e-03, 1.60193e-02, -5.33522e-02, 1.64831e-01, 9.43001e-01, -8.52933e-02, 2.09516e-02, -3.42477e-03 },
{ -2.72032e-03, 1.52095e-02, -5.05770e-02, 1.55480e-01, 9.47477e-01, -8.17385e-02, 2.00132e-02, -3.26730e-03 },
{ -2.57640e-03, 1.43934e-02, -4.77900e-02, 1.46192e-01, 9.51795e-01, -7.80792e-02, 1.90545e-02, -3.10689e-03 },
{ -2.43121e-03, 1.35716e-02, -4.49929e-02, 1.36968e-01, 9.55956e-01, -7.43154e-02, 1.80759e-02, -2.94361e-03 },
{ -2.28483e-03, 1.27445e-02, -4.21869e-02, 1.27812e-01, 9.59958e-01, -7.04471e-02, 1.70776e-02, -2.77751e-03 },
{ -2.13733e-03, 1.19125e-02, -3.93735e-02, 1.18725e-01, 9.63798e-01, -6.64743e-02, 1.60599e-02, -2.60868e-03 },
{ -1.98880e-03, 1.10760e-02, -3.65541e-02, 1.09710e-01, 9.67477e-01, -6.23972e-02, 1.50233e-02, -2.43718e-03 },
{ -1.83931e-03, 1.02356e-02, -3.37303e-02, 1.00769e-01, 9.70992e-01, -5.82159e-02, 1.39681e-02, -2.26307e-03 },
{ -1.68894e-03, 9.39154e-03, -3.09033e-02, 9.19033e-02, 9.74342e-01, -5.39305e-02, 1.28947e-02, -2.08645e-03 },
{ -1.53777e-03, 8.54441e-03, -2.80746e-02, 8.31162e-02, 9.77526e-01, -4.95412e-02, 1.18034e-02, -1.90738e-03 },
{ -1.38589e-03, 7.69462e-03, -2.52457e-02, 7.44095e-02, 9.80543e-01, -4.50483e-02, 1.06946e-02, -1.72594e-03 },
{ -1.23337e-03, 6.84261e-03, -2.24178e-02, 6.57852e-02, 9.83392e-01, -4.04519e-02, 9.56876e-03, -1.54221e-03 },
{ -1.08030e-03, 5.98883e-03, -1.95925e-02, 5.72454e-02, 9.86071e-01, -3.57525e-02, 8.42626e-03, -1.35627e-03 },
{ -9.26747e-04, 5.13372e-03, -1.67710e-02, 4.87921e-02, 9.88580e-01, -3.09503e-02, 7.26755e-03, -1.16820e-03 },
{ -7.72802e-04, 4.27773e-03, -1.39548e-02, 4.04274e-02, 9.90917e-01, -2.60456e-02, 6.09305e-03, -9.78093e-04 },
{ -6.18544e-04, 3.42130e-03, -1.11453e-02, 3.21531e-02, 9.93082e-01, -2.10389e-02, 4.90322e-03, -7.86031e-04 },
{ -4.64053e-04, 2.56486e-03, -8.34364e-03, 2.39714e-02, 9.95074e-01, -1.59305e-02, 3.69852e-03, -5.92100e-04 },
{ -3.09412e-04, 1.70888e-03, -5.55134e-03, 1.58840e-02, 9.96891e-01, -1.07209e-02, 2.47942e-03, -3.96391e-04 },
{ -1.54700e-04, 8.53777e-04, -2.76968e-03, 7.89295e-03, 9.98534e-01, -5.41054e-03, 1.24642e-03, -1.98993e-04 },
{ 0.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00, 1.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00 },
};

54
core/src/dsp/link.h
Wyświetl plik

@ -1,54 +0,0 @@
#pragma once
#include <dsp/block.h>
namespace dsp {
template <class T>
class Link : public generic_block<Link<T>> {
public:
Link() {}
Link(stream<T>* a, stream<T>* b) { init(a, b); }
void init(stream<T>* in, stream<T>* out) {
_in = in;
_out = out;
generic_block<Link<T>>::registerInput(_in);
generic_block<Link<T>>::registerOutput(_out);
generic_block<Link<T>>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<Link<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Link<T>>::ctrlMtx);
generic_block<Link<T>>::tempStop();
generic_block<Link<T>>::unregisterInput(_in);
_in = in;
generic_block<Link<T>>::registerInput(_in);
generic_block<Link<T>>::tempStart();
}
void setOutput(stream<T>* out) {
assert(generic_block<Link<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Link<T>>::ctrlMtx);
generic_block<Link<T>>::tempStop();
generic_block<Link<T>>::unregisterOutput(_out);
_out = out;
generic_block<Link<T>>::registerOutput(_out);
generic_block<Link<T>>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
memcpy(_out->writeBuf, _in->readBuf, count * sizeof(T));
_in->flush();
return _out->swap(count) ? count : -1;
}
private:
stream<T>* _in;
stream<T>* _out;
};
}

246
core/src/dsp/math.h
Wyświetl plik

@ -1,246 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <volk/volk.h>
namespace dsp {
template <class T>
class Add : public generic_block<Add<T>> {
public:
Add() {}
Add(stream<T>* a, stream<T>* b) { init(a, b); }
void init(stream<T>* a, stream<T>* b) {
_a = a;
_b = b;
generic_block<Add<T>>::registerInput(a);
generic_block<Add<T>>::registerInput(b);
generic_block<Add<T>>::registerOutput(&out);
generic_block<Add<T>>::_block_init = true;
}
void setInputs(stream<T>* a, stream<T>* b) {
assert(generic_block<Add<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Add<T>>::ctrlMtx);
generic_block<Add<T>>::tempStop();
generic_block<Add<T>>::unregisterInput(_a);
generic_block<Add<T>>::unregisterInput(_b);
_a = a;
_b = b;
generic_block<Add<T>>::registerInput(_a);
generic_block<Add<T>>::registerInput(_b);
generic_block<Add<T>>::tempStart();
}
void setInputA(stream<T>* a) {
assert(generic_block<Add<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Add<T>>::ctrlMtx);
generic_block<Add<T>>::tempStop();
generic_block<Add<T>>::unregisterInput(_a);
_a = a;
generic_block<Add<T>>::registerInput(_a);
generic_block<Add<T>>::tempStart();
}
void setInputB(stream<T>* b) {
assert(generic_block<Add<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Add<T>>::ctrlMtx);
generic_block<Add<T>>::tempStop();
generic_block<Add<T>>::unregisterInput(_b);
_b = b;
generic_block<Add<T>>::registerInput(_b);
generic_block<Add<T>>::tempStart();
}
int run() {
int a_count = _a->read();
if (a_count < 0) { return -1; }
int b_count = _b->read();
if (b_count < 0) { return -1; }
if (a_count != b_count) {
_a->flush();
_b->flush();
return 0;
}
if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
// TODO: Switch this out for volk_32fc_x2_add_32fc with a check for old volk versions that don't have it (eg. Ubuntu 18.04 that has volk 1.3)
volk_32f_x2_add_32f((float*)out.writeBuf, (float*)_a->readBuf, (float*)_b->readBuf, a_count * 2);
}
else {
volk_32f_x2_add_32f(out.writeBuf, _a->readBuf, _b->readBuf, a_count);
}
_a->flush();
_b->flush();
if (!out.swap(a_count)) { return -1; }
return a_count;
}
stream<T> out;
private:
stream<T>* _a;
stream<T>* _b;
};
template <class T>
class Subtract : public generic_block<Subtract<T>> {
public:
Subtract() {}
Subtract(stream<T>* a, stream<T>* b) { init(a, b); }
void init(stream<T>* a, stream<T>* b) {
_a = a;
_b = b;
generic_block<Subtract<T>>::registerInput(a);
generic_block<Subtract<T>>::registerInput(b);
generic_block<Subtract<T>>::registerOutput(&out);
generic_block<Subtract<T>>::_block_init = true;
}
void setInputs(stream<T>* a, stream<T>* b) {
assert(generic_block<Subtract<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Subtract<T>>::ctrlMtx);
generic_block<Subtract<T>>::tempStop();
generic_block<Subtract<T>>::unregisterInput(_a);
generic_block<Subtract<T>>::unregisterInput(_b);
_a = a;
_b = b;
generic_block<Subtract<T>>::registerInput(_a);
generic_block<Subtract<T>>::registerInput(_b);
generic_block<Subtract<T>>::tempStart();
}
void setInputA(stream<T>* a) {
assert(generic_block<Subtract<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Subtract<T>>::ctrlMtx);
generic_block<Subtract<T>>::tempStop();
generic_block<Subtract<T>>::unregisterInput(_a);
_a = a;
generic_block<Subtract<T>>::registerInput(_a);
generic_block<Subtract<T>>::tempStart();
}
void setInputB(stream<T>* b) {
assert(generic_block<Subtract<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Subtract<T>>::ctrlMtx);
generic_block<Subtract<T>>::tempStop();
generic_block<Subtract<T>>::unregisterInput(_b);
_b = b;
generic_block<Subtract<T>>::registerInput(_b);
generic_block<Subtract<T>>::tempStart();
}
int run() {
int a_count = _a->read();
if (a_count < 0) { return -1; }
int b_count = _b->read();
if (b_count < 0) { return -1; }
if (a_count != b_count) {
_a->flush();
_b->flush();
return 0;
}
if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
volk_32f_x2_subtract_32f((float*)out.writeBuf, (float*)_a->readBuf, (float*)_b->readBuf, a_count * 2);
}
else {
volk_32f_x2_subtract_32f(out.writeBuf, _a->readBuf, _b->readBuf, a_count);
}
_a->flush();
_b->flush();
if (!out.swap(a_count)) { return -1; }
return a_count;
}
stream<T> out;
private:
stream<T>* _a;
stream<T>* _b;
};
template <class T>
class Multiply : public generic_block<Multiply<T>> {
public:
Multiply() {}
Multiply(stream<T>* a, stream<T>* b) { init(a, b); }
void init(stream<T>* a, stream<T>* b) {
_a = a;
_b = b;
generic_block<Multiply<T>>::registerInput(a);
generic_block<Multiply<T>>::registerInput(b);
generic_block<Multiply<T>>::registerOutput(&out);
generic_block<Multiply<T>>::_block_init = true;
}
void setInputs(stream<T>* a, stream<T>* b) {
assert(generic_block<Multiply<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Multiply<T>>::ctrlMtx);
generic_block<Multiply<T>>::tempStop();
generic_block<Multiply<T>>::unregisterInput(_a);
generic_block<Multiply<T>>::unregisterInput(_b);
_a = a;
_b = b;
generic_block<Multiply<T>>::registerInput(_a);
generic_block<Multiply<T>>::registerInput(_b);
generic_block<Multiply<T>>::tempStart();
}
void setInputA(stream<T>* a) {
assert(generic_block<Multiply<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Multiply<T>>::ctrlMtx);
generic_block<Multiply<T>>::tempStop();
generic_block<Multiply<T>>::unregisterInput(_a);
_a = a;
generic_block<Multiply<T>>::registerInput(_a);
generic_block<Multiply<T>>::tempStart();
}
void setInputB(stream<T>* b) {
assert(generic_block<Multiply<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Multiply<T>>::ctrlMtx);
generic_block<Multiply<T>>::tempStop();
generic_block<Multiply<T>>::unregisterInput(_b);
_b = b;
generic_block<Multiply<T>>::registerInput(_b);
generic_block<Multiply<T>>::tempStart();
}
int run() {
int a_count = _a->read();
if (a_count < 0) { return -1; }
int b_count = _b->read();
if (b_count < 0) { return -1; }
if (a_count != b_count) {
_a->flush();
_b->flush();
return 0;
}
if constexpr (std::is_same_v<T, complex_t>) {
volk_32fc_x2_multiply_32fc((lv_32fc_t*)out.writeBuf, (lv_32fc_t*)_a->readBuf, (lv_32fc_t*)_b->readBuf, a_count);
}
else {
volk_32f_x2_multiply_32f(out.writeBuf, _a->readBuf, _b->readBuf, a_count);
}
_a->flush();
_b->flush();
if (!out.swap(a_count)) { return -1; }
return a_count;
}
stream<T> out;
private:
stream<T>* _a;
stream<T>* _b;
};
}

81
core/src/dsp/measure.h
Wyświetl plik

@ -1,81 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <fftw3.h>
#include <volk/volk.h>
#include <spdlog/spdlog.h>
#include <dsp/types.h>
#include <string.h>
namespace dsp {
class LevelMeter : public generic_block<LevelMeter> {
public:
LevelMeter() {}
LevelMeter(stream<stereo_t>* in) { init(in); }
void init(stream<stereo_t>* in) {
_in = in;
generic_block<LevelMeter>::registerInput(_in);
generic_block<LevelMeter>::_block_init = true;
}
void setInput(stream<stereo_t>* in) {
assert(generic_block<LevelMeter>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<LevelMeter>::ctrlMtx);
generic_block<LevelMeter>::tempStop();
generic_block<LevelMeter>::unregisterInput(_in);
_in = in;
generic_block<LevelMeter>::registerInput(_in);
generic_block<LevelMeter>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
float maxL = 0, maxR = 0;
float absL, absR;
for (int i = 0; i < count; i++) {
absL = fabs(_in->readBuf[i].l);
absR = fabs(_in->readBuf[i].r);
if (absL > maxL) { maxL = absL; }
if (absR > maxR) { maxR = absR; }
}
_in->flush();
float _lvlL = 10.0f * logf(maxL);
float _lvlR = 10.0f * logf(maxR);
// Update max values
{
std::lock_guard<std::mutex> lck(lvlMtx);
if (_lvlL > lvlL) { lvlL = _lvlL; }
if (_lvlR > lvlR) { lvlR = _lvlR; }
}
return count;
}
float getLeftLevel() {
std::lock_guard<std::mutex> lck(lvlMtx);
float ret = lvlL;
lvlL = -90.0f;
return ret;
}
float getRightLevel() {
std::lock_guard<std::mutex> lck(lvlMtx);
float ret = lvlR;
lvlR = -90.0f;
return ret;
}
private:
float lvlL = -90.0f;
float lvlR = -90.0f;
stream<stereo_t>* _in;
std::mutex lvlMtx;
};
}

66
core/src/dsp/meteor/hrpt.h
Wyświetl plik

@ -1,66 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/utils/bitstream.h>
namespace dsp {
namespace meteor {
class HRPTDemux : public generic_block<HRPTDemux> {
public:
HRPTDemux() {}
HRPTDemux(stream<uint8_t>* in) { init(in); }
void init(stream<uint8_t>* in) {
_in = in;
generic_block<HRPTDemux>::registerInput(_in);
generic_block<HRPTDemux>::registerOutput(&telemOut);
generic_block<HRPTDemux>::registerOutput(&BISMout);
generic_block<HRPTDemux>::registerOutput(&SSPDOut);
generic_block<HRPTDemux>::registerOutput(&MTVZAOut);
generic_block<HRPTDemux>::registerOutput(&MSUMROut);
generic_block<HRPTDemux>::_block_init = true;
}
void setInput(stream<uint8_t>* in) {
assert(generic_block<HRPTDemux>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<HRPTDemux>::ctrlMtx);
generic_block<HRPTDemux>::tempStop();
generic_block<HRPTDemux>::unregisterInput(_in);
_in = in;
generic_block<HRPTDemux>::registerInput(_in);
generic_block<HRPTDemux>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
for (int i = 0; i < 4; i++) {
memcpy(telemOut.writeBuf + (i * 2), _in->readBuf + 4 + (i * 256), 2);
memcpy(BISMout.writeBuf + (i * 4), _in->readBuf + 4 + (i * 256) + 2, 4);
memcpy(SSPDOut.writeBuf + (i * 4), _in->readBuf + 4 + (i * 256) + 6, 4);
memcpy(MTVZAOut.writeBuf + (i * 8), _in->readBuf + 4 + (i * 256) + 10, 8);
memcpy(MSUMROut.writeBuf + (i * 238), _in->readBuf + 4 + (i * 256) + 18, (i == 3) ? 234 : 238);
}
if (!telemOut.swap(8)) { return -1; }
if (!BISMout.swap(16)) { return -1; }
if (!SSPDOut.swap(16)) { return -1; }
if (!MTVZAOut.swap(32)) { return -1; }
if (!MSUMROut.swap(948)) { return -1; }
_in->flush();
return count;
}
stream<uint8_t> telemOut;
stream<uint8_t> BISMout;
stream<uint8_t> SSPDOut;
stream<uint8_t> MTVZAOut;
stream<uint8_t> MSUMROut;
private:
stream<uint8_t>* _in;
};
}
}

77
core/src/dsp/meteor/msumr.h
Wyświetl plik

@ -1,77 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/utils/bitstream.h>
namespace dsp {
namespace meteor {
const uint64_t MSUMR_SYNC_WORD = 0x0218A7A392DD9ABF;
const uint8_t MSUMR_SYNC_BYTES[8] = { 0x02, 0x18, 0xA7, 0xA3, 0x92, 0xDD, 0x9A, 0xBF };
class MSUMRDemux : public generic_block<MSUMRDemux> {
public:
MSUMRDemux() {}
MSUMRDemux(stream<uint8_t>* in) { init(in); }
void init(stream<uint8_t>* in) {
_in = in;
generic_block<MSUMRDemux>::registerInput(_in);
generic_block<MSUMRDemux>::registerOutput(&msumr1Out);
generic_block<MSUMRDemux>::registerOutput(&msumr2Out);
generic_block<MSUMRDemux>::registerOutput(&msumr3Out);
generic_block<MSUMRDemux>::registerOutput(&msumr4Out);
generic_block<MSUMRDemux>::registerOutput(&msumr5Out);
generic_block<MSUMRDemux>::registerOutput(&msumr6Out);
generic_block<MSUMRDemux>::_block_init = true;
}
void setInput(stream<uint8_t>* in) {
assert(generic_block<MSUMRDemux>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<MSUMRDemux>::ctrlMtx);
generic_block<MSUMRDemux>::tempStop();
generic_block<MSUMRDemux>::unregisterInput(_in);
_in = in;
generic_block<MSUMRDemux>::registerInput(_in);
generic_block<MSUMRDemux>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
int pixels = 0;
for (int i = 0; i < 11790; i += 30) {
for (int j = 0; j < 4; j++) {
msumr1Out.writeBuf[pixels + j] = (uint16_t)readBits((50 * 8) + (i * 8) + (j * 10), 10, _in->readBuf);
msumr2Out.writeBuf[pixels + j] = (uint16_t)readBits((50 * 8) + (i * 8) + (j * 10) + (40 * 1), 10, _in->readBuf);
msumr3Out.writeBuf[pixels + j] = (uint16_t)readBits((50 * 8) + (i * 8) + (j * 10) + (40 * 2), 10, _in->readBuf);
msumr4Out.writeBuf[pixels + j] = (uint16_t)readBits((50 * 8) + (i * 8) + (j * 10) + (40 * 3), 10, _in->readBuf);
msumr5Out.writeBuf[pixels + j] = (uint16_t)readBits((50 * 8) + (i * 8) + (j * 10) + (40 * 4), 10, _in->readBuf);
msumr6Out.writeBuf[pixels + j] = (uint16_t)readBits((50 * 8) + (i * 8) + (j * 10) + (40 * 5), 10, _in->readBuf);
}
pixels += 4;
}
if (!msumr1Out.swap(1572)) { return -1; }
if (!msumr2Out.swap(1572)) { return -1; }
if (!msumr3Out.swap(1572)) { return -1; }
if (!msumr4Out.swap(1572)) { return -1; }
if (!msumr5Out.swap(1572)) { return -1; }
if (!msumr6Out.swap(1572)) { return -1; }
_in->flush();
return count;
}
stream<uint16_t> msumr1Out;
stream<uint16_t> msumr2Out;
stream<uint16_t> msumr3Out;
stream<uint16_t> msumr4Out;
stream<uint16_t> msumr5Out;
stream<uint16_t> msumr6Out;
private:
stream<uint8_t>* _in;
};
}
}

110
core/src/dsp/noaa/hrpt.h
Wyświetl plik

@ -1,110 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/utils/bitstream.h>
namespace dsp {
namespace noaa {
inline uint16_t HRPTReadWord(int offset, uint8_t* buffer) {
return (uint16_t)readBits(offset * 10, 10, buffer);
}
const uint8_t HRPTSyncWord[] = {
1, 0, 1, 0, 0, 0, 0, 1, 0, 0,
0, 1, 0, 1, 1, 0, 1, 1, 1, 1,
1, 1, 0, 1, 0, 1, 1, 1, 0, 0,
0, 1, 1, 0, 0, 1, 1, 1, 0, 1,
1, 0, 0, 0, 0, 0, 1, 1, 1, 1,
0, 0, 1, 0, 0, 1, 0, 1, 0, 1
};
class HRPTDemux : public generic_block<HRPTDemux> {
public:
HRPTDemux() {}
HRPTDemux(stream<uint8_t>* in) { init(in); }
void init(stream<uint8_t>* in) {
_in = in;
generic_block<HRPTDemux>::registerInput(_in);
generic_block<HRPTDemux>::registerOutput(&AVHRRChan1Out);
generic_block<HRPTDemux>::registerOutput(&AVHRRChan2Out);
generic_block<HRPTDemux>::registerOutput(&AVHRRChan3Out);
generic_block<HRPTDemux>::registerOutput(&AVHRRChan4Out);
generic_block<HRPTDemux>::registerOutput(&AVHRRChan5Out);
generic_block<HRPTDemux>::_block_init = true;
}
void setInput(stream<uint8_t>* in) {
assert(generic_block<HRPTDemux>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<HRPTDemux>::ctrlMtx);
generic_block<HRPTDemux>::tempStop();
generic_block<HRPTDemux>::unregisterInput(_in);
_in = in;
generic_block<HRPTDemux>::registerInput(_in);
generic_block<HRPTDemux>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
int minFrame = readBits(61, 2, _in->readBuf);
// If GAC frame, reject
if (minFrame == 0) {
_in->flush();
return count;
}
// Extract TIP frames if present
if (minFrame == 1) {
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 104; j++) {
TIPOut.writeBuf[j] = (HRPTReadWord(103 + (i * 104) + j, _in->readBuf) >> 2) & 0xFF;
}
if (!TIPOut.swap(104)) { return -1; };
}
}
// Exctact AIP otherwise
else if (minFrame == 3) {
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 104; j++) {
AIPOut.writeBuf[j] = (HRPTReadWord(103 + (i * 104) + j, _in->readBuf) >> 2) & 0xFF;
}
if (!AIPOut.swap(104)) { return -1; };
}
}
// Extract AVHRR data
for (int i = 0; i < 2048; i++) {
AVHRRChan1Out.writeBuf[i] = HRPTReadWord(750 + (i * 5), _in->readBuf);
AVHRRChan2Out.writeBuf[i] = HRPTReadWord(750 + (i * 5) + 1, _in->readBuf);
AVHRRChan3Out.writeBuf[i] = HRPTReadWord(750 + (i * 5) + 2, _in->readBuf);
AVHRRChan4Out.writeBuf[i] = HRPTReadWord(750 + (i * 5) + 3, _in->readBuf);
AVHRRChan5Out.writeBuf[i] = HRPTReadWord(750 + (i * 5) + 4, _in->readBuf);
}
if (!AVHRRChan1Out.swap(2048)) { return -1; };
if (!AVHRRChan2Out.swap(2048)) { return -1; };
if (!AVHRRChan3Out.swap(2048)) { return -1; };
if (!AVHRRChan4Out.swap(2048)) { return -1; };
if (!AVHRRChan5Out.swap(2048)) { return -1; };
_in->flush();
return count;
}
stream<uint8_t> TIPOut;
stream<uint8_t> AIPOut;
stream<uint16_t> AVHRRChan1Out;
stream<uint16_t> AVHRRChan2Out;
stream<uint16_t> AVHRRChan3Out;
stream<uint16_t> AVHRRChan4Out;
stream<uint16_t> AVHRRChan5Out;
private:
stream<uint8_t>* _in;
};
}
}

240
core/src/dsp/noaa/tip.h
Wyświetl plik

@ -1,240 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/utils/bitstream.h>
namespace dsp {
namespace noaa {
class TIPDemux : public generic_block<TIPDemux> {
public:
TIPDemux() {}
TIPDemux(stream<uint8_t>* in) { init(in); }
void init(stream<uint8_t>* in) {
_in = in;
generic_block<TIPDemux>::registerInput(_in);
generic_block<TIPDemux>::registerOutput(&HIRSOut);
generic_block<TIPDemux>::registerOutput(&SEMOut);
generic_block<TIPDemux>::registerOutput(&DCSOut);
generic_block<TIPDemux>::registerOutput(&SBUVOut);
generic_block<TIPDemux>::_block_init = true;
}
void setInput(stream<uint8_t>* in) {
assert(generic_block<TIPDemux>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<TIPDemux>::ctrlMtx);
generic_block<TIPDemux>::tempStop();
generic_block<TIPDemux>::unregisterInput(_in);
_in = in;
generic_block<TIPDemux>::registerInput(_in);
generic_block<TIPDemux>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
// Extract HIRS
HIRSOut.writeBuf[0] = _in->readBuf[16];
HIRSOut.writeBuf[1] = _in->readBuf[17];
HIRSOut.writeBuf[2] = _in->readBuf[22];
HIRSOut.writeBuf[3] = _in->readBuf[23];
HIRSOut.writeBuf[4] = _in->readBuf[26];
HIRSOut.writeBuf[5] = _in->readBuf[27];
HIRSOut.writeBuf[6] = _in->readBuf[30];
HIRSOut.writeBuf[7] = _in->readBuf[31];
HIRSOut.writeBuf[8] = _in->readBuf[34];
HIRSOut.writeBuf[9] = _in->readBuf[35];
HIRSOut.writeBuf[10] = _in->readBuf[38];
HIRSOut.writeBuf[11] = _in->readBuf[39];
HIRSOut.writeBuf[12] = _in->readBuf[42];
HIRSOut.writeBuf[13] = _in->readBuf[43];
HIRSOut.writeBuf[14] = _in->readBuf[54];
HIRSOut.writeBuf[15] = _in->readBuf[55];
HIRSOut.writeBuf[16] = _in->readBuf[58];
HIRSOut.writeBuf[17] = _in->readBuf[59];
HIRSOut.writeBuf[18] = _in->readBuf[62];
HIRSOut.writeBuf[19] = _in->readBuf[63];
HIRSOut.writeBuf[20] = _in->readBuf[66];
HIRSOut.writeBuf[21] = _in->readBuf[67];
HIRSOut.writeBuf[22] = _in->readBuf[70];
HIRSOut.writeBuf[23] = _in->readBuf[71];
HIRSOut.writeBuf[24] = _in->readBuf[74];
HIRSOut.writeBuf[25] = _in->readBuf[75];
HIRSOut.writeBuf[26] = _in->readBuf[78];
HIRSOut.writeBuf[27] = _in->readBuf[79];
HIRSOut.writeBuf[28] = _in->readBuf[82];
HIRSOut.writeBuf[29] = _in->readBuf[83];
HIRSOut.writeBuf[30] = _in->readBuf[84];
HIRSOut.writeBuf[31] = _in->readBuf[85];
HIRSOut.writeBuf[32] = _in->readBuf[88];
HIRSOut.writeBuf[33] = _in->readBuf[89];
HIRSOut.writeBuf[34] = _in->readBuf[92];
HIRSOut.writeBuf[35] = _in->readBuf[93];
if (!HIRSOut.swap(36)) { return -1; };
// Extract SEM
SEMOut.writeBuf[0] = _in->readBuf[20];
SEMOut.writeBuf[1] = _in->readBuf[21];
if (!SEMOut.swap(2)) { return -1; };
// Extract DCS
DCSOut.writeBuf[0] = _in->readBuf[18];
DCSOut.writeBuf[1] = _in->readBuf[19];
DCSOut.writeBuf[2] = _in->readBuf[24];
DCSOut.writeBuf[3] = _in->readBuf[25];
DCSOut.writeBuf[4] = _in->readBuf[28];
DCSOut.writeBuf[5] = _in->readBuf[29];
DCSOut.writeBuf[6] = _in->readBuf[32];
DCSOut.writeBuf[7] = _in->readBuf[33];
DCSOut.writeBuf[8] = _in->readBuf[40];
DCSOut.writeBuf[9] = _in->readBuf[41];
DCSOut.writeBuf[10] = _in->readBuf[44];
DCSOut.writeBuf[11] = _in->readBuf[45];
DCSOut.writeBuf[12] = _in->readBuf[52];
DCSOut.writeBuf[13] = _in->readBuf[53];
DCSOut.writeBuf[14] = _in->readBuf[56];
DCSOut.writeBuf[15] = _in->readBuf[57];
DCSOut.writeBuf[16] = _in->readBuf[60];
DCSOut.writeBuf[17] = _in->readBuf[61];
DCSOut.writeBuf[18] = _in->readBuf[64];
DCSOut.writeBuf[19] = _in->readBuf[65];
DCSOut.writeBuf[20] = _in->readBuf[68];
DCSOut.writeBuf[21] = _in->readBuf[69];
DCSOut.writeBuf[22] = _in->readBuf[72];
DCSOut.writeBuf[23] = _in->readBuf[73];
DCSOut.writeBuf[24] = _in->readBuf[76];
DCSOut.writeBuf[25] = _in->readBuf[77];
DCSOut.writeBuf[26] = _in->readBuf[86];
DCSOut.writeBuf[27] = _in->readBuf[87];
DCSOut.writeBuf[28] = _in->readBuf[90];
DCSOut.writeBuf[29] = _in->readBuf[91];
DCSOut.writeBuf[30] = _in->readBuf[94];
DCSOut.writeBuf[31] = _in->readBuf[95];
if (!DCSOut.swap(32)) { return -1; };
// Extract SBUV
SBUVOut.writeBuf[0] = _in->readBuf[36];
SBUVOut.writeBuf[1] = _in->readBuf[37];
SBUVOut.writeBuf[2] = _in->readBuf[80];
SBUVOut.writeBuf[3] = _in->readBuf[81];
if (!SBUVOut.swap(4)) { return -1; };
_in->flush();
return count;
}
stream<uint8_t> HIRSOut;
stream<uint8_t> SEMOut;
stream<uint8_t> DCSOut;
stream<uint8_t> SBUVOut;
private:
stream<uint8_t>* _in;
};
inline uint16_t HIRSSignedToUnsigned(uint16_t n) {
return (n & 0x1000) ? (0x1000 + (n & 0xFFF)) : (0xFFF - (n & 0xFFF));
}
class HIRSDemux : public generic_block<HIRSDemux> {
public:
HIRSDemux() {}
HIRSDemux(stream<uint8_t>* in) { init(in); }
void init(stream<uint8_t>* in) {
_in = in;
generic_block<HIRSDemux>::registerInput(_in);
for (int i = 0; i < 20; i++) {
generic_block<HIRSDemux>::registerOutput(&radChannels[i]);
}
// Clear buffers
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 56; j++) { radChannels[i].writeBuf[j] = 0xFFF; }
}
}
void setInput(stream<uint8_t>* in) {
std::lock_guard<std::mutex> lck(generic_block<HIRSDemux>::ctrlMtx);
generic_block<HIRSDemux>::tempStop();
generic_block<HIRSDemux>::unregisterInput(_in);
_in = in;
generic_block<HIRSDemux>::registerInput(_in);
generic_block<HIRSDemux>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
int element = readBits(19, 6, _in->readBuf);
// If we've skipped or are on a non image element and there's data available, send it
if ((element < lastElement || element > 55) && newImageData) {
newImageData = false;
for (int i = 0; i < 20; i++) {
if (!radChannels[i].swap(56)) { return -1; }
}
// Clear buffers
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 56; j++) { radChannels[i].writeBuf[j] = 0xFFF; }
}
}
lastElement = element;
// If data is part of a line, save it
if (element <= 55) {
newImageData = true;
radChannels[0].writeBuf[element] = HIRSSignedToUnsigned(readBits(26, 13, _in->readBuf));
radChannels[1].writeBuf[element] = HIRSSignedToUnsigned(readBits(52, 13, _in->readBuf));
radChannels[2].writeBuf[element] = HIRSSignedToUnsigned(readBits(65, 13, _in->readBuf));
radChannels[3].writeBuf[element] = HIRSSignedToUnsigned(readBits(91, 13, _in->readBuf));
radChannels[4].writeBuf[element] = HIRSSignedToUnsigned(readBits(221, 13, _in->readBuf));
radChannels[5].writeBuf[element] = HIRSSignedToUnsigned(readBits(208, 13, _in->readBuf));
radChannels[6].writeBuf[element] = HIRSSignedToUnsigned(readBits(143, 13, _in->readBuf));
radChannels[7].writeBuf[element] = HIRSSignedToUnsigned(readBits(156, 13, _in->readBuf));
radChannels[8].writeBuf[element] = HIRSSignedToUnsigned(readBits(273, 13, _in->readBuf));
radChannels[9].writeBuf[element] = HIRSSignedToUnsigned(readBits(182, 13, _in->readBuf));
radChannels[10].writeBuf[element] = HIRSSignedToUnsigned(readBits(119, 13, _in->readBuf));
radChannels[11].writeBuf[element] = HIRSSignedToUnsigned(readBits(247, 13, _in->readBuf));
radChannels[12].writeBuf[element] = HIRSSignedToUnsigned(readBits(78, 13, _in->readBuf));
radChannels[13].writeBuf[element] = HIRSSignedToUnsigned(readBits(195, 13, _in->readBuf));
radChannels[14].writeBuf[element] = HIRSSignedToUnsigned(readBits(234, 13, _in->readBuf));
radChannels[15].writeBuf[element] = HIRSSignedToUnsigned(readBits(260, 13, _in->readBuf));
radChannels[16].writeBuf[element] = HIRSSignedToUnsigned(readBits(39, 13, _in->readBuf));
radChannels[17].writeBuf[element] = HIRSSignedToUnsigned(readBits(104, 13, _in->readBuf));
radChannels[18].writeBuf[element] = HIRSSignedToUnsigned(readBits(130, 13, _in->readBuf));
radChannels[19].writeBuf[element] = HIRSSignedToUnsigned(readBits(169, 13, _in->readBuf));
}
// If we are writing the last pixel of a line, send it already
if (element == 55) {
newImageData = false;
for (int i = 0; i < 20; i++) {
if (!radChannels[i].swap(56)) { return -1; }
}
// Clear buffers
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 56; j++) { radChannels[i].writeBuf[j] = 0xFFF; }
}
}
_in->flush();
return count;
}
stream<uint16_t> radChannels[20];
private:
stream<uint8_t>* _in;
int lastElement = 0;
bool newImageData = false;
};
}
}

462
core/src/dsp/noise_reduction.h
Wyświetl plik

@ -1,462 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/utils/window_functions.h>
#include <fftw3.h>
#define NR_TAP_COUNT 64
namespace dsp {
class FMIFNoiseReduction : public generic_block<FMIFNoiseReduction> {
public:
FMIFNoiseReduction() {}
FMIFNoiseReduction(stream<complex_t>* in, int tapCount) { init(in, tapCount); }
~FMIFNoiseReduction() {
if (!generic_block<FMIFNoiseReduction>::_block_init) { return; }
generic_block<FMIFNoiseReduction>::stop();
fftwf_destroy_plan(forwardPlan);
fftwf_destroy_plan(backwardPlan);
fftwf_free(delay);
fftwf_free(fft_in);
fftwf_free(fft_window);
fftwf_free(amp_buf);
fftwf_free(fft_cout);
fftwf_free(fft_cin);
fftwf_free(fft_fcout);
}
void init(stream<complex_t>* in, int tapCount) {
_in = in;
_tapCount = tapCount;
delay = (complex_t*)fftwf_malloc(sizeof(complex_t) * STREAM_BUFFER_SIZE);
fft_in = (complex_t*)fftwf_malloc(sizeof(complex_t) * _tapCount);
fft_window = (float*)fftwf_malloc(sizeof(float) * _tapCount);
amp_buf = (float*)fftwf_malloc(sizeof(float) * _tapCount);
fft_cout = (complex_t*)fftwf_malloc(sizeof(complex_t) * _tapCount);
fft_cin = (complex_t*)fftwf_malloc(sizeof(complex_t) * _tapCount);
fft_fcout = (complex_t*)fftwf_malloc(sizeof(complex_t) * _tapCount);
delay_start = &delay[_tapCount];
memset(delay, 0, sizeof(complex_t) * STREAM_BUFFER_SIZE);
memset(fft_in, 0, sizeof(complex_t) * _tapCount);
memset(amp_buf, 0, sizeof(float) * _tapCount);
memset(fft_cout, 0, sizeof(complex_t) * _tapCount);
memset(fft_cin, 0, sizeof(complex_t) * _tapCount);
memset(fft_fcout, 0, sizeof(complex_t) * _tapCount);
for (int i = 0; i < _tapCount; i++) {
fft_window[i] = window_function::blackman(i, _tapCount - 1);
}
forwardPlan = fftwf_plan_dft_1d(_tapCount, (fftwf_complex*)fft_in, (fftwf_complex*)fft_cout, FFTW_FORWARD, FFTW_ESTIMATE);
backwardPlan = fftwf_plan_dft_1d(_tapCount, (fftwf_complex*)fft_cin, (fftwf_complex*)fft_fcout, FFTW_BACKWARD, FFTW_ESTIMATE);
generic_block<FMIFNoiseReduction>::registerInput(_in);
generic_block<FMIFNoiseReduction>::registerOutput(&out);
generic_block<FMIFNoiseReduction>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<FMIFNoiseReduction>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FMIFNoiseReduction>::ctrlMtx);
generic_block<FMIFNoiseReduction>::tempStop();
generic_block<FMIFNoiseReduction>::unregisterInput(_in);
_in = in;
generic_block<FMIFNoiseReduction>::registerInput(_in);
generic_block<FMIFNoiseReduction>::tempStart();
}
void setTapCount(int tapCount) {
assert(generic_block<FMIFNoiseReduction>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FMIFNoiseReduction>::ctrlMtx);
generic_block<FMIFNoiseReduction>::tempStop();
generic_block<FMIFNoiseReduction>::unregisterInput(_in);
_tapCount = tapCount;
fftwf_destroy_plan(forwardPlan);
fftwf_destroy_plan(backwardPlan);
fftwf_free(delay);
fftwf_free(fft_in);
fftwf_free(fft_window);
fftwf_free(amp_buf);
fftwf_free(fft_cout);
fftwf_free(fft_cin);
fftwf_free(fft_fcout);
delay = (complex_t*)fftwf_malloc(sizeof(complex_t) * STREAM_BUFFER_SIZE);
fft_in = (complex_t*)fftwf_malloc(sizeof(complex_t) * _tapCount);
fft_window = (float*)fftwf_malloc(sizeof(float) * _tapCount);
amp_buf = (float*)fftwf_malloc(sizeof(float) * _tapCount);
fft_cout = (complex_t*)fftwf_malloc(sizeof(complex_t) * _tapCount);
fft_cin = (complex_t*)fftwf_malloc(sizeof(complex_t) * _tapCount);
fft_fcout = (complex_t*)fftwf_malloc(sizeof(complex_t) * _tapCount);
delay_start = &delay[_tapCount];
memset(delay, 0, sizeof(complex_t) * STREAM_BUFFER_SIZE);
memset(fft_in, 0, sizeof(complex_t) * _tapCount);
memset(amp_buf, 0, sizeof(float) * _tapCount);
memset(fft_cout, 0, sizeof(complex_t) * _tapCount);
memset(fft_cin, 0, sizeof(complex_t) * _tapCount);
memset(fft_fcout, 0, sizeof(complex_t) * _tapCount);
for (int i = 0; i < _tapCount; i++) {
fft_window[i] = window_function::blackman(i, _tapCount - 1);
}
forwardPlan = fftwf_plan_dft_1d(_tapCount, (fftwf_complex*)fft_in, (fftwf_complex*)fft_cout, FFTW_FORWARD, FFTW_ESTIMATE);
backwardPlan = fftwf_plan_dft_1d(_tapCount, (fftwf_complex*)fft_cin, (fftwf_complex*)fft_fcout, FFTW_BACKWARD, FFTW_ESTIMATE);
spdlog::info("FM IF Noise reduction set to {0} taps", _tapCount);
generic_block<FMIFNoiseReduction>::registerInput(_in);
generic_block<FMIFNoiseReduction>::tempStart();
}
void setLevel(float level) {
_level = powf(10.0f, level / 10.0f);
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
// Bypass
if (!bypass) {
memcpy(out.writeBuf, _in->readBuf, count * sizeof(complex_t));
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
// Write to delay buffer
memcpy(delay_start, _in->readBuf, count * sizeof(complex_t));
uint32_t idx = 0;
float actLevel = 0;
// Iterate the FFT
for (int i = 0; i < count; i++) {
// Apply windows
volk_32fc_32f_multiply_32fc((lv_32fc_t*)fft_in, (lv_32fc_t*)&delay[i], fft_window, _tapCount);
// Do forward FFT
fftwf_execute(forwardPlan);
// Process bins here
volk_32fc_magnitude_32f(amp_buf, (lv_32fc_t*)fft_cout, _tapCount);
volk_32f_index_max_32u(&idx, amp_buf, _tapCount);
// Keep only the bin of highest amplitude
fft_cin[idx] = fft_cout[idx];
// Do reverse FFT and get first element
fftwf_execute(backwardPlan);
out.writeBuf[i] = fft_fcout[_tapCount / 2];
// Reset the input buffer
fft_cin[idx] = { 0, 0 };
}
volk_32f_s32f_multiply_32f((float*)out.writeBuf, (float*)out.writeBuf, 1.0f / (float)_tapCount, count * 2);
// Copy last values to delay
memmove(delay, &delay[count], _tapCount * sizeof(complex_t));
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
bool bypass = true;
stream<complex_t> out;
float _level = 0.0f;
private:
stream<complex_t>* _in;
fftwf_plan forwardPlan;
fftwf_plan backwardPlan;
complex_t* delay;
complex_t* fft_in;
float* fft_window;
float* amp_buf;
complex_t* delay_start;
complex_t* fft_cout;
complex_t* fft_cin;
complex_t* fft_fcout;
int _tapCount;
};
class FFTNoiseReduction : public generic_block<FFTNoiseReduction> {
public:
FFTNoiseReduction() {}
FFTNoiseReduction(stream<float>* in) { init(in); }
~FFTNoiseReduction() {
if (!generic_block<FFTNoiseReduction>::_block_init) { return; }
generic_block<FFTNoiseReduction>::stop();
fftwf_destroy_plan(forwardPlan);
fftwf_destroy_plan(backwardPlan);
fftwf_free(delay);
fftwf_free(fft_in);
fftwf_free(fft_window);
fftwf_free(amp_buf);
fftwf_free(fft_cout);
fftwf_free(fft_fout);
}
void init(stream<float>* in) {
_in = in;
delay = (float*)fftwf_malloc(sizeof(float) * STREAM_BUFFER_SIZE);
fft_in = (float*)fftwf_malloc(sizeof(float) * NR_TAP_COUNT);
fft_window = (float*)fftwf_malloc(sizeof(float) * NR_TAP_COUNT);
amp_buf = (float*)fftwf_malloc(sizeof(float) * NR_TAP_COUNT);
fft_cout = (complex_t*)fftwf_malloc(sizeof(complex_t) * NR_TAP_COUNT);
fft_fout = (float*)fftwf_malloc(sizeof(float) * NR_TAP_COUNT);
delay_start = &delay[NR_TAP_COUNT];
memset(delay, 0, sizeof(float) * STREAM_BUFFER_SIZE);
memset(fft_in, 0, sizeof(float) * NR_TAP_COUNT);
memset(amp_buf, 0, sizeof(float) * NR_TAP_COUNT);
memset(fft_cout, 0, sizeof(complex_t) * NR_TAP_COUNT);
memset(fft_fout, 0, sizeof(float) * NR_TAP_COUNT);
for (int i = 0; i < NR_TAP_COUNT; i++) {
fft_window[i] = window_function::blackman(i, NR_TAP_COUNT - 1);
}
forwardPlan = fftwf_plan_dft_r2c_1d(NR_TAP_COUNT, fft_in, (fftwf_complex*)fft_cout, FFTW_ESTIMATE);
backwardPlan = fftwf_plan_dft_c2r_1d(NR_TAP_COUNT, (fftwf_complex*)fft_cout, fft_fout, FFTW_ESTIMATE);
generic_block<FFTNoiseReduction>::registerInput(_in);
generic_block<FFTNoiseReduction>::registerOutput(&out);
generic_block<FFTNoiseReduction>::_block_init = true;
}
void setInput(stream<float>* in) {
assert(generic_block<FFTNoiseReduction>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FFTNoiseReduction>::ctrlMtx);
generic_block<FFTNoiseReduction>::tempStop();
generic_block<FFTNoiseReduction>::unregisterInput(_in);
_in = in;
generic_block<FFTNoiseReduction>::registerInput(_in);
generic_block<FFTNoiseReduction>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
// Bypass
if (!bypass) {
memcpy(out.writeBuf, _in->readBuf, count * sizeof(float));
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
// Write to delay buffer
memcpy(delay_start, _in->readBuf, count * sizeof(float));
// Iterate the FFT
for (int i = 0; i < count; i++) {
// Apply windows
volk_32f_x2_multiply_32f(fft_in, &delay[i], fft_window, NR_TAP_COUNT);
// Do forward FFT
fftwf_execute(forwardPlan);
// Process bins here
volk_32fc_magnitude_32f(amp_buf, (lv_32fc_t*)fft_cout, NR_TAP_COUNT / 2);
for (int j = 1; j < NR_TAP_COUNT / 2; j++) {
if (log10f(amp_buf[0]) < level) {
fft_cout[j] = { 0, 0 };
}
}
// Do reverse FFT and get first element
fftwf_execute(backwardPlan);
out.writeBuf[i] = fft_fout[NR_TAP_COUNT / 2];
}
volk_32f_s32f_multiply_32f(out.writeBuf, out.writeBuf, 1.0f / (float)NR_TAP_COUNT, count);
// Copy last values to delay
memmove(delay, &delay[count], NR_TAP_COUNT * sizeof(float));
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
bool bypass = true;
stream<float> out;
float level = 0.0f;
private:
stream<float>* _in;
fftwf_plan forwardPlan;
fftwf_plan backwardPlan;
float* delay;
float* fft_in;
float* fft_window;
float* amp_buf;
float* delay_start;
complex_t* fft_cout;
float* fft_fout;
};
class NoiseBlanker : public generic_block<NoiseBlanker> {
public:
NoiseBlanker() {}
NoiseBlanker(stream<complex_t>* in, float level) { init(in, level); }
~NoiseBlanker() {
if (!generic_block<NoiseBlanker>::_block_init) { return; }
generic_block<NoiseBlanker>::stop();
volk_free(ampBuf);
}
void init(stream<complex_t>* in, float level) {
_in = in;
_level = powf(10.0f, level / 10.0f);
;
ampBuf = (float*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(float), volk_get_alignment());
generic_block<NoiseBlanker>::registerInput(_in);
generic_block<NoiseBlanker>::registerOutput(&out);
generic_block<NoiseBlanker>::_block_init = true;
}
void setLevel(float level) {
_level = powf(10.0f, level / 10.0f);
}
void setInput(stream<complex_t>* in) {
assert(generic_block<NoiseBlanker>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<NoiseBlanker>::ctrlMtx);
generic_block<NoiseBlanker>::tempStop();
generic_block<NoiseBlanker>::unregisterInput(_in);
_in = in;
generic_block<NoiseBlanker>::registerInput(_in);
generic_block<NoiseBlanker>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
// Get amplitudes
volk_32fc_magnitude_32f(ampBuf, (lv_32fc_t*)_in->readBuf, count);
// Hard limit the amplitude
complex_t inVal;
for (int i = 0; i < count; i++) {
inVal = _in->readBuf[i];
out.writeBuf[i] = (ampBuf[i] > _level) ? inVal * (_level / inVal.amplitude()) : inVal;
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
private:
float* ampBuf;
float _level;
stream<complex_t>* _in;
};
class NotchFilter : public generic_block<NotchFilter> {
public:
NotchFilter() {}
NotchFilter(stream<complex_t>* in, float rate, float offset, float sampleRate) { init(in, rate, offset, sampleRate); }
void init(stream<complex_t>* in, float rate, float offset, float sampleRate) {
_in = in;
correctionRate = rate;
_offset = offset;
_sampleRate = sampleRate;
phaseDelta = lv_cmake(std::cos((-_offset / _sampleRate) * 2.0f * FL_M_PI), std::sin((-_offset / _sampleRate) * 2.0f * FL_M_PI));
phaseDeltaConj = { phaseDelta.real(), -phaseDelta.imag() };
generic_block<NotchFilter>::registerInput(_in);
generic_block<NotchFilter>::registerOutput(&out);
generic_block<NotchFilter>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<NotchFilter>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<NotchFilter>::ctrlMtx);
generic_block<NotchFilter>::tempStop();
generic_block<NotchFilter>::unregisterInput(_in);
_in = in;
generic_block<NotchFilter>::registerInput(_in);
generic_block<NotchFilter>::tempStart();
}
void setCorrectionRate(float rate) {
correctionRate = rate;
}
void setOffset(float offset) {
_offset = offset;
phaseDelta = lv_cmake(std::cos((-_offset / _sampleRate) * 2.0f * FL_M_PI), std::sin((-_offset / _sampleRate) * 2.0f * FL_M_PI));
phaseDeltaConj = { phaseDelta.real(), -phaseDelta.imag() };
}
void setSampleRate(float sampleRate) {
_sampleRate = sampleRate;
phaseDelta = lv_cmake(std::cos((-_offset / _sampleRate) * 2.0f * FL_M_PI), std::sin((-_offset / _sampleRate) * 2.0f * FL_M_PI));
phaseDeltaConj = { phaseDelta.real(), -phaseDelta.imag() };
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32fc_s32fc_x2_rotator_32fc((lv_32fc_t*)_in->readBuf, (lv_32fc_t*)_in->readBuf, phaseDelta, &inPhase, count);
for (int i = 0; i < count; i++) {
out.writeBuf[i] = _in->readBuf[i] - offset;
offset = offset + (out.writeBuf[i] * correctionRate);
}
volk_32fc_s32fc_x2_rotator_32fc((lv_32fc_t*)out.writeBuf, (lv_32fc_t*)out.writeBuf, phaseDeltaConj, &outPhase, count);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
private:
stream<complex_t>* _in;
complex_t offset = { 0, 0 };
lv_32fc_t inPhase = { 1, 0 };
lv_32fc_t outPhase = { 4, 0 };
lv_32fc_t phaseDelta;
lv_32fc_t phaseDeltaConj;
float _offset;
float _sampleRate;
float correctionRate;
};
}

332
core/src/dsp/pll.h
Wyświetl plik

@ -1,332 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/interpolation_taps.h>
#include <math.h>
#include <dsp/utils/macros.h>
#include <dsp/math.h>
namespace dsp {
template <int ORDER>
class CostasLoop : public generic_block<CostasLoop<ORDER>> {
public:
CostasLoop() {}
CostasLoop(stream<complex_t>* in, float loopBandwidth) { init(in, loopBandwidth); }
void init(stream<complex_t>* in, float loopBandwidth) {
_in = in;
lastVCO.re = 1.0f;
lastVCO.im = 0.0f;
_loopBandwidth = loopBandwidth;
float dampningFactor = sqrtf(2.0f) / 2.0f;
float denominator = (1.0 + 2.0 * dampningFactor * _loopBandwidth + _loopBandwidth * _loopBandwidth);
_alpha = (4 * dampningFactor * _loopBandwidth) / denominator;
_beta = (4 * _loopBandwidth * _loopBandwidth) / denominator;
generic_block<CostasLoop<ORDER>>::registerInput(_in);
generic_block<CostasLoop<ORDER>>::registerOutput(&out);
generic_block<CostasLoop<ORDER>>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<CostasLoop<ORDER>>::_block_init);
generic_block<CostasLoop<ORDER>>::tempStop();
generic_block<CostasLoop<ORDER>>::unregisterInput(_in);
_in = in;
generic_block<CostasLoop<ORDER>>::registerInput(_in);
generic_block<CostasLoop<ORDER>>::tempStart();
}
void setLoopBandwidth(float loopBandwidth) {
assert(generic_block<CostasLoop<ORDER>>::_block_init);
generic_block<CostasLoop<ORDER>>::tempStop();
_loopBandwidth = loopBandwidth;
float dampningFactor = sqrtf(2.0f) / 2.0f;
float denominator = (1.0 + 2.0 * dampningFactor * _loopBandwidth + _loopBandwidth * _loopBandwidth);
_alpha = (4 * dampningFactor * _loopBandwidth) / denominator;
_beta = (4 * _loopBandwidth * _loopBandwidth) / denominator;
generic_block<CostasLoop<ORDER>>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
complex_t outVal;
float error;
for (int i = 0; i < count; i++) {
// Mix the VFO with the input to create the output value
outVal.re = (lastVCO.re * _in->readBuf[i].re) - (lastVCO.im * _in->readBuf[i].im);
outVal.im = (lastVCO.im * _in->readBuf[i].re) + (lastVCO.re * _in->readBuf[i].im);
out.writeBuf[i] = outVal;
// Calculate the phase error estimation
if constexpr (ORDER == 2) {
error = outVal.re * outVal.im;
}
if constexpr (ORDER == 4) {
error = (DSP_STEP(outVal.re) * outVal.im) - (DSP_STEP(outVal.im) * outVal.re);
}
if constexpr (ORDER == 8) {
// This is taken from GR, I have no idea how it works but it does...
const float K = (sqrtf(2.0) - 1);
if (fabsf(outVal.re) >= fabsf(outVal.im)) {
error = ((outVal.re > 0.0f ? 1.0f : -1.0f) * outVal.im -
(outVal.im > 0.0f ? 1.0f : -1.0f) * outVal.re * K);
}
else {
error = ((outVal.re > 0.0f ? 1.0f : -1.0f) * outVal.im * K -
(outVal.im > 0.0f ? 1.0f : -1.0f) * outVal.re);
}
}
if (error > 1.0f) { error = 1.0f; }
else if (error < -1.0f) {
error = -1.0f;
}
// Integrate frequency and clamp it
vcoFrequency += _beta * error;
if (vcoFrequency > 1.0f) { vcoFrequency = 1.0f; }
else if (vcoFrequency < -1.0f) {
vcoFrequency = -1.0f;
}
// Calculate new phase and wrap it
vcoPhase += vcoFrequency + (_alpha * error);
while (vcoPhase > (2.0f * FL_M_PI)) { vcoPhase -= (2.0f * FL_M_PI); }
while (vcoPhase < (-2.0f * FL_M_PI)) { vcoPhase += (2.0f * FL_M_PI); }
// Calculate output
lastVCO.re = cosf(-vcoPhase);
lastVCO.im = sinf(-vcoPhase);
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
private:
float _loopBandwidth = 1.0f;
float _alpha; // Integral coefficient
float _beta; // Proportional coefficient
float vcoFrequency = 0.0f;
float vcoPhase = 0.0f;
complex_t lastVCO;
stream<complex_t>* _in;
};
template <class T>
class CarrierTrackingPLL : public generic_block<CarrierTrackingPLL<T>> {
public:
CarrierTrackingPLL() {}
CarrierTrackingPLL(stream<complex_t>* in, float loopBandwidth) { init(in, loopBandwidth); }
void init(stream<complex_t>* in, float loopBandwidth) {
_in = in;
lastVCO.re = 1.0f;
lastVCO.im = 0.0f;
_loopBandwidth = loopBandwidth;
float dampningFactor = sqrtf(2.0f) / 2.0f;
float denominator = (1.0 + 2.0 * dampningFactor * _loopBandwidth + _loopBandwidth * _loopBandwidth);
_alpha = (4 * dampningFactor * _loopBandwidth) / denominator;
_beta = (4 * _loopBandwidth * _loopBandwidth) / denominator;
generic_block<CarrierTrackingPLL<T>>::registerInput(_in);
generic_block<CarrierTrackingPLL<T>>::registerOutput(&out);
generic_block<CarrierTrackingPLL<T>>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<CarrierTrackingPLL<T>>::_block_init);
generic_block<CarrierTrackingPLL<T>>::tempStop();
generic_block<CarrierTrackingPLL<T>>::unregisterInput(_in);
_in = in;
generic_block<CarrierTrackingPLL<T>>::registerInput(_in);
generic_block<CarrierTrackingPLL<T>>::tempStart();
}
void setLoopBandwidth(float loopBandwidth) {
assert(generic_block<CarrierTrackingPLL<T>>::_block_init);
generic_block<CarrierTrackingPLL<T>>::tempStop();
_loopBandwidth = loopBandwidth;
float dampningFactor = sqrtf(2.0f) / 2.0f;
float denominator = (1.0 + 2.0 * dampningFactor * _loopBandwidth + _loopBandwidth * _loopBandwidth);
_alpha = (4 * dampningFactor * _loopBandwidth) / denominator;
_beta = (4 * _loopBandwidth * _loopBandwidth) / denominator;
generic_block<CarrierTrackingPLL<T>>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
complex_t outVal;
float error;
for (int i = 0; i < count; i++) {
// Mix the VFO with the input to create the output value
outVal.re = (lastVCO.re * _in->readBuf[i].re) - ((-lastVCO.im) * _in->readBuf[i].im);
outVal.im = ((-lastVCO.im) * _in->readBuf[i].re) + (lastVCO.re * _in->readBuf[i].im);
if constexpr (std::is_same_v<T, float>) {
out.writeBuf[i] = outVal.fastPhase();
}
if constexpr (std::is_same_v<T, complex_t>) {
out.writeBuf[i] = outVal;
}
// Calculate the phase error estimation
// TODO: Figure out why fastPhase doesn't work
error = _in->readBuf[i].phase() - vcoPhase;
if (error > 3.1415926535f) { error -= 2.0f * 3.1415926535f; }
else if (error <= -3.1415926535f) {
error += 2.0f * 3.1415926535f;
}
// if (error > 1.0f) { error = 1.0f; }
// else if (error < -1.0f) { error = -1.0f; }
// Integrate frequency and clamp it
vcoFrequency += _beta * error;
if (vcoFrequency > 1.0f) { vcoFrequency = 1.0f; }
else if (vcoFrequency < -1.0f) {
vcoFrequency = -1.0f;
}
// Calculate new phase and wrap it
vcoPhase += vcoFrequency + (_alpha * error);
while (vcoPhase > (2.0f * FL_M_PI)) { vcoPhase -= (2.0f * FL_M_PI); }
while (vcoPhase < (-2.0f * FL_M_PI)) { vcoPhase += (2.0f * FL_M_PI); }
// Calculate output
lastVCO.re = cosf(vcoPhase);
lastVCO.im = sinf(vcoPhase);
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<T> out;
private:
float _loopBandwidth = 1.0f;
float _alpha; // Integral coefficient
float _beta; // Proportional coefficient
float vcoFrequency = 0.0f;
float vcoPhase = 0.0f;
complex_t lastVCO;
stream<complex_t>* _in;
};
class PLL : public generic_block<PLL> {
public:
PLL() {}
PLL(stream<complex_t>* in, float loopBandwidth) { init(in, loopBandwidth); }
void init(stream<complex_t>* in, float loopBandwidth) {
_in = in;
lastVCO.re = 1.0f;
lastVCO.im = 0.0f;
_loopBandwidth = loopBandwidth;
float dampningFactor = sqrtf(2.0f) / 2.0f;
float denominator = (1.0 + 2.0 * dampningFactor * _loopBandwidth + _loopBandwidth * _loopBandwidth);
_alpha = (4 * dampningFactor * _loopBandwidth) / denominator;
_beta = (4 * _loopBandwidth * _loopBandwidth) / denominator;
generic_block<PLL>::registerInput(_in);
generic_block<PLL>::registerOutput(&out);
generic_block<PLL>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<PLL>::_block_init);
generic_block<PLL>::tempStop();
generic_block<PLL>::unregisterInput(_in);
_in = in;
generic_block<PLL>::registerInput(_in);
generic_block<PLL>::tempStart();
}
void setLoopBandwidth(float loopBandwidth) {
assert(generic_block<PLL>::_block_init);
generic_block<PLL>::tempStop();
_loopBandwidth = loopBandwidth;
float dampningFactor = sqrtf(2.0f) / 2.0f;
float denominator = (1.0 + 2.0 * dampningFactor * _loopBandwidth + _loopBandwidth * _loopBandwidth);
_alpha = (4 * dampningFactor * _loopBandwidth) / denominator;
_beta = (4 * _loopBandwidth * _loopBandwidth) / denominator;
generic_block<PLL>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
complex_t outVal;
float error;
for (int i = 0; i < count; i++) {
out.writeBuf[i] = lastVCO;
// Calculate the phase error estimation
// TODO: Figure out why fastPhase doesn't work
error = _in->readBuf[i].phase() - vcoPhase;
if (error > 3.1415926535f) { error -= 2.0f * 3.1415926535f; }
else if (error <= -3.1415926535f) {
error += 2.0f * 3.1415926535f;
}
// Integrate frequency and clamp it
vcoFrequency += _beta * error;
if (vcoFrequency > 1.0f) { vcoFrequency = 1.0f; }
else if (vcoFrequency < -1.0f) {
vcoFrequency = -1.0f;
}
// Calculate new phase and wrap it
vcoPhase += vcoFrequency + (_alpha * error);
while (vcoPhase > (2.0f * FL_M_PI)) { vcoPhase -= (2.0f * FL_M_PI); }
while (vcoPhase < (-2.0f * FL_M_PI)) { vcoPhase += (2.0f * FL_M_PI); }
// Calculate output
lastVCO.re = cosf(vcoPhase);
lastVCO.im = sinf(vcoPhase);
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
private:
float _loopBandwidth = 1.0f;
float _alpha; // Integral coefficient
float _beta; // Proportional coefficient
float vcoFrequency = ((19000.0f / 250000.0f) * 2.0f * FL_M_PI);
float vcoPhase = 0.0f;
complex_t lastVCO;
stream<complex_t>* _in;
};
}

609
core/src/dsp/processing.h
Wyświetl plik

@ -1,609 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <volk/volk.h>
#include <spdlog/spdlog.h>
#include <string.h>
#include <stdint.h>
#include <dsp/math.h>
namespace dsp {
template <class T>
class FrequencyXlator : public generic_block<FrequencyXlator<T>> {
public:
FrequencyXlator() {}
FrequencyXlator(stream<complex_t>* in, float sampleRate, float freq) { init(in, sampleRate, freq); }
void init(stream<complex_t>* in, float sampleRate, float freq) {
_in = in;
_sampleRate = sampleRate;
_freq = freq;
phase = lv_cmake(1.0f, 0.0f);
phaseDelta = lv_cmake(std::cos((_freq / _sampleRate) * 2.0f * FL_M_PI), std::sin((_freq / _sampleRate) * 2.0f * FL_M_PI));
generic_block<FrequencyXlator<T>>::registerInput(_in);
generic_block<FrequencyXlator<T>>::registerOutput(&out);
generic_block<FrequencyXlator<T>>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<FrequencyXlator<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FrequencyXlator<T>>::ctrlMtx);
generic_block<FrequencyXlator<T>>::tempStop();
generic_block<FrequencyXlator<T>>::unregisterInput(_in);
_in = in;
generic_block<FrequencyXlator<T>>::registerInput(_in);
generic_block<FrequencyXlator<T>>::tempStart();
}
void setSampleRate(float sampleRate) {
assert(generic_block<FrequencyXlator<T>>::_block_init);
_sampleRate = sampleRate;
phaseDelta = lv_cmake(std::cos((_freq / _sampleRate) * 2.0f * FL_M_PI), std::sin((_freq / _sampleRate) * 2.0f * FL_M_PI));
}
float getSampleRate() {
assert(generic_block<FrequencyXlator<T>>::_block_init);
return _sampleRate;
}
void setFrequency(float freq) {
assert(generic_block<FrequencyXlator<T>>::_block_init);
_freq = freq;
phaseDelta = lv_cmake(std::cos((_freq / _sampleRate) * 2.0f * FL_M_PI), std::sin((_freq / _sampleRate) * 2.0f * FL_M_PI));
}
float getFrequency() {
assert(generic_block<FrequencyXlator<T>>::_block_init);
return _freq;
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
// TODO: Do float xlation
if constexpr (std::is_same_v<T, float>) {
spdlog::error("XLATOR NOT IMPLEMENTED FOR FLOAT");
}
if constexpr (std::is_same_v<T, complex_t>) {
volk_32fc_s32fc_x2_rotator_32fc((lv_32fc_t*)out.writeBuf, (lv_32fc_t*)_in->readBuf, phaseDelta, &phase, count);
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
private:
float _sampleRate;
float _freq;
lv_32fc_t phaseDelta;
lv_32fc_t phase;
stream<complex_t>* _in;
};
class AGC : public generic_block<AGC> {
public:
AGC() {}
AGC(stream<float>* in, float fallRate, float sampleRate) { init(in, fallRate, sampleRate); }
void init(stream<float>* in, float fallRate, float sampleRate) {
_in = in;
_sampleRate = sampleRate;
_fallRate = fallRate;
_CorrectedFallRate = _fallRate / _sampleRate;
generic_block<AGC>::registerInput(_in);
generic_block<AGC>::registerOutput(&out);
generic_block<AGC>::_block_init = true;
}
void setInput(stream<float>* in) {
assert(generic_block<AGC>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<AGC>::ctrlMtx);
generic_block<AGC>::tempStop();
generic_block<AGC>::unregisterInput(_in);
_in = in;
generic_block<AGC>::registerInput(_in);
generic_block<AGC>::tempStart();
}
void setSampleRate(float sampleRate) {
assert(generic_block<AGC>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<AGC>::ctrlMtx);
_sampleRate = sampleRate;
_CorrectedFallRate = _fallRate / _sampleRate;
}
void setFallRate(float fallRate) {
assert(generic_block<AGC>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<AGC>::ctrlMtx);
_fallRate = fallRate;
_CorrectedFallRate = _fallRate / _sampleRate;
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
level = pow(10, ((10.0f * log10f(level)) - (_CorrectedFallRate * count)) / 10.0f);
if (level < 10e-14) { level = 10e-14; }
float absVal;
for (int i = 0; i < count; i++) {
absVal = fabsf(_in->readBuf[i]);
if (absVal > level) { level = absVal; }
}
volk_32f_s32f_multiply_32f(out.writeBuf, _in->readBuf, 1.0f / level, count);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<float> out;
private:
float level = 0.0f;
float _fallRate;
float _CorrectedFallRate;
float _sampleRate;
stream<float>* _in;
};
class ComplexAGC : public generic_block<ComplexAGC> {
public:
ComplexAGC() {}
ComplexAGC(stream<complex_t>* in, float setPoint, float maxGain, float rate) { init(in, setPoint, maxGain, rate); }
void init(stream<complex_t>* in, float setPoint, float maxGain, float rate) {
_in = in;
_setPoint = setPoint;
_maxGain = maxGain;
_rate = rate;
generic_block<ComplexAGC>::registerInput(_in);
generic_block<ComplexAGC>::registerOutput(&out);
generic_block<ComplexAGC>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<ComplexAGC>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<ComplexAGC>::ctrlMtx);
generic_block<ComplexAGC>::tempStop();
generic_block<ComplexAGC>::unregisterInput(_in);
_in = in;
generic_block<ComplexAGC>::registerInput(_in);
generic_block<ComplexAGC>::tempStart();
}
void setSetPoint(float setPoint) {
assert(generic_block<ComplexAGC>::_block_init);
_setPoint = setPoint;
}
void setMaxGain(float maxGain) {
assert(generic_block<ComplexAGC>::_block_init);
_maxGain = maxGain;
}
void setRate(float rate) {
assert(generic_block<ComplexAGC>::_block_init);
_rate = rate;
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
dsp::complex_t val;
for (int i = 0; i < count; i++) {
val = _in->readBuf[i] * _gain;
out.writeBuf[i] = val;
_gain += (_setPoint - val.amplitude()) * _rate;
if (_gain > _maxGain) { _gain = _maxGain; }
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
private:
float _gain = 1.0f;
float _setPoint = 1.0f;
float _maxGain = 10e4;
float _rate = 10e-4;
stream<complex_t>* _in;
};
class DelayImag : public generic_block<DelayImag> {
public:
DelayImag() {}
DelayImag(stream<complex_t>* in) { init(in); }
void init(stream<complex_t>* in) {
_in = in;
generic_block<DelayImag>::registerInput(_in);
generic_block<DelayImag>::registerOutput(&out);
generic_block<DelayImag>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<DelayImag>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<DelayImag>::ctrlMtx);
generic_block<DelayImag>::tempStop();
generic_block<DelayImag>::unregisterInput(_in);
_in = in;
generic_block<DelayImag>::registerInput(_in);
generic_block<DelayImag>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
dsp::complex_t val;
for (int i = 0; i < count; i++) {
val = _in->readBuf[i];
out.writeBuf[i].re = val.re;
out.writeBuf[i].im = lastIm;
lastIm = val.im;
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
private:
float lastIm = 0.0f;
stream<complex_t>* _in;
};
template <class T>
class Volume : public generic_block<Volume<T>> {
public:
Volume() {}
Volume(stream<T>* in, float volume) { init(in, volume); }
void init(stream<T>* in, float volume) {
_in = in;
_volume = volume;
level = powf(_volume, 2);
generic_block<Volume<T>>::registerInput(_in);
generic_block<Volume<T>>::registerOutput(&out);
generic_block<Volume<T>>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<Volume<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Volume<T>>::ctrlMtx);
generic_block<Volume<T>>::tempStop();
generic_block<Volume<T>>::unregisterInput(_in);
_in = in;
generic_block<Volume<T>>::registerInput(_in);
generic_block<Volume<T>>::tempStart();
}
void setVolume(float volume) {
assert(generic_block<Volume<T>>::_block_init);
_volume = volume;
level = powf(_volume, 2);
}
float getVolume() {
assert(generic_block<Volume<T>>::_block_init);
return _volume;
}
void setMuted(bool muted) {
assert(generic_block<Volume<T>>::_block_init);
_muted = muted;
}
bool getMuted() {
assert(generic_block<Volume<T>>::_block_init);
return _muted;
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
if (_muted) {
if constexpr (std::is_same_v<T, stereo_t>) {
memset(out.writeBuf, 0, sizeof(stereo_t) * count);
}
else {
memset(out.writeBuf, 0, sizeof(float) * count);
}
}
else {
if constexpr (std::is_same_v<T, stereo_t>) {
volk_32f_s32f_multiply_32f((float*)out.writeBuf, (float*)_in->readBuf, level, count * 2);
}
else {
volk_32f_s32f_multiply_32f((float*)out.writeBuf, (float*)_in->readBuf, level, count);
}
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<T> out;
private:
float level = 1.0f;
float _volume = 1.0f;
bool _muted = false;
stream<T>* _in;
};
class Squelch : public generic_block<Squelch> {
public:
Squelch() {}
Squelch(stream<complex_t>* in, float level) { init(in, level); }
~Squelch() {
if (!generic_block<Squelch>::_block_init) { return; }
generic_block<Squelch>::stop();
delete[] normBuffer;
generic_block<Squelch>::_block_init = false;
}
void init(stream<complex_t>* in, float level) {
_in = in;
_level = level;
normBuffer = new float[STREAM_BUFFER_SIZE];
generic_block<Squelch>::registerInput(_in);
generic_block<Squelch>::registerOutput(&out);
generic_block<Squelch>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<Squelch>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Squelch>::ctrlMtx);
generic_block<Squelch>::tempStop();
generic_block<Squelch>::unregisterInput(_in);
_in = in;
generic_block<Squelch>::registerInput(_in);
generic_block<Squelch>::tempStart();
}
void setLevel(float level) {
assert(generic_block<Squelch>::_block_init);
_level = level;
}
float getLevel() {
assert(generic_block<Squelch>::_block_init);
return _level;
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
float sum;
volk_32fc_magnitude_32f(normBuffer, (lv_32fc_t*)_in->readBuf, count);
volk_32f_accumulator_s32f(&sum, normBuffer, count);
sum /= (float)count;
if (10.0f * log10f(sum) >= _level) {
memcpy(out.writeBuf, _in->readBuf, count * sizeof(complex_t));
}
else {
memset(out.writeBuf, 0, count * sizeof(complex_t));
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
private:
float* normBuffer;
float _level = -50.0f;
stream<complex_t>* _in;
};
template <class T>
class Packer : public generic_block<Packer<T>> {
public:
Packer() {}
Packer(stream<T>* in, int count) { init(in, count); }
void init(stream<T>* in, int count) {
_in = in;
samples = count;
generic_block<Packer<T>>::registerInput(_in);
generic_block<Packer<T>>::registerOutput(&out);
generic_block<Packer<T>>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<Packer<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Packer<T>>::ctrlMtx);
generic_block<Packer<T>>::tempStop();
generic_block<Packer<T>>::unregisterInput(_in);
_in = in;
generic_block<Packer<T>>::registerInput(_in);
generic_block<Packer<T>>::tempStart();
}
void setSampleCount(int count) {
assert(generic_block<Packer<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Packer<T>>::ctrlMtx);
generic_block<Packer<T>>::tempStop();
samples = count;
generic_block<Packer<T>>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) {
read = 0;
return -1;
}
for (int i = 0; i < count; i++) {
out.writeBuf[read++] = _in->readBuf[i];
if (read >= samples) {
read = 0;
if (!out.swap(samples)) {
_in->flush();
read = 0;
return -1;
}
}
}
_in->flush();
return count;
}
stream<T> out;
private:
int samples = 1;
int read = 0;
stream<T>* _in;
};
class Threshold : public generic_block<Threshold> {
public:
Threshold() {}
Threshold(stream<float>* in) { init(in); }
~Threshold() {
if (!generic_block<Threshold>::_block_init) { return; }
generic_block<Threshold>::stop();
delete[] normBuffer;
generic_block<Threshold>::_block_init = false;
}
void init(stream<float>* in) {
_in = in;
normBuffer = new float[STREAM_BUFFER_SIZE];
generic_block<Threshold>::registerInput(_in);
generic_block<Threshold>::registerOutput(&out);
generic_block<Threshold>::_block_init = true;
}
void setInput(stream<float>* in) {
assert(generic_block<Threshold>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Threshold>::ctrlMtx);
generic_block<Threshold>::tempStop();
generic_block<Threshold>::unregisterInput(_in);
_in = in;
generic_block<Threshold>::registerInput(_in);
generic_block<Threshold>::tempStart();
}
void setLevel(float level) {
assert(generic_block<Threshold>::_block_init);
_level = level;
}
float getLevel() {
assert(generic_block<Threshold>::_block_init);
return _level;
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
for (int i = 0; i < count; i++) {
out.writeBuf[i] = (_in->readBuf[i] > 0.0f);
}
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<uint8_t> out;
private:
float* normBuffer;
float _level = -50.0f;
stream<float>* _in;
};
class BFMPilotToStereo : public generic_block<BFMPilotToStereo> {
public:
BFMPilotToStereo() {}
BFMPilotToStereo(stream<complex_t>* in) { init(in); }
~BFMPilotToStereo() {
generic_block<BFMPilotToStereo>::stop();
delete[] buffer;
}
void init(stream<complex_t>* in) {
_in = in;
buffer = new complex_t[STREAM_BUFFER_SIZE];
generic_block<BFMPilotToStereo>::registerInput(_in);
generic_block<BFMPilotToStereo>::registerOutput(&out);
generic_block<BFMPilotToStereo>::_block_init = true;
}
void setInputs(stream<complex_t>* in) {
assert(generic_block<BFMPilotToStereo>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<BFMPilotToStereo>::ctrlMtx);
generic_block<BFMPilotToStereo>::tempStop();
generic_block<BFMPilotToStereo>::unregisterInput(_in);
_in = in;
generic_block<BFMPilotToStereo>::registerInput(_in);
generic_block<BFMPilotToStereo>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32fc_x2_multiply_32fc((lv_32fc_t*)buffer, (lv_32fc_t*)_in->readBuf, (lv_32fc_t*)_in->readBuf, count);
_in->flush();
volk_32fc_conjugate_32fc((lv_32fc_t*)out.writeBuf, (lv_32fc_t*)buffer, count);
if (!out.swap(count)) { return -1; }
return count;
}
stream<complex_t> out;
private:
stream<complex_t>* _in;
complex_t* buffer;
};
}

218
core/src/dsp/resampling.h
Wyświetl plik

@ -1,218 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/window.h>
#include <numeric>
#include <string.h>
#include <dsp/math.h>
namespace dsp {
template <class T>
class PolyphaseResampler : public generic_block<PolyphaseResampler<T>> {
public:
PolyphaseResampler() {}
PolyphaseResampler(stream<T>* in, dsp::filter_window::generic_window* window, float inSampleRate, float outSampleRate) { init(in, window, inSampleRate, outSampleRate); }
~PolyphaseResampler() {
if (!generic_block<PolyphaseResampler<T>>::_block_init) { return; }
generic_block<PolyphaseResampler<T>>::stop();
volk_free(buffer);
volk_free(taps);
freeTapPhases();
generic_block<PolyphaseResampler<T>>::_block_init = false;
}
void init(stream<T>* in, dsp::filter_window::generic_window* window, float inSampleRate, float outSampleRate) {
_in = in;
_window = window;
_inSampleRate = inSampleRate;
_outSampleRate = outSampleRate;
int _gcd = std::gcd((int)_inSampleRate, (int)_outSampleRate);
_interp = _outSampleRate / _gcd;
_decim = _inSampleRate / _gcd;
tapCount = _window->getTapCount();
taps = (float*)volk_malloc(tapCount * sizeof(float), volk_get_alignment());
_window->createTaps(taps, tapCount, _interp);
buildTapPhases();
buffer = (T*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(T) * 2, volk_get_alignment());
memset(buffer, 0, STREAM_BUFFER_SIZE * sizeof(T) * 2);
counter = 0;
offset = 0;
generic_block<PolyphaseResampler<T>>::registerInput(_in);
generic_block<PolyphaseResampler<T>>::registerOutput(&out);
generic_block<PolyphaseResampler<T>>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<PolyphaseResampler<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<PolyphaseResampler<T>>::ctrlMtx);
generic_block<PolyphaseResampler<T>>::tempStop();
generic_block<PolyphaseResampler<T>>::unregisterInput(_in);
_in = in;
counter = 0;
offset = 0;
generic_block<PolyphaseResampler<T>>::registerInput(_in);
generic_block<PolyphaseResampler<T>>::tempStart();
}
void setInSampleRate(float inSampleRate) {
assert(generic_block<PolyphaseResampler<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<PolyphaseResampler<T>>::ctrlMtx);
generic_block<PolyphaseResampler<T>>::tempStop();
_inSampleRate = inSampleRate;
int _gcd = std::gcd((int)_inSampleRate, (int)_outSampleRate);
_interp = _outSampleRate / _gcd;
_decim = _inSampleRate / _gcd;
buildTapPhases();
counter = 0;
offset = 0;
generic_block<PolyphaseResampler<T>>::tempStart();
}
void setOutSampleRate(float outSampleRate) {
assert(generic_block<PolyphaseResampler<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<PolyphaseResampler<T>>::ctrlMtx);
generic_block<PolyphaseResampler<T>>::tempStop();
_outSampleRate = outSampleRate;
int _gcd = std::gcd((int)_inSampleRate, (int)_outSampleRate);
_interp = _outSampleRate / _gcd;
_decim = _inSampleRate / _gcd;
buildTapPhases();
counter = 0;
offset = 0;
generic_block<PolyphaseResampler<T>>::tempStart();
}
int getInterpolation() {
assert(generic_block<PolyphaseResampler<T>>::_block_init);
return _interp;
}
int getDecimation() {
assert(generic_block<PolyphaseResampler<T>>::_block_init);
return _decim;
}
void updateWindow(dsp::filter_window::generic_window* window) {
assert(generic_block<PolyphaseResampler<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<PolyphaseResampler<T>>::ctrlMtx);
generic_block<PolyphaseResampler<T>>::tempStop();
_window = window;
volk_free(taps);
tapCount = window->getTapCount();
taps = (float*)volk_malloc(tapCount * sizeof(float), volk_get_alignment());
window->createTaps(taps, tapCount, _interp);
buildTapPhases();
counter = 0;
offset = 0;
generic_block<PolyphaseResampler<T>>::tempStart();
}
int calcOutSize(int in) {
assert(generic_block<PolyphaseResampler<T>>::_block_init);
return (in * _interp) / _decim;
}
virtual int run() override {
int count = _in->read();
if (count < 0) {
return -1;
}
memcpy(&buffer[tapsPerPhase], _in->readBuf, count * sizeof(T));
_in->flush();
// Write to output
int outIndex = 0;
int inOffset = offset;
int _counter = counter;
if constexpr (std::is_same_v<T, float>) {
while (inOffset < count) {
volk_32f_x2_dot_prod_32f(&out.writeBuf[outIndex++], &buffer[inOffset], tapPhases[_counter], tapsPerPhase);
_counter += _decim;
inOffset += (_counter / _interp);
_counter = (_counter % _interp);
}
}
if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
while (inOffset < count) {
volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&out.writeBuf[outIndex++], (lv_32fc_t*)&buffer[inOffset], tapPhases[_counter], tapsPerPhase);
_counter += _decim;
inOffset += (_counter / _interp);
_counter = (_counter % _interp);
}
}
if (!out.swap(outIndex)) { return -1; }
offset = inOffset - count;
counter = _counter;
memmove(buffer, &buffer[count], tapsPerPhase * sizeof(T));
return count;
}
stream<T> out;
private:
void buildTapPhases() {
if (!taps) {
return;
}
if (!tapPhases.empty()) {
freeTapPhases();
}
int phases = _interp;
tapsPerPhase = (tapCount + phases - 1) / phases; //Integer division ceiling
bufStart = &buffer[tapsPerPhase];
for (int i = 0; i < phases; i++) {
tapPhases.push_back((float*)volk_malloc(tapsPerPhase * sizeof(float), volk_get_alignment()));
}
int currentTap = 0;
for (int tap = 0; tap < tapsPerPhase; tap++) {
for (int phase = 0; phase < phases; phase++) {
if (currentTap < tapCount) {
tapPhases[(_interp - 1) - phase][tap] = taps[currentTap++];
}
else {
tapPhases[(_interp - 1) - phase][tap] = 0;
}
}
}
}
void freeTapPhases() {
for (auto& tapPhase : tapPhases) {
volk_free(tapPhase);
}
tapPhases.clear();
}
stream<T>* _in;
dsp::filter_window::generic_window* _window;
T* bufStart;
T* buffer;
int tapCount;
int _interp, _decim;
float _inSampleRate, _outSampleRate;
float* taps;
int counter = 0;
int offset = 0;
int tapsPerPhase;
std::vector<float*> tapPhases;
};
}

243
core/src/dsp/routing.h
Wyświetl plik

@ -1,243 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/buffer.h>
#include <string.h>
#include <numeric>
#include <spdlog/spdlog.h>
namespace dsp {
template <class T>
class Splitter : public generic_block<Splitter<T>> {
public:
Splitter() {}
Splitter(stream<T>* in) { init(in); }
void init(stream<T>* in) {
_in = in;
generic_block<Splitter>::registerInput(_in);
generic_block<Splitter>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<Splitter>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Splitter>::ctrlMtx);
generic_block<Splitter>::tempStop();
generic_block<Splitter>::unregisterInput(_in);
_in = in;
generic_block<Splitter>::registerInput(_in);
generic_block<Splitter>::tempStart();
}
void bindStream(stream<T>* stream) {
assert(generic_block<Splitter>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Splitter>::ctrlMtx);
generic_block<Splitter>::tempStop();
out.push_back(stream);
generic_block<Splitter>::registerOutput(stream);
generic_block<Splitter>::tempStart();
}
void unbindStream(stream<T>* stream) {
assert(generic_block<Splitter>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Splitter>::ctrlMtx);
generic_block<Splitter>::tempStop();
generic_block<Splitter>::unregisterOutput(stream);
out.erase(std::remove(out.begin(), out.end(), stream), out.end());
generic_block<Splitter>::tempStart();
}
private:
int run() {
// TODO: If too slow, buffering might be necessary
int count = _in->read();
if (count < 0) { return -1; }
for (const auto& stream : out) {
memcpy(stream->writeBuf, _in->readBuf, count * sizeof(T));
if (!stream->swap(count)) { return -1; }
}
_in->flush();
return count;
}
stream<T>* _in;
std::vector<stream<T>*> out;
};
template <class T>
class StreamDoubler : public generic_block<StreamDoubler<T>> {
public:
StreamDoubler() {}
StreamDoubler(stream<T>* in) { init(in); }
void init(stream<T>* in) {
_in = in;
generic_block<StreamDoubler>::registerInput(_in);
generic_block<StreamDoubler>::registerOutput(&outA);
generic_block<StreamDoubler>::registerOutput(&outB);
generic_block<StreamDoubler>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<StreamDoubler>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<StreamDoubler>::ctrlMtx);
generic_block<StreamDoubler>::tempStop();
generic_block<StreamDoubler>::unregisterInput(_in);
_in = in;
generic_block<StreamDoubler>::registerInput(_in);
generic_block<StreamDoubler>::tempStart();
}
stream<T> outA;
stream<T> outB;
private:
int run() {
int count = _in->read();
if (count < 0) { return -1; }
memcpy(outA.writeBuf, _in->readBuf, count * sizeof(T));
memcpy(outB.writeBuf, _in->readBuf, count * sizeof(T));
_in->flush();
if (!outA.swap(count)) { return -1; }
if (!outB.swap(count)) { return -1; }
return count;
}
stream<T>* _in;
};
// NOTE: I'm not proud of this, it's BAD and just taken from the previous DSP, but it works...
template <class T>
class Reshaper : public generic_block<Reshaper<T>> {
public:
Reshaper() {}
Reshaper(stream<T>* in, int keep, int skip) { init(in, keep, skip); }
// NOTE: For some reason, the base class destructor doesn't get called.... this is a temporary fix I guess
// I also don't check for _block_init for the exact sample reason, something's weird
~Reshaper() {
if (!generic_block<Reshaper<T>>::_block_init) { return; }
generic_block<Reshaper<T>>::stop();
}
void init(stream<T>* in, int keep, int skip) {
_in = in;
_keep = keep;
_skip = skip;
ringBuf.init(keep * 2);
generic_block<Reshaper<T>>::registerInput(_in);
generic_block<Reshaper<T>>::registerOutput(&out);
generic_block<Reshaper<T>>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<Reshaper<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Reshaper<T>>::ctrlMtx);
generic_block<Reshaper<T>>::tempStop();
generic_block<Reshaper<T>>::unregisterInput(_in);
_in = in;
generic_block<Reshaper<T>>::registerInput(_in);
generic_block<Reshaper<T>>::tempStart();
}
void setKeep(int keep) {
assert(generic_block<Reshaper<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Reshaper<T>>::ctrlMtx);
generic_block<Reshaper<T>>::tempStop();
_keep = keep;
ringBuf.setMaxLatency(keep * 2);
generic_block<Reshaper<T>>::tempStart();
}
void setSkip(int skip) {
assert(generic_block<Reshaper<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Reshaper<T>>::ctrlMtx);
generic_block<Reshaper<T>>::tempStop();
_skip = skip;
generic_block<Reshaper<T>>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
ringBuf.write(_in->readBuf, count);
_in->flush();
return count;
}
stream<T> out;
private:
void doStart() override {
workThread = std::thread(&Reshaper<T>::loop, this);
bufferWorkerThread = std::thread(&Reshaper<T>::bufferWorker, this);
}
void loop() {
while (run() >= 0)
;
}
void doStop() override {
_in->stopReader();
ringBuf.stopReader();
out.stopWriter();
ringBuf.stopWriter();
if (workThread.joinable()) {
workThread.join();
}
if (bufferWorkerThread.joinable()) {
bufferWorkerThread.join();
}
_in->clearReadStop();
ringBuf.clearReadStop();
out.clearWriteStop();
ringBuf.clearWriteStop();
}
void bufferWorker() {
T* buf = new T[_keep];
bool delay = _skip < 0;
int readCount = std::min<int>(_keep + _skip, _keep);
int skip = std::max<int>(_skip, 0);
int delaySize = (-_skip) * sizeof(T);
int delayCount = (-_skip);
T* start = &buf[std::max<int>(-_skip, 0)];
T* delayStart = &buf[_keep + _skip];
while (true) {
if (delay) {
memmove(buf, delayStart, delaySize);
if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
for (int i = 0; i < delayCount; i++) {
buf[i].re /= 10.0f;
buf[i].im /= 10.0f;
}
}
}
if (ringBuf.readAndSkip(start, readCount, skip) < 0) { break; };
memcpy(out.writeBuf, buf, _keep * sizeof(T));
if (!out.swap(_keep)) { break; }
}
delete[] buf;
}
stream<T>* _in;
int _outBlockSize;
RingBuffer<T> ringBuf;
std::thread bufferWorkerThread;
std::thread workThread;
int _keep, _skip;
};
}

192
core/src/dsp/sink.h
Wyświetl plik

@ -1,189 +1,35 @@
#pragma once
#include <dsp/block.h>
#include <dsp/buffer.h>
#include <fstream>
#include "block.h"
namespace dsp {
template <class T>
class HandlerSink : public generic_block<HandlerSink<T>> {
class Sink : public block {
public:
HandlerSink() {}
Sink() {}
HandlerSink(stream<T>* in, void (*handler)(T* data, int count, void* ctx), void* ctx) { init(in, handler, ctx); }
Sink(stream<T>* in) { init(in); }
void init(stream<T>* in, void (*handler)(T* data, int count, void* ctx), void* ctx) {
virtual ~Sink() {}
virtual void init(stream<T>* in) {
_in = in;
_handler = handler;
_ctx = ctx;
generic_block<HandlerSink<T>>::registerInput(_in);
generic_block<HandlerSink<T>>::_block_init = true;
registerInput(_in);
_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<HandlerSink<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<HandlerSink<T>>::ctrlMtx);
generic_block<HandlerSink<T>>::tempStop();
generic_block<HandlerSink<T>>::unregisterInput(_in);
virtual void setInput(stream<T>* in) {
assert(_block_init);
std::lock_guard<std::recursive_mutex> lck(ctrlMtx);
tempStop();
unregisterInput(_in);
_in = in;
generic_block<HandlerSink<T>>::registerInput(_in);
generic_block<HandlerSink<T>>::tempStart();
registerInput(_in);
tempStart();
}
void setHandler(void (*handler)(T* data, int count, void* ctx), void* ctx) {
assert(generic_block<HandlerSink<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<HandlerSink<T>>::ctrlMtx);
generic_block<HandlerSink<T>>::tempStop();
_handler = handler;
_ctx = ctx;
generic_block<HandlerSink<T>>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
_handler(_in->readBuf, count, _ctx);
_in->flush();
return count;
}
private:
stream<T>* _in;
void (*_handler)(T* data, int count, void* ctx);
void* _ctx;
};
template <class T>
class RingBufferSink : public generic_block<RingBufferSink<T>> {
public:
RingBufferSink() {}
RingBufferSink(stream<T>* in) { init(in); }
void init(stream<T>* in) {
_in = in;
data.init(480); // TODO: Use an argument
generic_block<RingBufferSink<T>>::registerInput(_in);
generic_block<RingBufferSink<T>>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<RingBufferSink<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<RingBufferSink<T>>::ctrlMtx);
generic_block<RingBufferSink<T>>::tempStop();
generic_block<RingBufferSink<T>>::unregisterInput(_in);
_in = in;
generic_block<RingBufferSink<T>>::registerInput(_in);
generic_block<RingBufferSink<T>>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
if (data.write(_in->readBuf, count) < 0) { return -1; }
_in->flush();
return count;
}
RingBuffer<T> data;
private:
void doStop() {
_in->stopReader();
data.stopWriter();
if (generic_block<RingBufferSink<T>>::workerThread.joinable()) {
generic_block<RingBufferSink<T>>::workerThread.join();
}
_in->clearReadStop();
data.clearWriteStop();
}
virtual int run() = 0;
protected:
stream<T>* _in;
};
template <class T>
class NullSink : public generic_block<NullSink<T>> {
public:
NullSink() {}
NullSink(stream<T>* in) { init(in); }
void init(stream<T>* in) {
_in = in;
generic_block<NullSink<T>>::registerInput(_in);
generic_block<NullSink<T>>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<NullSink<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<NullSink<T>>::ctrlMtx);
generic_block<NullSink<T>>::tempStop();
generic_block<NullSink<T>>::unregisterInput(_in);
_in = in;
generic_block<NullSink<T>>::registerInput(_in);
generic_block<NullSink<T>>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
_in->flush();
return count;
}
private:
stream<T>* _in;
};
template <class T>
class FileSink : public generic_block<FileSink<T>> {
public:
FileSink() {}
FileSink(stream<T>* in, std::string path) { init(in, path); }
~FileSink() {
if (!generic_block<FileSink<T>>::_block_init) { return; }
generic_block<FileSink<T>>::stop();
if (file.is_open()) { file.close(); }
generic_block<FileSink<T>>::_block_init = false;
}
void init(stream<T>* in, std::string path) {
_in = in;
file = std::ofstream(path, std::ios::binary);
generic_block<FileSink<T>>::registerInput(_in);
generic_block<FileSink<T>>::_block_init = true;
}
void setInput(stream<T>* in) {
assert(generic_block<FileSink<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FileSink<T>>::ctrlMtx);
generic_block<FileSink<T>>::tempStop();
generic_block<FileSink<T>>::unregisterInput(_in);
_in = in;
generic_block<FileSink<T>>::registerInput(_in);
generic_block<FileSink<T>>::tempStart();
}
bool isOpen() {
assert(generic_block<FileSink<T>>::_block_init);
return file.is_open();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
if (file.is_open()) {
file.write((char*)_in->readBuf, count * sizeof(T));
}
_in->flush();
return count;
}
private:
stream<T>* _in;
std::ofstream file;
};
}
}

113
core/src/dsp/source.h
Wyświetl plik

@ -1,114 +1,23 @@
#pragma once
#include <dsp/block.h>
#include <dsp/math.h>
#include "block.h"
namespace dsp {
class SineSource : public generic_block<SineSource> {
public:
SineSource() {}
SineSource(int blockSize, float sampleRate, float freq) { init(blockSize, sampleRate, freq); }
void init(int blockSize, float sampleRate, float freq) {
_blockSize = blockSize;
_sampleRate = sampleRate;
_freq = freq;
zeroPhase = (lv_32fc_t*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(lv_32fc_t), volk_get_alignment());
for (int i = 0; i < STREAM_BUFFER_SIZE; i++) {
zeroPhase[i] = lv_cmake(1.0f, 0.0f);
}
phase = lv_cmake(1.0f, 0.0f);
phaseDelta = lv_cmake(std::cos((_freq / _sampleRate) * 2.0f * FL_M_PI), std::sin((_freq / _sampleRate) * 2.0f * FL_M_PI));
generic_block<SineSource>::registerOutput(&out);
generic_block<SineSource>::_block_init = true;
}
void setBlockSize(int blockSize) {
assert(generic_block<SineSource>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<SineSource>::ctrlMtx);
generic_block<SineSource>::tempStop();
_blockSize = blockSize;
generic_block<SineSource>::tempStart();
}
int getBlockSize() {
assert(generic_block<SineSource>::_block_init);
return _blockSize;
}
void setSampleRate(float sampleRate) {
assert(generic_block<SineSource>::_block_init);
_sampleRate = sampleRate;
phaseDelta = lv_cmake(std::cos((_freq / _sampleRate) * 2.0f * FL_M_PI), std::sin((_freq / _sampleRate) * 2.0f * FL_M_PI));
}
float getSampleRate() {
assert(generic_block<SineSource>::_block_init);
return _sampleRate;
}
void setFrequency(float freq) {
assert(generic_block<SineSource>::_block_init);
_freq = freq;
phaseDelta = lv_cmake(std::cos((_freq / _sampleRate) * 2.0f * FL_M_PI), std::sin((_freq / _sampleRate) * 2.0f * FL_M_PI));
}
float getFrequency() {
assert(generic_block<SineSource>::_block_init);
return _freq;
}
int run() {
volk_32fc_s32fc_x2_rotator_32fc((lv_32fc_t*)out.writeBuf, zeroPhase, phaseDelta, &phase, _blockSize);
if (!out.swap(_blockSize)) { return -1; }
return _blockSize;
}
stream<complex_t> out;
private:
int _blockSize;
float _sampleRate;
float _freq;
lv_32fc_t phaseDelta;
lv_32fc_t phase;
lv_32fc_t* zeroPhase;
};
template <class T>
class HandlerSource : public generic_block<HandlerSource<T>> {
class Source : public block {
public:
HandlerSource() {}
Source() {}
HandlerSource(int (*handler)(T* data, void* ctx), void* ctx) { init(handler, ctx); }
Source() { init(); }
void init(int (*handler)(T* data, void* ctx), void* ctx) {
_handler = handler;
_ctx = ctx;
generic_block<HandlerSource<T>>::registerOutput(&out);
generic_block<HandlerSource<T>>::_block_init = true;
virtual ~Source() {}
virtual void init() {
registerOutput(&out);
_block_init = true;
}
void setHandler(int (*handler)(T* data, void* ctx), void* ctx) {
assert(generic_block<HandlerSource<T>>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<HandlerSource<T>>::ctrlMtx);
generic_block<HandlerSource<T>>::tempStop();
_handler = handler;
_ctx = ctx;
generic_block<HandlerSource<T>>::tempStart();
}
int run() {
int count = _handler(out.writeBuf, _ctx);
if (count < 0) { return -1; }
out.swap(count);
return count;
}
virtual int run() = 0;
stream<T> out;
private:
int (*_handler)(T* data, void* ctx);
void* _ctx;
};
}
}

291
core/src/dsp/stereo_fm.h
Wyświetl plik

@ -1,291 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/stream.h>
#include <dsp/types.h>
namespace dsp {
class FMStereoDemuxPilotFilter : public generic_block<FMStereoDemuxPilotFilter> {
public:
FMStereoDemuxPilotFilter() {}
FMStereoDemuxPilotFilter(stream<complex_t>* in, dsp::filter_window::generic_complex_window* window) { init(in, window); }
~FMStereoDemuxPilotFilter() {
if (!generic_block<FMStereoDemuxPilotFilter>::_block_init) { return; }
generic_block<FMStereoDemuxPilotFilter>::stop();
volk_free(buffer);
volk_free(taps);
generic_block<FMStereoDemuxPilotFilter>::_block_init = false;
}
void init(stream<complex_t>* in, dsp::filter_window::generic_complex_window* window) {
_in = in;
tapCount = window->getTapCount();
taps = (complex_t*)volk_malloc(tapCount * sizeof(complex_t), volk_get_alignment());
window->createTaps(taps, tapCount);
buffer = (complex_t*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(complex_t) * 2, volk_get_alignment());
bufStart = &buffer[tapCount];
generic_block<FMStereoDemuxPilotFilter>::registerInput(_in);
generic_block<FMStereoDemuxPilotFilter>::registerOutput(&dataOut);
generic_block<FMStereoDemuxPilotFilter>::registerOutput(&pilotOut);
generic_block<FMStereoDemuxPilotFilter>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<FMStereoDemuxPilotFilter>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FMStereoDemuxPilotFilter>::ctrlMtx);
generic_block<FMStereoDemuxPilotFilter>::tempStop();
generic_block<FMStereoDemuxPilotFilter>::unregisterInput(_in);
_in = in;
generic_block<FMStereoDemuxPilotFilter>::registerInput(_in);
generic_block<FMStereoDemuxPilotFilter>::tempStart();
}
void updateWindow(dsp::filter_window::generic_complex_window* window) {
assert(generic_block<FMStereoDemuxPilotFilter>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FMStereoDemuxPilotFilter>::ctrlMtx);
std::lock_guard<std::mutex> lck2(bufMtx);
_window = window;
volk_free(taps);
tapCount = window->getTapCount();
taps = (complex_t*)volk_malloc(tapCount * sizeof(complex_t), volk_get_alignment());
bufStart = &buffer[tapCount];
window->createTaps(taps, tapCount);
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
bufMtx.lock();
memcpy(bufStart, _in->readBuf, count * sizeof(complex_t));
_in->flush();
for (int i = 0; i < count; i++) {
volk_32fc_x2_dot_prod_32fc((lv_32fc_t*)&pilotOut.writeBuf[i], (lv_32fc_t*)&buffer[i + 1], (lv_32fc_t*)taps, tapCount);
}
memcpy(dataOut.writeBuf, &buffer[tapCount - ((tapCount - 1) / 2)], count * sizeof(complex_t));
if (!pilotOut.swap(count) || !dataOut.swap(count)) {
bufMtx.unlock();
return -1;
}
memmove(buffer, &buffer[count], tapCount * sizeof(complex_t));
bufMtx.unlock();
return count;
}
stream<complex_t> dataOut;
stream<complex_t> pilotOut;
private:
stream<complex_t>* _in;
dsp::filter_window::generic_complex_window* _window;
std::mutex bufMtx;
complex_t* bufStart;
complex_t* buffer;
int tapCount;
complex_t* taps;
};
class FMStereoDemux : public generic_block<FMStereoDemux> {
public:
FMStereoDemux() {}
FMStereoDemux(stream<complex_t>* data, stream<complex_t>* pilot, float loopBandwidth) { init(data, pilot, loopBandwidth); }
void init(stream<complex_t>* data, stream<complex_t>* pilot, float loopBandwidth) {
_data = data;
_pilot = pilot;
lastVCO.re = 1.0f;
lastVCO.im = 0.0f;
_loopBandwidth = loopBandwidth;
float dampningFactor = sqrtf(2.0f) / 2.0f;
float denominator = (1.0 + 2.0 * dampningFactor * _loopBandwidth + _loopBandwidth * _loopBandwidth);
_alpha = (4 * dampningFactor * _loopBandwidth) / denominator;
_beta = (4 * _loopBandwidth * _loopBandwidth) / denominator;
generic_block<FMStereoDemux>::registerInput(_data);
generic_block<FMStereoDemux>::registerInput(_pilot);
generic_block<FMStereoDemux>::registerOutput(&AplusBOut);
generic_block<FMStereoDemux>::registerOutput(&AminusBOut);
generic_block<FMStereoDemux>::_block_init = true;
}
void setInput(stream<complex_t>* data, stream<complex_t>* pilot) {
assert(generic_block<FMStereoDemux>::_block_init);
generic_block<FMStereoDemux>::tempStop();
generic_block<FMStereoDemux>::unregisterInput(_data);
generic_block<FMStereoDemux>::unregisterInput(_pilot);
_data = data;
_pilot = pilot;
generic_block<FMStereoDemux>::registerInput(_data);
generic_block<FMStereoDemux>::registerInput(_pilot);
generic_block<FMStereoDemux>::tempStart();
}
void setLoopBandwidth(float loopBandwidth) {
assert(generic_block<FMStereoDemux>::_block_init);
generic_block<FMStereoDemux>::tempStop();
_loopBandwidth = loopBandwidth;
float dampningFactor = sqrtf(2.0f) / 2.0f;
float denominator = (1.0 + 2.0 * dampningFactor * _loopBandwidth + _loopBandwidth * _loopBandwidth);
_alpha = (4 * dampningFactor * _loopBandwidth) / denominator;
_beta = (4 * _loopBandwidth * _loopBandwidth) / denominator;
generic_block<FMStereoDemux>::tempStart();
}
int run() {
int count = _data->read();
if (count < 0) { return -1; }
int pCount = _pilot->read();
if (pCount < 0) { return -1; }
complex_t doubledVCO;
float error;
volk_32fc_deinterleave_real_32f(AplusBOut.writeBuf, (lv_32fc_t*)_data->readBuf, count);
for (int i = 0; i < count; i++) {
// Double the VCO, then mix it with the input data.
// IMPORTANT: THERE SHOULDN'T BE A NEED FOR A GAIN HERE
doubledVCO = lastVCO * lastVCO;
AminusBOut.writeBuf[i] = (_data->readBuf[i].re * doubledVCO.re) * 2.0f;
// Calculate the phase error estimation
error = _pilot->readBuf[i].phase() - vcoPhase;
if (error > 3.1415926535f) { error -= 2.0f * 3.1415926535f; }
else if (error <= -3.1415926535f) {
error += 2.0f * 3.1415926535f;
}
// Integrate frequency and clamp it
vcoFrequency += _beta * error;
if (vcoFrequency > upperLimit) { vcoFrequency = upperLimit; }
else if (vcoFrequency < lowerLimit) {
vcoFrequency = lowerLimit;
}
// Calculate new phase and wrap it
vcoPhase += vcoFrequency + (_alpha * error);
while (vcoPhase > (2.0f * FL_M_PI)) { vcoPhase -= (2.0f * FL_M_PI); }
while (vcoPhase < (-2.0f * FL_M_PI)) { vcoPhase += (2.0f * FL_M_PI); }
// Calculate output
lastVCO.re = cosf(vcoPhase);
lastVCO.im = sinf(vcoPhase);
}
_data->flush();
_pilot->flush();
if (!AplusBOut.swap(count)) { return -1; }
if (!AminusBOut.swap(count)) { return -1; }
return count;
}
stream<float> AplusBOut;
stream<float> AminusBOut;
float gain = 2.0f;
private:
float _loopBandwidth = 0.01f;
const float expectedFreq = ((19000.0f / 250000.0f) * 2.0f * FL_M_PI);
const float upperLimit = ((19200.0f / 250000.0f) * 2.0f * FL_M_PI);
const float lowerLimit = ((18800.0f / 250000.0f) * 2.0f * FL_M_PI);
float _alpha; // Integral coefficient
float _beta; // Proportional coefficient
float vcoFrequency = expectedFreq;
float vcoPhase = 0.0f;
complex_t lastVCO;
stream<complex_t>* _data;
stream<complex_t>* _pilot;
};
class FMStereoReconstruct : public generic_block<FMStereoReconstruct> {
public:
FMStereoReconstruct() {}
FMStereoReconstruct(stream<float>* a, stream<float>* b) { init(a, b); }
~FMStereoReconstruct() {
generic_block<FMStereoReconstruct>::stop();
delete[] leftBuf;
delete[] rightBuf;
}
void init(stream<float>* aplusb, stream<float>* aminusb) {
_aplusb = aplusb;
_aminusb = aminusb;
leftBuf = new float[STREAM_BUFFER_SIZE];
rightBuf = new float[STREAM_BUFFER_SIZE];
generic_block<FMStereoReconstruct>::registerInput(aplusb);
generic_block<FMStereoReconstruct>::registerInput(aminusb);
generic_block<FMStereoReconstruct>::registerOutput(&out);
generic_block<FMStereoReconstruct>::_block_init = true;
}
void setInputs(stream<float>* aplusb, stream<float>* aminusb) {
assert(generic_block<FMStereoReconstruct>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FMStereoReconstruct>::ctrlMtx);
generic_block<FMStereoReconstruct>::tempStop();
generic_block<FMStereoReconstruct>::unregisterInput(_aplusb);
generic_block<FMStereoReconstruct>::unregisterInput(_aminusb);
_aplusb = aplusb;
_aminusb = aminusb;
generic_block<FMStereoReconstruct>::registerInput(_aplusb);
generic_block<FMStereoReconstruct>::registerInput(_aminusb);
generic_block<FMStereoReconstruct>::tempStart();
}
int run() {
int a_count = _aplusb->read();
if (a_count < 0) { return -1; }
int b_count = _aminusb->read();
if (b_count < 0) { return -1; }
if (a_count != b_count) {
_aplusb->flush();
_aminusb->flush();
return 0;
}
volk_32f_x2_add_32f(rightBuf, _aplusb->readBuf, _aminusb->readBuf, a_count);
volk_32f_x2_subtract_32f(leftBuf, _aplusb->readBuf, _aminusb->readBuf, a_count);
_aplusb->flush();
_aminusb->flush();
volk_32f_x2_interleave_32fc((lv_32fc_t*)out.writeBuf, leftBuf, rightBuf, a_count);
if (!out.swap(a_count)) { return -1; }
return a_count;
}
stream<stereo_t> out;
private:
stream<float>* _aplusb;
stream<float>* _aminusb;
float* leftBuf;
float* rightBuf;
};
}

38
core/src/dsp/stream.h
Wyświetl plik

@ -1,9 +1,11 @@
#pragma once
#include <string.h>
#include <mutex>
#include <condition_variable>
#include <volk/volk.h>
#include "buffer/buffer.h"
// 1MB buffer
// 1MSample buffer
#define STREAM_BUFFER_SIZE 1000000
namespace dsp {
@ -22,23 +24,23 @@ namespace dsp {
class stream : public untyped_stream {
public:
stream() {
writeBuf = (T*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(T), volk_get_alignment());
readBuf = (T*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(T), volk_get_alignment());
writeBuf = buffer::alloc<T>(STREAM_BUFFER_SIZE);
readBuf = buffer::alloc<T>(STREAM_BUFFER_SIZE);
}
~stream() {
volk_free(writeBuf);
volk_free(readBuf);
virtual ~stream() {
buffer::free(writeBuf);
buffer::free(readBuf);
}
void setBufferSize(int samples) {
volk_free(writeBuf);
volk_free(readBuf);
writeBuf = (T*)volk_malloc(samples * sizeof(T), volk_get_alignment());
readBuf = (T*)volk_malloc(samples * sizeof(T), volk_get_alignment());
virtual void setBufferSize(int samples) {
buffer::free(writeBuf);
buffer::free(readBuf);
writeBuf = buffer::alloc<T>(samples);
readBuf = buffer::alloc<T>(samples);
}
bool swap(int size) {
virtual inline bool swap(int size) {
{
// Wait to either swap or stop
std::unique_lock<std::mutex> lck(swapMtx);
@ -65,7 +67,7 @@ namespace dsp {
return true;
}
int read() {
virtual inline int read() {
// Wait for data to be ready or to be stopped
std::unique_lock<std::mutex> lck(rdyMtx);
rdyCV.wait(lck, [this] { return (dataReady || readerStop); });
@ -73,7 +75,7 @@ namespace dsp {
return (readerStop ? -1 : dataSize);
}
void flush() {
virtual inline void flush() {
// Clear data ready
{
std::lock_guard<std::mutex> lck(rdyMtx);
@ -89,7 +91,7 @@ namespace dsp {
swapCV.notify_all();
}
void stopWriter() {
virtual void stopWriter() {
{
std::lock_guard<std::mutex> lck(swapMtx);
writerStop = true;
@ -97,11 +99,11 @@ namespace dsp {
swapCV.notify_all();
}
void clearWriteStop() {
virtual void clearWriteStop() {
writerStop = false;
}
void stopReader() {
virtual void stopReader() {
{
std::lock_guard<std::mutex> lck(rdyMtx);
readerStop = true;
@ -109,7 +111,7 @@ namespace dsp {
rdyCV.notify_all();
}
void clearReadStop() {
virtual void clearReadStop() {
readerStop = false;
}

46
core/src/dsp/types.h
Wyświetl plik

@ -1,6 +1,6 @@
#pragma once
#include <math.h>
#include <dsp/utils/math.h>
#include "math/constants.h"
namespace dsp {
struct complex_t {
@ -8,10 +8,18 @@ namespace dsp {
return complex_t{ re * b, im * b };
}
complex_t operator*(const double b) {
return complex_t{ re * (float)b, im * (float)b };
}
complex_t operator/(const float b) {
return complex_t{ re / b, im / b };
}
complex_t operator/(const double b) {
return complex_t{ re / (float)b, im / (float)b };
}
complex_t operator*(const complex_t& b) {
return complex_t{ (re * b.re) - (im * b.im), (im * b.re) + (re * b.im) };
}
@ -24,6 +32,24 @@ namespace dsp {
return complex_t{ re - b.re, im - b.im };
}
complex_t& operator+=(const complex_t& b) {
re += b.re;
im += b.im;
return *this;
}
complex_t& operator-=(const complex_t& b) {
re -= b.re;
im -= b.im;
return *this;
}
complex_t& operator*=(const float& b) {
re *= b;
im *= b;
return *this;
}
inline complex_t conj() {
return complex_t{ re, -im };
}
@ -78,6 +104,24 @@ namespace dsp {
return stereo_t{ l - b.l, r - b.r };
}
stereo_t& operator+=(const stereo_t& b) {
l += b.l;
r += b.r;
return *this;
}
stereo_t& operator-=(const stereo_t& b) {
l -= b.l;
r -= b.r;
return *this;
}
stereo_t& operator*=(const float& b) {
l *= b;
r *= b;
return *this;
}
float l;
float r;
};

43
core/src/dsp/utils/bitstream.h
Wyświetl plik

@ -1,43 +0,0 @@
#pragma once
namespace dsp {
inline uint64_t readBits(int offset, int length, uint8_t* buffer) {
uint64_t outputValue = 0;
int lastBit = offset + (length - 1);
int firstWord = offset / 8;
int lastWord = lastBit / 8;
int firstOffset = offset - (firstWord * 8);
int lastOffset = lastBit - (lastWord * 8);
int wordCount = (lastWord - firstWord) + 1;
// If the data fits in a single byte, just get it
if (wordCount == 1) {
return (buffer[firstWord] & (0xFF >> firstOffset)) >> (7 - lastOffset);
}
int bitsRead = length;
for (int i = 0; i < wordCount; i++) {
// First word
if (i == 0) {
bitsRead -= 8 - firstOffset;
outputValue |= (uint64_t)(buffer[firstWord] & (0xFF >> firstOffset)) << bitsRead;
continue;
}
// Last word
if (i == (wordCount - 1)) {
outputValue |= (uint64_t)buffer[lastWord] >> (7 - lastOffset);
break;
}
// Just a normal byte
bitsRead -= 8;
outputValue |= (uint64_t)buffer[firstWord + i] << bitsRead;
}
return outputValue;
}
}

120
core/src/dsp/utils/ccsds.h
Wyświetl plik

@ -1,120 +0,0 @@
#pragma once
#include <stdint.h>
namespace dsp {
namespace ccsds {
const uint8_t TO_DUAL_BASIS[256] = {
0x00, 0x7b, 0xaf, 0xd4, 0x99, 0xe2, 0x36, 0x4d, 0xfa, 0x81, 0x55, 0x2e, 0x63, 0x18, 0xcc, 0xb7,
0x86, 0xfd, 0x29, 0x52, 0x1f, 0x64, 0xb0, 0xcb, 0x7c, 0x07, 0xd3, 0xa8, 0xe5, 0x9e, 0x4a, 0x31,
0xec, 0x97, 0x43, 0x38, 0x75, 0x0e, 0xda, 0xa1, 0x16, 0x6d, 0xb9, 0xc2, 0x8f, 0xf4, 0x20, 0x5b,
0x6a, 0x11, 0xc5, 0xbe, 0xf3, 0x88, 0x5c, 0x27, 0x90, 0xeb, 0x3f, 0x44, 0x09, 0x72, 0xa6, 0xdd,
0xef, 0x94, 0x40, 0x3b, 0x76, 0x0d, 0xd9, 0xa2, 0x15, 0x6e, 0xba, 0xc1, 0x8c, 0xf7, 0x23, 0x58,
0x69, 0x12, 0xc6, 0xbd, 0xf0, 0x8b, 0x5f, 0x24, 0x93, 0xe8, 0x3c, 0x47, 0x0a, 0x71, 0xa5, 0xde,
0x03, 0x78, 0xac, 0xd7, 0x9a, 0xe1, 0x35, 0x4e, 0xf9, 0x82, 0x56, 0x2d, 0x60, 0x1b, 0xcf, 0xb4,
0x85, 0xfe, 0x2a, 0x51, 0x1c, 0x67, 0xb3, 0xc8, 0x7f, 0x04, 0xd0, 0xab, 0xe6, 0x9d, 0x49, 0x32,
0x8d, 0xf6, 0x22, 0x59, 0x14, 0x6f, 0xbb, 0xc0, 0x77, 0x0c, 0xd8, 0xa3, 0xee, 0x95, 0x41, 0x3a,
0x0b, 0x70, 0xa4, 0xdf, 0x92, 0xe9, 0x3d, 0x46, 0xf1, 0x8a, 0x5e, 0x25, 0x68, 0x13, 0xc7, 0xbc,
0x61, 0x1a, 0xce, 0xb5, 0xf8, 0x83, 0x57, 0x2c, 0x9b, 0xe0, 0x34, 0x4f, 0x02, 0x79, 0xad, 0xd6,
0xe7, 0x9c, 0x48, 0x33, 0x7e, 0x05, 0xd1, 0xaa, 0x1d, 0x66, 0xb2, 0xc9, 0x84, 0xff, 0x2b, 0x50,
0x62, 0x19, 0xcd, 0xb6, 0xfb, 0x80, 0x54, 0x2f, 0x98, 0xe3, 0x37, 0x4c, 0x01, 0x7a, 0xae, 0xd5,
0xe4, 0x9f, 0x4b, 0x30, 0x7d, 0x06, 0xd2, 0xa9, 0x1e, 0x65, 0xb1, 0xca, 0x87, 0xfc, 0x28, 0x53,
0x8e, 0xf5, 0x21, 0x5a, 0x17, 0x6c, 0xb8, 0xc3, 0x74, 0x0f, 0xdb, 0xa0, 0xed, 0x96, 0x42, 0x39,
0x08, 0x73, 0xa7, 0xdc, 0x91, 0xea, 0x3e, 0x45, 0xf2, 0x89, 0x5d, 0x26, 0x6b, 0x10, 0xc4, 0xbf
};
const uint8_t FROM_DUAL_BASIS[256] = {
0x00, 0xcc, 0xac, 0x60, 0x79, 0xb5, 0xd5, 0x19, 0xf0, 0x3c, 0x5c, 0x90, 0x89, 0x45, 0x25, 0xe9,
0xfd, 0x31, 0x51, 0x9d, 0x84, 0x48, 0x28, 0xe4, 0x0d, 0xc1, 0xa1, 0x6d, 0x74, 0xb8, 0xd8, 0x14,
0x2e, 0xe2, 0x82, 0x4e, 0x57, 0x9b, 0xfb, 0x37, 0xde, 0x12, 0x72, 0xbe, 0xa7, 0x6b, 0x0b, 0xc7,
0xd3, 0x1f, 0x7f, 0xb3, 0xaa, 0x66, 0x06, 0xca, 0x23, 0xef, 0x8f, 0x43, 0x5a, 0x96, 0xf6, 0x3a,
0x42, 0x8e, 0xee, 0x22, 0x3b, 0xf7, 0x97, 0x5b, 0xb2, 0x7e, 0x1e, 0xd2, 0xcb, 0x07, 0x67, 0xab,
0xbf, 0x73, 0x13, 0xdf, 0xc6, 0x0a, 0x6a, 0xa6, 0x4f, 0x83, 0xe3, 0x2f, 0x36, 0xfa, 0x9a, 0x56,
0x6c, 0xa0, 0xc0, 0x0c, 0x15, 0xd9, 0xb9, 0x75, 0x9c, 0x50, 0x30, 0xfc, 0xe5, 0x29, 0x49, 0x85,
0x91, 0x5d, 0x3d, 0xf1, 0xe8, 0x24, 0x44, 0x88, 0x61, 0xad, 0xcd, 0x01, 0x18, 0xd4, 0xb4, 0x78,
0xc5, 0x09, 0x69, 0xa5, 0xbc, 0x70, 0x10, 0xdc, 0x35, 0xf9, 0x99, 0x55, 0x4c, 0x80, 0xe0, 0x2c,
0x38, 0xf4, 0x94, 0x58, 0x41, 0x8d, 0xed, 0x21, 0xc8, 0x04, 0x64, 0xa8, 0xb1, 0x7d, 0x1d, 0xd1,
0xeb, 0x27, 0x47, 0x8b, 0x92, 0x5e, 0x3e, 0xf2, 0x1b, 0xd7, 0xb7, 0x7b, 0x62, 0xae, 0xce, 0x02,
0x16, 0xda, 0xba, 0x76, 0x6f, 0xa3, 0xc3, 0x0f, 0xe6, 0x2a, 0x4a, 0x86, 0x9f, 0x53, 0x33, 0xff,
0x87, 0x4b, 0x2b, 0xe7, 0xfe, 0x32, 0x52, 0x9e, 0x77, 0xbb, 0xdb, 0x17, 0x0e, 0xc2, 0xa2, 0x6e,
0x7a, 0xb6, 0xd6, 0x1a, 0x03, 0xcf, 0xaf, 0x63, 0x8a, 0x46, 0x26, 0xea, 0xf3, 0x3f, 0x5f, 0x93,
0xa9, 0x65, 0x05, 0xc9, 0xd0, 0x1c, 0x7c, 0xb0, 0x59, 0x95, 0xf5, 0x39, 0x20, 0xec, 0x8c, 0x40,
0x54, 0x98, 0xf8, 0x34, 0x2d, 0xe1, 0x81, 0x4d, 0xa4, 0x68, 0x08, 0xc4, 0xdd, 0x11, 0x71, 0xbd
};
const uint8_t SCRAMBLING_SEQUENCE[255] = {
0xFF, 0x48, 0x0E, 0xC0, 0x9A, 0x0D, 0x70, 0xBC, 0x8E, 0x2C, 0x93, 0xAD, 0xA7, 0xB7, 0x46, 0xCE,
0x5A, 0x97, 0x7D, 0xCC, 0x32, 0xA2, 0xBF, 0x3E, 0x0A, 0x10, 0xF1, 0x88, 0x94, 0xCD, 0xEA, 0xB1,
0xFE, 0x90, 0x1D, 0x81, 0x34, 0x1A, 0xE1, 0x79, 0x1C, 0x59, 0x27, 0x5B, 0x4F, 0x6E, 0x8D, 0x9C,
0xB5, 0x2E, 0xFB, 0x98, 0x65, 0x45, 0x7E, 0x7C, 0x14, 0x21, 0xE3, 0x11, 0x29, 0x9B, 0xD5, 0x63,
0xFD, 0x20, 0x3B, 0x02, 0x68, 0x35, 0xC2, 0xF2, 0x38, 0xB2, 0x4E, 0xB6, 0x9E, 0xDD, 0x1B, 0x39,
0x6A, 0x5D, 0xF7, 0x30, 0xCA, 0x8A, 0xFC, 0xF8, 0x28, 0x43, 0xC6, 0x22, 0x53, 0x37, 0xAA, 0xC7,
0xFA, 0x40, 0x76, 0x04, 0xD0, 0x6B, 0x85, 0xE4, 0x71, 0x64, 0x9D, 0x6D, 0x3D, 0xBA, 0x36, 0x72,
0xD4, 0xBB, 0xEE, 0x61, 0x95, 0x15, 0xF9, 0xF0, 0x50, 0x87, 0x8C, 0x44, 0xA6, 0x6F, 0x55, 0x8F,
0xF4, 0x80, 0xEC, 0x09, 0xA0, 0xD7, 0x0B, 0xC8, 0xE2, 0xC9, 0x3A, 0xDA, 0x7B, 0x74, 0x6C, 0xE5,
0xA9, 0x77, 0xDC, 0xC3, 0x2A, 0x2B, 0xF3, 0xE0, 0xA1, 0x0F, 0x18, 0x89, 0x4C, 0xDE, 0xAB, 0x1F,
0xE9, 0x01, 0xD8, 0x13, 0x41, 0xAE, 0x17, 0x91, 0xC5, 0x92, 0x75, 0xB4, 0xF6, 0xE8, 0xD9, 0xCB,
0x52, 0xEF, 0xB9, 0x86, 0x54, 0x57, 0xE7, 0xC1, 0x42, 0x1E, 0x31, 0x12, 0x99, 0xBD, 0x56, 0x3F,
0xD2, 0x03, 0xB0, 0x26, 0x83, 0x5C, 0x2F, 0x23, 0x8B, 0x24, 0xEB, 0x69, 0xED, 0xD1, 0xB3, 0x96,
0xA5, 0xDF, 0x73, 0x0C, 0xA8, 0xAF, 0xCF, 0x82, 0x84, 0x3C, 0x62, 0x25, 0x33, 0x7A, 0xAC, 0x7F,
0xA4, 0x07, 0x60, 0x4D, 0x06, 0xB8, 0x5E, 0x47, 0x16, 0x49, 0xD6, 0xD3, 0xDB, 0xA3, 0x67, 0x2D,
0x4B, 0xBE, 0xE6, 0x19, 0x51, 0x5F, 0x9F, 0x05, 0x08, 0x78, 0xC4, 0x4A, 0x66, 0xF5, 0x58
};
const uint32_t ASM_VALUE = 0x1ACFFC1D;
const uint8_t ASM_BYTES[4] = { 0x1A, 0xCF, 0xFC, 0x1D };
const uint8_t ASM_SYMS[16] = { 0b00, 0b01, 0b10, 0b10, 0b11, 0b00, 0b11, 0b11, 0b11, 0b11, 0b11, 0b00, 0b00, 0b01, 0b11, 0b01 };
const uint8_t ASM_BITS[32] = { 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1 };
class FrameDataDecoder {
public:
FrameDataDecoder(int interleaving, bool dualBasis, int rsBlockSize, int rsParitySize) {
_interleaving = interleaving;
_dualBasis = dualBasis;
_rsBlockSize = rsBlockSize;
_rsParitySize = rsParitySize;
}
void decode(uint8_t* in, uint8_t* out, int count) {
// Deinterleave
if (_dualBasis) {
for (int i = 0; i < count; i++) {
workBuffer[i % _interleaving][i / _interleaving] = FROM_DUAL_BASIS[in[i]];
}
}
else {
for (int i = 0; i < count; i++) {
workBuffer[i % _interleaving][i / _interleaving] = in[i];
}
}
// Reed solomon
// Reinterleave and descramble if needed
if (_dualBasis) {
for (int i = 0; i < count; i++) {
out[i] = TO_DUAL_BASIS[workOutputBuffer[i % _interleaving][i / _interleaving]];
}
}
else {
for (int i = 0; i < count; i++) {
out[i] = workOutputBuffer[i % _interleaving][i / _interleaving];
}
}
}
private:
uint8_t workBuffer[5][255];
uint8_t workOutputBuffer[5][255];
int _interleaving;
bool _dualBasis;
int _rsBlockSize;
int _rsParitySize;
};
inline void descramble(uint8_t* in, uint8_t* out, int count) {
for (int i = 0; i < count; i++) {
out[i] = in[i] ^ SCRAMBLING_SEQUENCE[i % 255];
}
}
}
}

6
core/src/dsp/utils/macros.h
Wyświetl plik

@ -1,6 +0,0 @@
#pragma once
#include <dsp/types.h>
#define DSP_SIGN(n) ((n) >= 0)
#define DSP_STEP_CPLX(c) (complex_t{ (c.re > 0.0f) ? 1.0f : -1.0f, (c.im > 0.0f) ? 1.0f : -1.0f })
#define DSP_STEP(n) (((n) > 0.0f) ? 1.0f : -1.0f)

12
core/src/dsp/utils/math.h
Wyświetl plik

@ -1,12 +0,0 @@
#pragma once
#include <math.h>
#define FL_M_PI 3.1415926535f
namespace dsp {
namespace math {
inline double sinc(double omega, double x, double norm) {
return (x == 0.0f) ? 1.0f : (sin(omega * x) / (norm * x));
}
}
}

28
core/src/dsp/utils/window_functions.h
Wyświetl plik

@ -1,28 +0,0 @@
#pragma once
#include <dsp/types.h>
namespace dsp {
namespace window_function {
inline double blackman(double n, double N, double alpha = 0.16f) {
double a0 = (1.0f - alpha) / 2.0f;
double a2 = alpha / 2.0f;
return a0 - (0.5f * cos(2.0f * FL_M_PI * (n / N))) + (a2 * cos(4.0f * FL_M_PI * (n / N)));
}
inline double blackmanThirdOrder(double n, double N, double a0, double a1, double a2, double a3) {
return a0 - (a1 * cos(2.0f * FL_M_PI * (n / N))) + (a2 * cos(4.0f * FL_M_PI * (n / N))) - (a3 * cos(6.0f * FL_M_PI * (n / N)));
}
inline double nuttall(double n, double N) {
return blackmanThirdOrder(n, N, 0.3635819f, 0.4891775f, 0.1365995f, 0.0106411f);
}
inline double blackmanNuttall(double n, double N) {
return blackmanThirdOrder(n, N, 0.3635819f, 0.4891775f, 0.1365995f, 0.0106411f);
}
inline double blackmanHarris(double n, double N) {
return blackmanThirdOrder(n, N, 0.35875f, 0.48829f, 0.14128f, 0.01168f);
}
}
}

133
core/src/dsp/vfo.h
Wyświetl plik

@ -1,133 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/window.h>
#include <dsp/resampling.h>
#include <dsp/processing.h>
#include <algorithm>
namespace dsp {
class VFO {
public:
VFO() {}
~VFO() {
if (!_init) { return; }
stop();
_init = false;
}
VFO(stream<complex_t>* in, float offset, float inSampleRate, float outSampleRate, float bandWidth) {
init(in, offset, inSampleRate, outSampleRate, bandWidth);
};
void init(stream<complex_t>* in, float offset, float inSampleRate, float outSampleRate, float bandWidth) {
_in = in;
_offset = offset;
_inSampleRate = inSampleRate;
_outSampleRate = outSampleRate;
_bandWidth = bandWidth;
float realCutoff = std::min<float>(_bandWidth, std::min<float>(_inSampleRate, _outSampleRate)) / 2.0f;
xlator.init(_in, _inSampleRate, -_offset);
win.init(realCutoff, realCutoff, inSampleRate);
resamp.init(&xlator.out, &win, _inSampleRate, _outSampleRate);
win.setSampleRate(_inSampleRate * resamp.getInterpolation());
resamp.updateWindow(&win);
out = &resamp.out;
_init = true;
}
void start() {
assert(_init);
if (running) { return; }
xlator.start();
resamp.start();
running = true;
}
void stop() {
assert(_init);
if (!running) { return; }
xlator.stop();
resamp.stop();
running = false;
}
void setInSampleRate(float inSampleRate) {
assert(_init);
_inSampleRate = inSampleRate;
if (running) {
xlator.stop();
resamp.stop();
}
xlator.setSampleRate(_inSampleRate);
resamp.setInSampleRate(_inSampleRate);
float realCutoff = std::min<float>(_bandWidth, std::min<float>(_inSampleRate, _outSampleRate)) / 2.0f;
win.setSampleRate(_inSampleRate * resamp.getInterpolation());
win.setCutoff(realCutoff);
win.setTransWidth(realCutoff);
resamp.updateWindow(&win);
if (running) {
xlator.start();
resamp.start();
}
}
void setOutSampleRate(float outSampleRate) {
assert(_init);
_outSampleRate = outSampleRate;
if (running) { resamp.stop(); }
resamp.setOutSampleRate(_outSampleRate);
float realCutoff = std::min<float>(_bandWidth, std::min<float>(_inSampleRate, _outSampleRate)) / 2.0f;
win.setSampleRate(_inSampleRate * resamp.getInterpolation());
win.setCutoff(realCutoff);
win.setTransWidth(realCutoff);
resamp.updateWindow(&win);
if (running) { resamp.start(); }
}
void setOutSampleRate(float outSampleRate, float bandWidth) {
assert(_init);
_outSampleRate = outSampleRate;
_bandWidth = bandWidth;
if (running) { resamp.stop(); }
resamp.setOutSampleRate(_outSampleRate);
float realCutoff = std::min<float>(_bandWidth, std::min<float>(_inSampleRate, _outSampleRate)) / 2.0f;
win.setSampleRate(_inSampleRate * resamp.getInterpolation());
win.setCutoff(realCutoff);
win.setTransWidth(realCutoff);
resamp.updateWindow(&win);
if (running) { resamp.start(); }
}
void setOffset(float offset) {
assert(_init);
_offset = offset;
xlator.setFrequency(-_offset);
}
void setBandwidth(float bandWidth) {
assert(_init);
_bandWidth = bandWidth;
float realCutoff = std::min<float>(_bandWidth, std::min<float>(_inSampleRate, _outSampleRate)) / 2.0f;
win.setCutoff(realCutoff);
win.setTransWidth(realCutoff);
resamp.updateWindow(&win);
}
stream<complex_t>* out;
private:
bool _init = false;
bool running = false;
float _offset, _inSampleRate, _outSampleRate, _bandWidth;
filter_window::BlackmanWindow win;
stream<complex_t>* _in;
FrequencyXlator<complex_t> xlator;
PolyphaseResampler<complex_t> resamp;
};
}

419
core/src/dsp/window.h
Wyświetl plik

@ -1,419 +0,0 @@
#pragma once
#include <dsp/block.h>
#include <dsp/types.h>
#include <dsp/utils/window_functions.h>
#include <fftw3.h>
namespace dsp {
namespace filter_window {
class generic_window {
public:
virtual int getTapCount() { return -1; }
virtual void createTaps(float* taps, int tapCount, float factor = 1.0f) {}
};
class generic_complex_window {
public:
virtual int getTapCount() { return -1; }
virtual void createTaps(dsp::complex_t* taps, int tapCount, float factor = 1.0f) {}
};
class BlackmanWindow : public filter_window::generic_window {
public:
BlackmanWindow() {}
BlackmanWindow(float cutoff, float transWidth, float sampleRate) { init(cutoff, transWidth, sampleRate); }
void init(float cutoff, float transWidth, float sampleRate) {
_cutoff = cutoff;
_transWidth = transWidth;
_sampleRate = sampleRate;
}
void setSampleRate(float sampleRate) {
_sampleRate = sampleRate;
}
void setCutoff(float cutoff) {
_cutoff = cutoff;
}
void setTransWidth(float transWidth) {
_transWidth = transWidth;
}
int getTapCount() {
float fc = _cutoff / _sampleRate;
if (fc > 1.0f) {
fc = 1.0f;
}
int _M = 4.0f / (_transWidth / _sampleRate);
if (_M < 4) {
_M = 4;
}
if (_M % 2 == 0) { _M++; }
return _M;
}
void createTaps(float* taps, int tapCount, float factor = 1.0f) {
// Calculate cuttoff frequency
float omega = 2.0f * FL_M_PI * (_cutoff / _sampleRate);
if (omega > FL_M_PI) { omega = FL_M_PI; }
// Generate taps
float val;
float sum = 0.0f;
float tc = tapCount;
for (int i = 0; i < tapCount; i++) {
val = math::sinc(omega, (float)i - (tc / 2), FL_M_PI) * window_function::blackman(i, tc - 1);
taps[i] = val;
sum += val;
}
// Normalize taps and multiply by supplied factor
for (int i = 0; i < tapCount; i++) {
taps[i] *= factor;
taps[i] /= sum;
}
}
private:
float _cutoff, _transWidth, _sampleRate;
};
class BandPassBlackmanWindow : public filter_window::generic_complex_window {
public:
BandPassBlackmanWindow() {}
BandPassBlackmanWindow(float lowCutoff, float highCutoff, float transWidth, float sampleRate) { init(lowCutoff, highCutoff, transWidth, sampleRate); }
void init(float lowCutoff, float highCutoff, float transWidth, float sampleRate) {
assert(lowCutoff <= highCutoff);
_lowCutoff = lowCutoff;
_highCutoff = highCutoff;
_transWidth = transWidth;
_sampleRate = sampleRate;
// Calculate other values
_offset = (_lowCutoff + _highCutoff) / 2.0f;
_cutoff = fabs((_highCutoff - _lowCutoff) / 2.0f);
}
void setSampleRate(float sampleRate) {
_sampleRate = sampleRate;
}
void setCutoffs(float lowCutoff, float highCutoff) {
assert(lowCutoff <= highCutoff);
_lowCutoff = lowCutoff;
_highCutoff = highCutoff;
// Calculate other values
_offset = (_lowCutoff + _highCutoff) / 2.0f;
_cutoff = fabs((_highCutoff - _lowCutoff) / 2.0f);
}
void setLowCutoff(float lowCutoff) {
assert(lowCutoff <= _highCutoff);
_lowCutoff = lowCutoff;
// Calculate other values
_offset = (_lowCutoff + _highCutoff) / 2.0f;
_cutoff = fabs((_highCutoff - _lowCutoff) / 2.0f);
}
void setHighCutoff(float highCutoff) {
assert(_lowCutoff <= highCutoff);
_highCutoff = highCutoff;
// Calculate other values
_offset = (_lowCutoff + _highCutoff) / 2.0f;
_cutoff = fabs((_highCutoff - _lowCutoff) / 2.0f);
}
void setTransWidth(float transWidth) {
_transWidth = transWidth;
}
int getTapCount() {
float fc = _cutoff / _sampleRate;
if (fc > 1.0f) {
fc = 1.0f;
}
int _M = 4.0f / (_transWidth / _sampleRate);
if (_M < 4) {
_M = 4;
}
if (_M % 2 == 0) { _M++; }
return _M;
}
void createTaps(dsp::complex_t* taps, int tapCount, float factor = 1.0f) {
// Calculate cuttoff frequency
float omega = 2.0f * FL_M_PI * (_cutoff / _sampleRate);
if (omega > FL_M_PI) { omega = FL_M_PI; }
// Generate taps
float val;
float sum = 0.0f;
float tc = tapCount;
for (int i = 0; i < tapCount; i++) {
val = math::sinc(omega, (float)i - (tc / 2), FL_M_PI) * window_function::blackman(i, tc - 1);
taps[i].re = val;
taps[i].im = 0;
sum += val;
}
// Normalize taps and multiply by supplied factor
for (int i = 0; i < tapCount; i++) {
taps[i] = taps[i] * factor;
taps[i] = taps[i] / sum;
}
// Add offset
lv_32fc_t phase = lv_cmake(1.0f, 0.0f);
lv_32fc_t phaseDelta = lv_cmake(std::cos((-_offset / _sampleRate) * 2.0f * FL_M_PI), std::sin((-_offset / _sampleRate) * 2.0f * FL_M_PI));
volk_32fc_s32fc_x2_rotator_32fc((lv_32fc_t*)taps, (lv_32fc_t*)taps, phaseDelta, &phase, tapCount);
}
private:
float _lowCutoff, _highCutoff;
float _cutoff, _transWidth, _sampleRate, _offset;
};
}
class RRCTaps : public filter_window::generic_window {
public:
RRCTaps() {}
RRCTaps(int tapCount, float sampleRate, float baudRate, float alpha) { init(tapCount, sampleRate, baudRate, alpha); }
void init(int tapCount, float sampleRate, float baudRate, float alpha) {
_tapCount = tapCount;
_sampleRate = sampleRate;
_baudRate = baudRate;
_alpha = alpha;
}
int getTapCount() {
return _tapCount;
}
void setSampleRate(float sampleRate) {
_sampleRate = sampleRate;
}
void setBaudRate(float baudRate) {
_baudRate = baudRate;
}
void setTapCount(int count) {
_tapCount = count;
}
void setAlpha(float alpha) {
_alpha = alpha;
}
void createTaps(float* taps, int tapCount, float factor = 1.0f) {
// ======== CREDIT: GNU Radio =========
tapCount |= 1; // ensure that tapCount is odd
double spb = _sampleRate / _baudRate; // samples per bit/symbol
double scale = 0;
for (int i = 0; i < tapCount; i++) {
double x1, x2, x3, num, den;
double xindx = i - tapCount / 2;
x1 = FL_M_PI * xindx / spb;
x2 = 4 * _alpha * xindx / spb;
x3 = x2 * x2 - 1;
// Avoid Rounding errors...
if (fabs(x3) >= 0.000001) {
if (i != tapCount / 2)
num = cos((1 + _alpha) * x1) +
sin((1 - _alpha) * x1) / (4 * _alpha * xindx / spb);
else
num = cos((1 + _alpha) * x1) + (1 - _alpha) * FL_M_PI / (4 * _alpha);
den = x3 * FL_M_PI;
}
else {
if (_alpha == 1) {
taps[i] = -1;
scale += taps[i];
continue;
}
x3 = (1 - _alpha) * x1;
x2 = (1 + _alpha) * x1;
num = (sin(x2) * (1 + _alpha) * FL_M_PI -
cos(x3) * ((1 - _alpha) * FL_M_PI * spb) / (4 * _alpha * xindx) +
sin(x3) * spb * spb / (4 * _alpha * xindx * xindx));
den = -32 * FL_M_PI * _alpha * _alpha * xindx / spb;
}
taps[i] = 4 * _alpha * num / den;
scale += taps[i];
}
for (int i = 0; i < tapCount; i++) {
taps[i] = taps[i] / scale;
}
}
private:
int _tapCount;
float _sampleRate, _baudRate, _alpha;
};
// class NotchWindow : public filter_window::generic_complex_window {
// public:
// NotchWindow() {}
// NotchWindow(float frequency, float width, float sampleRate, int tapCount) { init(frequency, width, sampleRate, tapCount); }
// ~NotchWindow() {
// if (fft_in) { fftwf_free(fft_in); }
// if (fft_out) { fftwf_free(fft_out); }
// fftwf_destroy_plan(fft_plan);
// }
// void init(float frequency, float width, float sampleRate, int tapCount) {
// _frequency = frequency;
// _width = width;
// _sampleRate = sampleRate;
// _tapCount = tapCount;
// // Ensure the number of taps is even
// if (_tapCount & 1) { _tapCount++; }
// fft_in = (complex_t*)fftwf_malloc(_tapCount * sizeof(complex_t));
// fft_out = (complex_t*)fftwf_malloc(_tapCount * sizeof(complex_t));
// fft_plan = fftwf_plan_dft_1d(_tapCount, (fftwf_complex*)fft_in, (fftwf_complex*)fft_out, FFTW_BACKWARD, FFTW_ESTIMATE);
// }
// void setFrequency(float frequency) {
// _frequency = frequency;
// }
// void setWidth(float width) {
// _width = width;
// }
// void setSampleRate(float sampleRate) {
// _sampleRate = sampleRate;
// }
// void setTapCount(int count) {
// _tapCount = count;
// // Ensure the number of taps is even
// // Free buffers
// if (fft_in) { fftwf_free(fft_in); }
// if (fft_out) { fftwf_free(fft_out); }
// fftwf_destroy_plan(fft_plan);
// // Reallocate
// fft_in = (complex_t*)fftwf_malloc(_tapCount * sizeof(complex_t));
// fft_out = (complex_t*)fftwf_malloc(_tapCount * sizeof(complex_t));
// // Create new plan
// fft_plan = fftwf_plan_dft_1d(_tapCount, (fftwf_complex*)fft_in, (fftwf_complex*)fft_out, FFTW_BACKWARD, FFTW_ESTIMATE);
// }
// int getTapCount() {
// return _tapCount;
// }
// void createTaps(complex_t* taps, int tapCount, float factor = 1.0f) {
// float ratio = _sampleRate / (float)tapCount;
// int thalf = tapCount / 2;
// float start = _frequency - (_width / 2.0f);
// float stop = _frequency + (_width / 2.0f);
// // Fill taps
// float freq;
// float pratio = 2.0f * FL_M_PI / (float)tapCount;
// complex_t phaseDiff = {cosf(pratio), -sinf(pratio)};
// complex_t phasor = {1, 0};
// for (int i = 0; i < tapCount; i++) {
// freq = (i < thalf) ? ((float)i * ratio) : -((float)(tapCount - i) * ratio);
// if (freq >= start && freq <= stop) {
// fft_in[i] = {0, 0};
// }
// else {
// fft_in[i] = phasor;
// }
// phasor = phasor * phaseDiff;
// }
// // Run IFFT
// fftwf_execute(fft_plan);
// // Apply window and copy to output
// for (int i = 0; i < tapCount; i++) {
// taps[tapCount - i - 1] = fft_out[i] / (float)tapCount;
// }
// }
// private:
// complex_t* fft_in = NULL;
// complex_t* fft_out = NULL;
// float _frequency, _width, _sampleRate;
// int _tapCount;
// fftwf_plan fft_plan;
// };
class NotchWindow : public filter_window::generic_complex_window {
public:
NotchWindow() {}
NotchWindow(float frequency, float width, float sampleRate, int tapCount) { init(frequency, width, sampleRate, tapCount); }
void init(float frequency, float width, float sampleRate, int tapCount) {
_frequency = frequency;
_sampleRate = sampleRate;
_tapCount = tapCount;
}
void setFrequency(float frequency) {
_frequency = frequency;
}
void setWidth(float width) {}
void setSampleRate(float sampleRate) {
_sampleRate = sampleRate;
}
void setTapCount(int count) {
_tapCount = count;
}
int getTapCount() {
return _tapCount;
}
void createTaps(complex_t* taps, int tapCount, float factor = 1.0f) {
// Generate exponential decay
float fact = 1.0f / (float)tapCount;
for (int i = 0; i < tapCount; i++) {
taps[tapCount - i - 1] = { expf(-fact * i) * (float)window_function::blackman(i, tapCount - 1), 0 };
}
// Frequency translate it to the right place
lv_32fc_t phase = lv_cmake(1.0f, 0.0f);
lv_32fc_t phaseDelta = lv_cmake(std::cos((-_frequency / _sampleRate) * 2.0f * FL_M_PI), std::sin((-_frequency / _sampleRate) * 2.0f * FL_M_PI));
volk_32fc_s32fc_x2_rotator_32fc((lv_32fc_t*)taps, (lv_32fc_t*)taps, phaseDelta, &phase, tapCount);
}
private:
float _frequency, _sampleRate;
int _tapCount;
};
}

69
core/src/gui/main_window.cpp
Wyświetl plik

@ -6,7 +6,7 @@
#include <complex>
#include <gui/widgets/waterfall.h>
#include <gui/widgets/frequency_select.h>
#include <signal_path/dsp.h>
#include <signal_path/iq_frontend.h>
#include <gui/icons.h>
#include <gui/widgets/bandplan.h>
#include <gui/style.h>
@ -88,8 +88,8 @@ void MainWindow::init() {
fft_out = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize);
fftwPlan = fftwf_plan_dft_1d(fftSize, fft_in, fft_out, FFTW_FORWARD, FFTW_ESTIMATE);
sigpath::signalPath.init(8000000, 20, fftSize, &dummyStream, (dsp::complex_t*)fft_in, fftHandler, this);
sigpath::signalPath.start();
sigpath::iqFrontEnd.init(&dummyStream, 8000000, true, 1, false, 1024, 20.0, IQFrontEnd::FFTWindow::NUTTALL, acquireFFTBuffer, releaseFFTBuffer, this);
sigpath::iqFrontEnd.start();
vfoCreatedHandler.handler = vfoAddedHandler;
vfoCreatedHandler.ctx = this;
@ -227,37 +227,11 @@ void MainWindow::init() {
core::moduleManager.doPostInitAll();
}
void MainWindow::fftHandler(dsp::complex_t* samples, int count, void* ctx) {
MainWindow* _this = (MainWindow*)ctx;
std::lock_guard<std::mutex> lck(_this->fft_mtx);
float* MainWindow::acquireFFTBuffer(void* ctx) {
return gui::waterfall.getFFTBuffer();
}
// Check if the count is valid
if (count > _this->fftSize) {
return;
}
// Apply window
volk_32fc_32f_multiply_32fc((lv_32fc_t*)_this->fft_in, (lv_32fc_t*)samples, sigpath::signalPath.fftTaps, count);
// Zero out the rest of the samples
if (count < _this->fftSize) {
memset(&_this->fft_in[count], 0, (_this->fftSize - count) * sizeof(dsp::complex_t));
}
// Execute FFT
fftwf_execute(_this->fftwPlan);
// Get the FFT buffer
float* fftBuf = gui::waterfall.getFFTBuffer();
if (fftBuf == NULL) {
gui::waterfall.pushFFT();
return;
}
// Take power of spectrum
volk_32fc_s32f_power_spectrum_32f(fftBuf, (lv_32fc_t*)_this->fft_out, _this->fftSize, _this->fftSize);
// Push back data
void MainWindow::releaseFFTBuffer(void* ctx) {
gui::waterfall.pushFFT();
}
@ -530,9 +504,9 @@ void MainWindow::draw() {
ImGui::Checkbox("Show demo window", &demoWindow);
ImGui::Text("ImGui version: %s", ImGui::GetVersion());
ImGui::Checkbox("Bypass buffering", &sigpath::signalPath.inputBuffer.bypass);
// ImGui::Checkbox("Bypass buffering", &sigpath::iqFrontEnd.inputBuffer.bypass);
ImGui::Text("Buffering: %d", (sigpath::signalPath.inputBuffer.writeCur - sigpath::signalPath.inputBuffer.readCur + 32) % 32);
// ImGui::Text("Buffering: %d", (sigpath::iqFrontEnd.inputBuffer.writeCur - sigpath::iqFrontEnd.inputBuffer.readCur + 32) % 32);
if (ImGui::Button("Test Bug")) {
spdlog::error("Will this make the software crash?");
@ -680,7 +654,7 @@ void MainWindow::draw() {
void MainWindow::setPlayState(bool _playing) {
if (_playing == playing) { return; }
if (_playing) {
sigpath::signalPath.inputBuffer.flush();
sigpath::iqFrontEnd.flushInputBuffer();
sigpath::sourceManager.start();
sigpath::sourceManager.tune(gui::waterfall.getCenterFrequency());
playing = true;
@ -690,7 +664,7 @@ void MainWindow::setPlayState(bool _playing) {
playing = false;
onPlayStateChange.emit(false);
sigpath::sourceManager.stop();
sigpath::signalPath.inputBuffer.flush();
sigpath::iqFrontEnd.flushInputBuffer();
}
}
@ -702,27 +676,6 @@ bool MainWindow::sdrIsRunning() {
return playing;
}
void MainWindow::setFFTSize(int size) {
std::lock_guard<std::mutex> lck(fft_mtx);
fftSize = size;
gui::waterfall.setRawFFTSize(fftSize);
sigpath::signalPath.setFFTSize(fftSize);
fftwf_destroy_plan(fftwPlan);
fftwf_free(fft_in);
fftwf_free(fft_out);
fft_in = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize);
fft_out = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize);
fftwPlan = fftwf_plan_dft_1d(fftSize, fft_in, fft_out, FFTW_FORWARD, FFTW_ESTIMATE);
}
void MainWindow::setFFTWindow(int win) {
std::lock_guard<std::mutex> lck(fft_mtx);
sigpath::signalPath.setFFTWindow(win);
}
bool MainWindow::isPlaying() {
return playing;
}

6
core/src/gui/main_window.h
Wyświetl plik

@ -17,10 +17,11 @@ public:
void draw();
void setViewBandwidthSlider(float bandwidth);
bool sdrIsRunning();
void setFFTSize(int size);
void setFFTWindow(int win);
void setFirstMenuRender();
static float* acquireFFTBuffer(void* ctx);
static void releaseFFTBuffer(void* ctx);
// TODO: Replace with it's own class
void setVFO(double freq);
@ -33,7 +34,6 @@ public:
Event<bool> onPlayStateChange;
private:
static void fftHandler(dsp::complex_t* samples, int count, void* ctx);
static void vfoAddedHandler(VFOManager::VFO* vfo, void* ctx);
// FFT Variables

22
core/src/gui/menus/display.cpp
Wyświetl plik

@ -52,6 +52,12 @@ namespace displaymenu {
int fftSizeId = 0;
const IQFrontEnd::FFTWindow fftWindowList[] = {
IQFrontEnd::FFTWindow::RECTANGULAR,
IQFrontEnd::FFTWindow::BLACKMAN,
IQFrontEnd::FFTWindow::NUTTALL
};
void updateFFTHoldSpeed() {
gui::waterfall.setFFTHoldSpeed(fftHoldSpeed / (fftRate * 10.0f));
}
@ -89,13 +95,13 @@ namespace displaymenu {
break;
}
}
gui::mainWindow.setFFTSize(FFTSizes[fftSizeId]);
sigpath::iqFrontEnd.setFFTSize(FFTSizes[fftSizeId]);
fftRate = core::configManager.conf["fftRate"];
sigpath::signalPath.setFFTRate(fftRate);
sigpath::iqFrontEnd.setFFTRate(fftRate);
selectedWindow = std::clamp<int>((int)core::configManager.conf["fftWindow"], 0, _FFT_WINDOW_COUNT - 1);
gui::mainWindow.setFFTWindow(selectedWindow);
selectedWindow = std::clamp<int>((int)core::configManager.conf["fftWindow"], 0, (sizeof(fftWindowList) / sizeof(IQFrontEnd::FFTWindow)) - 1);
sigpath::iqFrontEnd.setFFTWindow(fftWindowList[selectedWindow]);
gui::menu.locked = core::configManager.conf["lockMenuOrder"];
@ -172,7 +178,7 @@ namespace displaymenu {
ImGui::SetNextItemWidth(menuWidth - ImGui::GetCursorPosX());
if (ImGui::InputInt("##sdrpp_fft_rate", &fftRate, 1, 10)) {
fftRate = std::max<int>(1, fftRate);
sigpath::signalPath.setFFTRate(fftRate);
sigpath::iqFrontEnd.setFFTRate(fftRate);
updateFFTHoldSpeed();
core::configManager.acquire();
core::configManager.conf["fftRate"] = fftRate;
@ -182,7 +188,7 @@ namespace displaymenu {
ImGui::LeftLabel("FFT Size");
ImGui::SetNextItemWidth(menuWidth - ImGui::GetCursorPosX());
if (ImGui::Combo("##sdrpp_fft_size", &fftSizeId, FFTSizesStr)) {
gui::mainWindow.setFFTSize(FFTSizes[fftSizeId]);
sigpath::iqFrontEnd.setFFTSize(FFTSizes[fftSizeId]);
core::configManager.acquire();
core::configManager.conf["fftSize"] = FFTSizes[fftSizeId];
core::configManager.release(true);
@ -190,8 +196,8 @@ namespace displaymenu {
ImGui::LeftLabel("FFT Window");
ImGui::SetNextItemWidth(menuWidth - ImGui::GetCursorPosX());
if (ImGui::Combo("##sdrpp_fft_window", &selectedWindow, "Rectangular\0Blackman\0")) {
gui::mainWindow.setFFTWindow(selectedWindow);
if (ImGui::Combo("##sdrpp_fft_window", &selectedWindow, "Rectangular\0Blackman\0Nuttall\0")) {
sigpath::iqFrontEnd.setFFTWindow(fftWindowList[selectedWindow]);
core::configManager.acquire();
core::configManager.conf["fftWindow"] = selectedWindow;
core::configManager.release(true);

8
core/src/gui/menus/source.cpp
Wyświetl plik

@ -138,12 +138,12 @@ namespace sourcemenu {
offsetMode = core::configManager.conf["offsetMode"];
decimationPower = core::configManager.conf["decimationPower"];
iqCorrection = core::configManager.conf["iqCorrection"];
sigpath::signalPath.setIQCorrection(iqCorrection);
sigpath::iqFrontEnd.setDCBlocking(iqCorrection);
updateOffset();
refreshSources();
selectSource(selected);
sigpath::signalPath.setDecimation(decimationPower);
sigpath::iqFrontEnd.setDecimation(1 << decimationPower);
sourceRegisteredHandler.handler = onSourceRegistered;
sourceUnregisterHandler.handler = onSourceUnregister;
@ -174,7 +174,7 @@ namespace sourcemenu {
sigpath::sourceManager.showSelectedMenu();
if (ImGui::Checkbox("IQ Correction##_sdrpp_iq_corr", &iqCorrection)) {
sigpath::signalPath.setIQCorrection(iqCorrection);
sigpath::iqFrontEnd.setDCBlocking(iqCorrection);
core::configManager.acquire();
core::configManager.conf["iqCorrection"] = iqCorrection;
core::configManager.release(true);
@ -209,7 +209,7 @@ namespace sourcemenu {
ImGui::LeftLabel("Decimation");
ImGui::SetNextItemWidth(itemWidth - ImGui::GetCursorPosX());
if (ImGui::Combo("##source_decim", &decimationPower, decimationStages)) {
sigpath::signalPath.setDecimation(decimationPower);
sigpath::iqFrontEnd.setDecimation(1 << decimationPower);
core::configManager.acquire();
core::configManager.conf["decimationPower"] = decimationPower;
core::configManager.release(true);

13
core/src/server.cpp
Wyświetl plik

@ -8,13 +8,14 @@
#include <signal_path/signal_path.h>
#include <gui/smgui.h>
#include <utils/optionlist.h>
#include <dsp/compression.h>
#include "dsp/compression/sample_stream_compressor.h"
#include "dsp/sink/handler_sink.h"
#include <zstd.h>
namespace server {
dsp::stream<dsp::complex_t> dummyInput;
dsp::DynamicRangeCompressor comp;
dsp::HandlerSink<uint8_t> hnd;
dsp::compression::SampleStreamCompressor comp;
dsp::sink::Handler<uint8_t> hnd;
net::Conn client;
uint8_t* rbuf = NULL;
uint8_t* sbuf = NULL;
@ -49,7 +50,7 @@ namespace server {
spdlog::info("=====| SERVER MODE |=====");
// Init DSP
comp.init(&dummyInput, dsp::PCM_TYPE_I8);
comp.init(&dummyInput, dsp::compression::PCM_TYPE_I8);
hnd.init(&comp.out, _testServerHandler, NULL);
rbuf = new uint8_t[SERVER_MAX_PACKET_SIZE];
sbuf = new uint8_t[SERVER_MAX_PACKET_SIZE];
@ -189,7 +190,7 @@ namespace server {
// Perform settings reset
sigpath::sourceManager.stop();
comp.setPCMType(dsp::PCM_TYPE_I16);
comp.setPCMType(dsp::compression::PCM_TYPE_I16);
compression = false;
sendSampleRate(sampleRate);
@ -291,7 +292,7 @@ namespace server {
sendCommandAck(COMMAND_SET_FREQUENCY, 0);
}
else if (cmd == COMMAND_SET_SAMPLE_TYPE && len == 1) {
dsp::PCMType type = (dsp::PCMType)*(uint8_t*)data;
dsp::compression::PCMType type = (dsp::compression::PCMType)*(uint8_t*)data;
comp.setPCMType(type);
}
else if (cmd == COMMAND_SET_COMPRESSION && len == 1) {

278
core/src/signal_path/dsp.cpp
Wyświetl plik

@ -1,278 +0,0 @@
#include <signal_path/dsp.h>
#include <core.h>
SignalPath::SignalPath() {
}
void SignalPath::init(uint64_t sampleRate, int fftRate, int fftSize, dsp::stream<dsp::complex_t>* input, dsp::complex_t* fftBuffer, void fftHandler(dsp::complex_t*, int, void*), void* fftHandlerCtx) {
this->sampleRate = sampleRate;
this->sourceSampleRate = sampleRate;
this->fftRate = fftRate;
this->fftSize = fftSize;
inputBlockSize = sampleRate / 200.0f;
halfBandWindow.init(1000000, 200000, 4000000);
inputBuffer.init(input);
corrector.init(&inputBuffer.out, 50.0f / sampleRate);
split.init(&inputBuffer.out);
// Allocate the fft taps
fftTaps = new float[fftSize];
// Calculate the parameters for the reshaper
int fftInterval = sampleRate / fftRate;
fftOutputSampleCount = std::min<int>(fftInterval, fftSize);
int fftSkip = fftInterval - fftOutputSampleCount;
// Generate FFT Windows
generateFFTWindow(fftWindow, fftTaps, fftOutputSampleCount);
reshape.init(&fftStream, fftSize, fftSkip);
split.bindStream(&fftStream);
fftHandlerSink.init(&reshape.out, fftHandler, fftHandlerCtx);
}
void SignalPath::setSampleRate(double sampleRate) {
this->sampleRate = sampleRate;
// Stop the splitter
split.stop();
reshape.stop();
// Stop all VFOs
for (auto const& [name, vfo] : vfos) {
vfo.vfo->stop();
}
updateFFTDSP();
// Update the sample rate for all VFOs and start them up
for (auto const& [name, vfo] : vfos) {
vfo.vfo->setInSampleRate(sampleRate);
vfo.vfo->start();
}
// Update correction rate on the IQ corrector
corrector.setCorrectionRate(50.0f / sampleRate);
// Start the splitter
split.start();
reshape.start();
}
double SignalPath::getSampleRate() {
return sampleRate;
}
void SignalPath::start() {
for (auto& decimator : decimators) {
decimator->start();
}
inputBuffer.start();
if (iqCorrection) { corrector.start(); }
split.start();
reshape.start();
fftHandlerSink.start();
running = true;
}
void SignalPath::stop() {
for (auto& decimator : decimators) {
decimator->stop();
}
inputBuffer.stop();
if (iqCorrection) { corrector.stop(); }
split.stop();
reshape.stop();
fftHandlerSink.stop();
running = false;
}
dsp::VFO* SignalPath::addVFO(std::string name, double outSampleRate, double bandwidth, double offset) {
if (vfos.find(name) != vfos.end()) {
return NULL;
}
VFO_t vfo;
vfo.inputStream = new dsp::stream<dsp::complex_t>;
split.bindStream(vfo.inputStream);
vfo.vfo = new dsp::VFO();
vfo.vfo->init(vfo.inputStream, offset, sampleRate, outSampleRate, bandwidth);
vfo.vfo->start();
vfos[name] = vfo;
return vfo.vfo;
}
void SignalPath::removeVFO(std::string name) {
if (vfos.find(name) == vfos.end()) {
return;
}
VFO_t vfo = vfos[name];
vfo.vfo->stop();
split.unbindStream(vfo.inputStream);
delete vfo.vfo;
delete vfo.inputStream;
vfos.erase(name);
}
void SignalPath::setInput(dsp::stream<dsp::complex_t>* input) {
inputBuffer.setInput(input);
}
void SignalPath::bindIQStream(dsp::stream<dsp::complex_t>* stream) {
split.bindStream(stream);
}
void SignalPath::unbindIQStream(dsp::stream<dsp::complex_t>* stream) {
split.unbindStream(stream);
}
void SignalPath::setFFTSize(int size) {
fftSize = size;
reshape.stop();
updateFFTDSP();
reshape.start();
}
void SignalPath::setFFTRate(double rate) {
fftRate = rate;
reshape.stop();
updateFFTDSP();
reshape.start();
}
void SignalPath::startFFT() {
reshape.start();
fftHandlerSink.start();
}
void SignalPath::stopFFT() {
reshape.stop();
fftHandlerSink.stop();
}
void SignalPath::setBuffering(bool enabled) {
inputBuffer.bypass = !enabled;
}
void SignalPath::setDecimation(int dec) {
decimation = dec;
if (running) { split.stop(); }
// Stop existing decimators
if (!decimators.empty()) {
for (auto& decimator : decimators) {
decimator->stop();
}
for (auto& decimator : decimators) {
delete decimator;
}
}
decimators.clear();
// If no decimation, reconnect
if (!dec) {
if (iqCorrection) {
split.setInput(&corrector.out);
}
else {
split.setInput(&inputBuffer.out);
}
if (running) { split.start(); }
core::setInputSampleRate(sourceSampleRate);
return;
}
// Create new decimators
for (int i = 0; i < dec; i++) {
dsp::HalfDecimator<dsp::complex_t>* decimator;
if (iqCorrection && i == 0) {
decimator = new dsp::HalfDecimator<dsp::complex_t>(&corrector.out, &halfBandWindow);
}
else if (i == 0) {
decimator = new dsp::HalfDecimator<dsp::complex_t>(&inputBuffer.out, &halfBandWindow);
}
else {
decimator = new dsp::HalfDecimator<dsp::complex_t>(&decimators[i - 1]->out, &halfBandWindow);
}
if (running) { decimator->start(); }
decimators.push_back(decimator);
}
split.setInput(&decimators[decimators.size() - 1]->out);
if (running) { split.start(); }
// Update the DSP sample rate
core::setInputSampleRate(sourceSampleRate);
}
void SignalPath::setIQCorrection(bool enabled) {
if (iqCorrection == enabled) { return; }
if (!iqCorrection && enabled) {
if (decimation) {
decimators[0]->setInput(&corrector.out);
}
else {
split.setInput(&corrector.out);
}
if (running) { corrector.start(); }
}
else if (iqCorrection && !enabled) {
if (running) { corrector.stop(); }
if (decimation) {
decimators[0]->setInput(&inputBuffer.out);
}
else {
split.setInput(&inputBuffer.out);
}
}
iqCorrection = enabled;
if (!enabled) {
corrector.offset.re = 0;
corrector.offset.im = 0;
}
}
void SignalPath::setFFTWindow(int win) {
fftWindow = win;
reshape.stop();
updateFFTDSP();
reshape.start();
}
void SignalPath::generateFFTWindow(int win, float* taps, int size) {
if (win == FFT_WINDOW_RECTANGULAR) {
for (int i = 0; i < size; i++) {
taps[i] = (i % 2) ? 1 : -1;
}
}
else if (win == FFT_WINDOW_BLACKMAN) {
for (int i = 0; i < size; i++) {
taps[i] = ((i % 2) ? dsp::window_function::blackman(i, size) : -dsp::window_function::blackman(i, size)) * 2;
}
}
}
void SignalPath::updateFFTDSP() {
// Allocate the fft taps
if (fftTaps != NULL) { delete[] fftTaps; }
fftTaps = new float[fftSize];
// Calculate the parameters for the reshaper
int fftInterval = sampleRate / fftRate;
fftOutputSampleCount = std::min<int>(fftInterval, fftSize);
int fftSkip = fftInterval - fftOutputSampleCount;
// Generate FFT Windows
generateFFTWindow(fftWindow, fftTaps, fftOutputSampleCount);
// Update parameters of the reshaper
reshape.setKeep(fftOutputSampleCount);
reshape.setSkip(fftSkip);
spdlog::info("Updating FFT DSP settings: Keep: {0}, Skip: {1}", fftOutputSampleCount, fftSkip);
}

74
core/src/signal_path/dsp.h
Wyświetl plik

@ -1,74 +0,0 @@
#pragma once
#include <dsp/routing.h>
#include <dsp/vfo.h>
#include <map>
#include <dsp/sink.h>
#include <dsp/decimation.h>
#include <dsp/correction.h>
enum {
FFT_WINDOW_RECTANGULAR,
FFT_WINDOW_BLACKMAN,
_FFT_WINDOW_COUNT
};
class SignalPath {
public:
SignalPath();
void init(uint64_t sampleRate, int fftRate, int fftSize, dsp::stream<dsp::complex_t>* input, dsp::complex_t* fftBuffer, void fftHandler(dsp::complex_t*, int, void*), void* fftHandlerCtx);
void start();
void stop();
void setSampleRate(double sampleRate);
double getSampleRate();
dsp::VFO* addVFO(std::string name, double outSampleRate, double bandwidth, double offset);
void removeVFO(std::string name);
void setInput(dsp::stream<dsp::complex_t>* input);
void bindIQStream(dsp::stream<dsp::complex_t>* stream);
void unbindIQStream(dsp::stream<dsp::complex_t>* stream);
void setFFTSize(int size);
void setFFTRate(double rate);
void startFFT();
void stopFFT();
void setBuffering(bool enabled);
void setDecimation(int dec);
void setIQCorrection(bool enabled);
void setFFTWindow(int win);
dsp::SampleFrameBuffer<dsp::complex_t> inputBuffer;
double sourceSampleRate = 0;
int decimation = 0;
float* fftTaps = NULL;
private:
void generateFFTWindow(int win, float* taps, int size);
void updateFFTDSP();
struct VFO_t {
dsp::stream<dsp::complex_t>* inputStream;
dsp::VFO* vfo;
};
dsp::Splitter<dsp::complex_t> split;
dsp::IQCorrector corrector;
// FFT
dsp::stream<dsp::complex_t> fftStream;
dsp::Reshaper<dsp::complex_t> reshape;
dsp::HandlerSink<dsp::complex_t> fftHandlerSink;
// VFO
std::map<std::string, VFO_t> vfos;
std::vector<dsp::HalfDecimator<dsp::complex_t>*> decimators;
dsp::filter_window::BlackmanWindow halfBandWindow;
int fftOutputSampleCount = 0;
double sampleRate;
double fftRate;
int fftSize;
int inputBlockSize;
int fftWindow = FFT_WINDOW_RECTANGULAR;
bool bufferingEnabled = false;
bool running = false;
bool iqCorrection = false;
};

2
core/src/signal_path/signal_path.cpp
Wyświetl plik

@ -1,7 +1,7 @@
#include <signal_path/signal_path.h>
namespace sigpath {
SignalPath signalPath;
IQFrontEnd iqFrontEnd;
VFOManager vfoManager;
SourceManager sourceManager;
SinkManager sinkManager;

10
core/src/signal_path/signal_path.h
Wyświetl plik

@ -1,12 +1,12 @@
#pragma once
#include <signal_path/dsp.h>
#include <signal_path/vfo_manager.h>
#include <signal_path/source.h>
#include <signal_path/sink.h>
#include "iq_frontend.h"
#include "vfo_manager.h"
#include "source.h"
#include "sink.h"
#include <module.h>
namespace sigpath {
SDRPP_EXPORT SignalPath signalPath;
SDRPP_EXPORT IQFrontEnd iqFrontEnd;
SDRPP_EXPORT VFOManager vfoManager;
SDRPP_EXPORT SourceManager sourceManager;
SDRPP_EXPORT SinkManager sinkManager;

2
core/src/signal_path/sink.cpp
Wyświetl plik

@ -24,7 +24,7 @@ void SinkManager::Stream::init(dsp::stream<dsp::stereo_t>* in, EventHandler<floa
_sampleRate = sampleRate;
splitter.init(_in);
splitter.bindStream(&volumeInput);
volumeAjust.init(&volumeInput, 1.0f);
volumeAjust.init(&volumeInput, 1.0f, false);
sinkOut = &volumeAjust.out;
}

12
core/src/signal_path/sink.h
Wyświetl plik

@ -3,9 +3,9 @@
#include <string>
#include <dsp/stream.h>
#include <dsp/types.h>
#include <dsp/routing.h>
#include <dsp/processing.h>
#include <dsp/sink.h>
#include "../dsp/routing/splitter.h"
#include "../dsp/audio/volume.h"
#include "../dsp/sink/null_sink.h"
#include <mutex>
#include <utils/event.h>
#include <vector>
@ -52,10 +52,10 @@ public:
private:
dsp::stream<dsp::stereo_t>* _in;
dsp::Splitter<dsp::stereo_t> splitter;
dsp::routing::Splitter<dsp::stereo_t> splitter;
SinkManager::Sink* sink;
dsp::stream<dsp::stereo_t> volumeInput;
dsp::Volume<dsp::stereo_t> volumeAjust;
dsp::audio::Volume volumeAjust;
std::mutex ctrlMtx;
float _sampleRate;
int providerId = 0;
@ -85,7 +85,7 @@ public:
}
private:
dsp::NullSink<dsp::stereo_t> ns;
dsp::sink::Null<dsp::stereo_t> ns;
};
void registerSinkProvider(std::string name, SinkProvider provider);

4
core/src/signal_path/source.cpp
Wyświetl plik

@ -26,7 +26,7 @@ void SourceManager::unregisterSource(std::string name) {
if (selectedHandler != NULL) {
sources[selectedName]->deselectHandler(sources[selectedName]->ctx);
}
sigpath::signalPath.setInput(&nullSource);
sigpath::iqFrontEnd.setInput(&nullSource);
selectedHandler = NULL;
}
sources.erase(name);
@ -54,7 +54,7 @@ void SourceManager::selectSource(std::string name) {
server::setInput(selectedHandler->stream);
}
else {
sigpath::signalPath.setInput(selectedHandler->stream);
sigpath::iqFrontEnd.setInput(selectedHandler->stream);
}
// Set server input here
}

8
core/src/signal_path/vfo_manager.cpp
Wyświetl plik

@ -4,7 +4,7 @@
VFOManager::VFO::VFO(std::string name, int reference, double offset, double bandwidth, double sampleRate, double minBandwidth, double maxBandwidth, bool bandwidthLocked) {
this->name = name;
dspVFO = sigpath::signalPath.addVFO(name, sampleRate, bandwidth, offset);
dspVFO = sigpath::iqFrontEnd.addVFO(name, sampleRate, bandwidth, offset);
wtfVFO = new ImGui::WaterfallVFO;
wtfVFO->setReference(reference);
wtfVFO->setBandwidth(bandwidth);
@ -12,7 +12,7 @@ VFOManager::VFO::VFO(std::string name, int reference, double offset, double band
wtfVFO->minBandwidth = minBandwidth;
wtfVFO->maxBandwidth = maxBandwidth;
wtfVFO->bandwidthLocked = bandwidthLocked;
output = dspVFO->out;
output = &dspVFO->out;
gui::waterfall.vfos[name] = wtfVFO;
}
@ -22,7 +22,7 @@ VFOManager::VFO::~VFO() {
if (gui::waterfall.selectedVFO == name) {
gui::waterfall.selectFirstVFO();
}
sigpath::signalPath.removeVFO(name);
sigpath::iqFrontEnd.removeVFO(name);
delete wtfVFO;
}
@ -46,7 +46,7 @@ void VFOManager::VFO::setBandwidth(double bandwidth, bool updateWaterfall) {
}
void VFOManager::VFO::setSampleRate(double sampleRate, double bandwidth) {
dspVFO->setOutSampleRate(sampleRate, bandwidth);
dspVFO->setOutSamplerate(sampleRate, bandwidth);
wtfVFO->setBandwidth(bandwidth);
}

4
core/src/signal_path/vfo_manager.h
Wyświetl plik

@ -1,5 +1,5 @@
#pragma once
#include <dsp/vfo.h>
#include "../dsp/channel/rx_vfo.h"
#include <gui/widgets/waterfall.h>
#include <utils/event.h>
@ -30,7 +30,7 @@ public:
friend class VFOManager;
dsp::VFO* dspVFO;
dsp::channel::RxVFO* dspVFO;
ImGui::WaterfallVFO* wtfVFO;
private:

16
decoder_modules/radio/src/demodulators/am.h
Wyświetl plik

@ -1,7 +1,7 @@
#pragma once
#include "../demod.h"
#include <dsp/demodulator.h>
#include <dsp/filter.h>
#include <dsp/demod/am.h>
#include <dsp/convert/mono_to_stereo.h>
namespace demod {
class AM : public Demodulator {
@ -20,20 +20,17 @@ namespace demod {
this->name = name;
// Define structure
demod.init(input);
agc.init(&demod.out, 20.0f, getIFSampleRate());
m2s.init(&agc.out);
demod.init(input, dsp::demod::AM::AGCMode::CARRIER, 200000.0 / getIFSampleRate());
m2s.init(&demod.out);
}
void start() {
demod.start();
agc.start();
m2s.start();
}
void stop() {
demod.stop();
agc.stop();
m2s.stop();
}
@ -71,9 +68,8 @@ namespace demod {
dsp::stream<dsp::stereo_t>* getOutput() { return &m2s.out; }
private:
dsp::AMDemod demod;
dsp::AGC agc;
dsp::MonoToStereo m2s;
dsp::demod::AM demod;
dsp::convert::MonoToStereo m2s;
std::string name;
};

20
decoder_modules/radio/src/demodulators/cw.h
Wyświetl plik

@ -1,7 +1,9 @@
#pragma once
#include "../demod.h"
#include <dsp/demodulator.h>
#include <dsp/filter.h>
#include <dsp/channel/frequency_xlator.h>
#include <dsp/convert/complex_to_real.h>
#include <dsp/convert/mono_to_stereo.h>
#include <dsp/loop/agc.h>
namespace demod {
class CW : public Demodulator {
@ -30,9 +32,9 @@ namespace demod {
config->release();
// Define structure
xlator.init(input, getIFSampleRate(), tone);
xlator.init(input, tone, getIFSampleRate());
c2r.init(&xlator.out);
agc.init(&c2r.out, 20.0f, getIFSampleRate());
agc.init(&c2r.out, 1.0, 200000.0 / getIFSampleRate());
m2s.init(&agc.out);
}
@ -55,7 +57,7 @@ namespace demod {
ImGui::FillWidth();
if (ImGui::InputInt(("Stereo##_radio_cw_tone_" + name).c_str(), &tone, 10, 100)) {
tone = std::clamp<int>(tone, 250, 1250);
xlator.setFrequency(tone);
xlator.setOffset(tone, getIFSampleRate());
afbwChangeHandler.handler(getAFBandwidth(_bandwidth), afbwChangeHandler.ctx);
_config->acquire();
_config->conf[name][getName()]["tone"] = tone;
@ -94,10 +96,10 @@ namespace demod {
private:
ConfigManager* _config = NULL;
dsp::FrequencyXlator<dsp::complex_t> xlator;
dsp::ComplexToReal c2r;
dsp::AGC agc;
dsp::MonoToStereo m2s;
dsp::channel::FrequencyXlator xlator;
dsp::convert::ComplexToReal c2r;
dsp::loop::AGC<float> agc;
dsp::convert::MonoToStereo m2s;
std::string name;

18
decoder_modules/radio/src/demodulators/dsb.h
Wyświetl plik

@ -1,7 +1,7 @@
#pragma once
#include "../demod.h"
#include <dsp/demodulator.h>
#include <dsp/filter.h>
#include <dsp/demod/ssb.h>
#include <dsp/convert/mono_to_stereo.h>
namespace demod {
class DSB : public Demodulator {
@ -20,20 +20,17 @@ namespace demod {
this->name = name;
// Define structure
demod.init(input, getIFSampleRate(), bandwidth, dsp::SSBDemod::MODE_DSB);
agc.init(&demod.out, 20.0f, getIFSampleRate());
m2s.init(&agc.out);
demod.init(input, dsp::demod::SSB::Mode::DSB, bandwidth, getIFSampleRate(), 200000.0 / getIFSampleRate());
m2s.init(&demod.out);
}
void start() {
demod.start();
agc.start();
m2s.start();
}
void stop() {
demod.stop();
agc.stop();
m2s.stop();
}
@ -42,7 +39,7 @@ namespace demod {
}
void setBandwidth(double bandwidth) {
demod.setBandWidth(bandwidth);
demod.setBandwidth(bandwidth);
}
void setInput(dsp::stream<dsp::complex_t>* input) {
@ -73,9 +70,8 @@ namespace demod {
dsp::stream<dsp::stereo_t>* getOutput() { return &m2s.out; }
private:
dsp::SSBDemod demod;
dsp::AGC agc;
dsp::MonoToStereo m2s;
dsp::demod::SSB demod;
dsp::convert::MonoToStereo m2s;
std::string name;
};

18
decoder_modules/radio/src/demodulators/lsb.h
Wyświetl plik

@ -1,7 +1,7 @@
#pragma once
#include "../demod.h"
#include <dsp/demodulator.h>
#include <dsp/filter.h>
#include <dsp/demod/ssb.h>
#include <dsp/convert/mono_to_stereo.h>
namespace demod {
class LSB : public Demodulator {
@ -20,20 +20,17 @@ namespace demod {
this->name = name;
// Define structure
demod.init(input, getIFSampleRate(), bandwidth, dsp::SSBDemod::MODE_LSB);
agc.init(&demod.out, 20.0f, getIFSampleRate());
m2s.init(&agc.out);
demod.init(input, dsp::demod::SSB::Mode::LSB, bandwidth, getIFSampleRate(), 200000.0 / getIFSampleRate());
m2s.init(&demod.out);
}
void start() {
demod.start();
agc.start();
m2s.start();
}
void stop() {
demod.stop();
agc.stop();
m2s.stop();
}
@ -42,7 +39,7 @@ namespace demod {
}
void setBandwidth(double bandwidth) {
demod.setBandWidth(bandwidth);
demod.setBandwidth(bandwidth);
}
void setInput(dsp::stream<dsp::complex_t>* input) {
@ -73,9 +70,8 @@ namespace demod {
dsp::stream<dsp::stereo_t>* getOutput() { return &m2s.out; }
private:
dsp::SSBDemod demod;
dsp::AGC agc;
dsp::MonoToStereo m2s;
dsp::demod::SSB demod;
dsp::convert::MonoToStereo m2s;
std::string name;
};

Some files were not shown because too many files have changed in this diff Show More