new modole system

core/src/audio.cpp

@@ -0,0 +1,309 @@
+#include <audio.h>
+
+namespace audio {
+    std::map<std::string, AudioStream_t*> streams;
+
+    float registerMonoStream(dsp::stream<float>* stream, std::string name, std::string vfoName, int (*sampleRateChangeHandler)(void* ctx, float sampleRate), void* ctx) {
+        AudioStream_t* astr = new AudioStream_t;
+        astr->type = STREAM_TYPE_MONO;
+        astr->ctx = ctx;
+        astr->audio = new io::AudioSink;
+        astr->audio->init(1);
+        astr->deviceId = astr->audio->getDeviceId();
+        float sampleRate = astr->audio->devices[astr->deviceId].sampleRates[0];
+        int blockSize = sampleRate / 200; // default block size
+        astr->monoAudioStream = new dsp::stream<float>(blockSize * 2);
+        astr->audio->setBlockSize(blockSize);
+        astr->audio->setStreamType(io::AudioSink::MONO);
+        astr->audio->setMonoInput(astr->monoAudioStream);
+        astr->audio->setSampleRate(sampleRate);
+        astr->blockSize = blockSize;
+        astr->sampleRate = sampleRate;
+        astr->monoStream = stream;
+        astr->sampleRateChangeHandler = sampleRateChangeHandler;
+        astr->monoDynSplit = new dsp::DynamicSplitter<float>(stream, blockSize);
+        astr->monoDynSplit->bind(astr->monoAudioStream);
+        astr->running = false;
+        astr->volume = 1.0f;
+        astr->sampleRateId = 0;
+        astr->vfoName = vfoName;
+        streams[name] = astr;
+        return sampleRate;
+    }
+
+    float registerStereoStream(dsp::stream<dsp::StereoFloat_t>* stream, std::string name, std::string vfoName, int (*sampleRateChangeHandler)(void* ctx, float sampleRate), void* ctx) {
+        AudioStream_t* astr = new AudioStream_t;
+        astr->type = STREAM_TYPE_STEREO;
+        astr->ctx = ctx;
+        astr->audio = new io::AudioSink;
+        astr->audio->init(1);
+        float sampleRate = astr->audio->devices[astr->audio->getDeviceId()].sampleRates[0];
+        int blockSize = sampleRate / 200; // default block size
+        astr->stereoAudioStream = new dsp::stream<dsp::StereoFloat_t>(blockSize * 2);
+        astr->audio->setBlockSize(blockSize);
+        astr->audio->setStreamType(io::AudioSink::STEREO);
+        astr->audio->setStereoInput(astr->stereoAudioStream);
+        astr->audio->setSampleRate(sampleRate);
+        astr->blockSize = blockSize;
+        astr->sampleRate = sampleRate;
+        astr->stereoStream = stream;
+        astr->sampleRateChangeHandler = sampleRateChangeHandler;
+        astr->stereoDynSplit = new dsp::DynamicSplitter<dsp::StereoFloat_t>(stream, blockSize);
+        astr->stereoDynSplit->bind(astr->stereoAudioStream);
+        astr->running = false;
+        streams[name] = astr;
+        astr->vfoName = vfoName;
+        return sampleRate;
+    }
+
+    void startStream(std::string name) {
+        AudioStream_t* astr = streams[name];
+        if (astr->running) {
+            return;
+        }
+        if (astr->type == STREAM_TYPE_MONO) {
+            astr->monoDynSplit->start();
+        }
+        else {
+            astr->stereoDynSplit->start();
+        }
+        astr->audio->start();
+        astr->running = true;
+    }
+
+    void stopStream(std::string name) {
+        AudioStream_t* astr = streams[name];
+        if (!astr->running) {
+            return;
+        }
+        if (astr->type == STREAM_TYPE_MONO) {
+            astr->monoDynSplit->stop();
+        }
+        else {
+            astr->stereoDynSplit->stop();
+        }
+        astr->audio->stop();
+        astr->running = false;
+    }
+
+    void removeStream(std::string name) {
+        AudioStream_t* astr = streams[name];
+        stopStream(name);
+        for (int i = 0; i < astr->boundStreams.size(); i++) {
+            astr->boundStreams[i].streamRemovedHandler(astr->ctx);
+        }
+        delete astr->monoDynSplit;
+    }
+
+    dsp::stream<float>* bindToStreamMono(std::string name, void (*streamRemovedHandler)(void* ctx), void (*sampleRateChangeHandler)(void* ctx, float sampleRate, int blockSize), void* ctx) {
+        AudioStream_t* astr = streams[name];
+        BoundStream_t bstr;
+        bstr.type = STREAM_TYPE_MONO;
+        bstr.ctx = ctx;
+        bstr.streamRemovedHandler = streamRemovedHandler;
+        bstr.sampleRateChangeHandler = sampleRateChangeHandler;
+        if (astr->type == STREAM_TYPE_MONO) {
+            bstr.monoStream = new dsp::stream<float>(astr->blockSize * 2);
+            astr->monoDynSplit->stop();
+            astr->monoDynSplit->bind(bstr.monoStream);
+            if (astr->running) {
+                astr->monoDynSplit->start();
+            }
+            astr->boundStreams.push_back(bstr);
+            return bstr.monoStream;
+        }
+        bstr.stereoStream = new dsp::stream<dsp::StereoFloat_t>(astr->blockSize * 2);
+        bstr.s2m = new dsp::StereoToMono(bstr.stereoStream, astr->blockSize * 2);
+        bstr.monoStream = &bstr.s2m->output;
+        astr->stereoDynSplit->stop();
+        astr->stereoDynSplit->bind(bstr.stereoStream);
+        if (astr->running) {
+            astr->stereoDynSplit->start();
+        }
+        bstr.s2m->start();
+        astr->boundStreams.push_back(bstr);
+        return bstr.monoStream;
+    }
+
+    dsp::stream<dsp::StereoFloat_t>* bindToStreamStereo(std::string name, void (*streamRemovedHandler)(void* ctx), void (*sampleRateChangeHandler)(void* ctx, float sampleRate, int blockSize), void* ctx) {
+        AudioStream_t* astr = streams[name];
+        BoundStream_t bstr;
+        bstr.type = STREAM_TYPE_STEREO;
+        bstr.ctx = ctx;
+        bstr.streamRemovedHandler = streamRemovedHandler;
+        bstr.sampleRateChangeHandler = sampleRateChangeHandler;
+        if (astr->type == STREAM_TYPE_STEREO) {
+            bstr.stereoStream = new dsp::stream<dsp::StereoFloat_t>(astr->blockSize * 2);
+            astr->stereoDynSplit->stop();
+            astr->stereoDynSplit->bind(bstr.stereoStream);
+            if (astr->running) {
+                astr->stereoDynSplit->start();
+            }
+            astr->boundStreams.push_back(bstr);
+            return bstr.stereoStream;
+        }
+        bstr.monoStream = new dsp::stream<float>(astr->blockSize * 2);
+        bstr.m2s = new dsp::MonoToStereo(bstr.monoStream, astr->blockSize * 2);
+        bstr.stereoStream = &bstr.m2s->output;
+        astr->monoDynSplit->stop();
+        astr->monoDynSplit->bind(bstr.monoStream);
+        if (astr->running) {
+            astr->monoDynSplit->start();
+        }
+        bstr.m2s->start();
+        astr->boundStreams.push_back(bstr);
+        return bstr.stereoStream;
+    }
+
+    void setBlockSize(std::string name, int blockSize) {
+        AudioStream_t* astr = streams[name];
+        if (astr->running) {
+            return;
+        }
+        if (astr->type == STREAM_TYPE_MONO) {
+            astr->monoDynSplit->setBlockSize(blockSize);
+            for (int i = 0; i < astr->boundStreams.size(); i++) {
+                BoundStream_t bstr = astr->boundStreams[i];
+                bstr.monoStream->setMaxLatency(blockSize * 2);
+                if (bstr.type == STREAM_TYPE_STEREO) {
+                    bstr.m2s->stop();
+                    bstr.m2s->setBlockSize(blockSize);
+                    bstr.m2s->start();
+                }
+            }
+            astr->blockSize = blockSize;
+            return;
+        }
+        astr->monoDynSplit->setBlockSize(blockSize);
+        for (int i = 0; i < astr->boundStreams.size(); i++) {
+            BoundStream_t bstr = astr->boundStreams[i];
+            bstr.stereoStream->setMaxLatency(blockSize * 2);
+            if (bstr.type == STREAM_TYPE_MONO) {
+                bstr.s2m->stop();
+                bstr.s2m->setBlockSize(blockSize);
+                bstr.s2m->start();
+            }
+        }
+        astr->blockSize = blockSize;
+    }
+
+    void unbindFromStreamMono(std::string name, dsp::stream<float>* stream) {
+        AudioStream_t* astr = streams[name];
+        for (int i = 0; i < astr->boundStreams.size(); i++) {
+            BoundStream_t bstr = astr->boundStreams[i];
+            if (bstr.monoStream != stream) {
+                continue;
+            }
+            if (astr->type == STREAM_TYPE_STEREO) {
+                astr->stereoDynSplit->stop();
+                astr->stereoDynSplit->unbind(bstr.stereoStream);
+                if (astr->running) {
+                    astr->stereoDynSplit->start();
+                }
+                bstr.s2m->stop();
+                delete bstr.s2m;
+                return;
+            }
+            astr->monoDynSplit->stop();
+            astr->monoDynSplit->unbind(bstr.monoStream);
+            if (astr->running) {
+                astr->monoDynSplit->start();
+            }
+            delete stream;
+            return;
+        }
+    }
+
+    void unbindFromStreamStereo(std::string name, dsp::stream<dsp::StereoFloat_t>* stream) {
+        AudioStream_t* astr = streams[name];
+        for (int i = 0; i < astr->boundStreams.size(); i++) {
+            BoundStream_t bstr = astr->boundStreams[i];
+            if (bstr.stereoStream != stream) {
+                continue;
+            }
+            if (astr->type == STREAM_TYPE_MONO) {
+                astr->monoDynSplit->stop();
+                astr->monoDynSplit->unbind(bstr.monoStream);
+                if (astr->running) {
+                    astr->monoDynSplit->start();
+                }
+                bstr.m2s->stop();
+                delete bstr.m2s;
+                return;
+            }
+            astr->stereoDynSplit->stop();
+            astr->stereoDynSplit->unbind(bstr.stereoStream);
+            if (astr->running) {
+                astr->stereoDynSplit->start();
+            }
+            delete stream;
+            return;
+        }
+    }
+
+    std::string getNameFromVFO(std::string vfoName) {
+        for (auto const& [name, stream] : streams) {
+            if (stream->vfoName == vfoName) {
+                return name;
+            }
+        }
+        return "";
+    }
+
+    void setSampleRate(std::string name, float sampleRate) {
+        AudioStream_t* astr = streams[name];
+        if (astr->running) {
+            return;
+        }
+        int blockSize = astr->sampleRateChangeHandler(astr->ctx, sampleRate);
+        astr->audio->setSampleRate(sampleRate);
+        astr->audio->setBlockSize(blockSize);
+        if (astr->type == STREAM_TYPE_MONO) {
+            astr->monoDynSplit->setBlockSize(blockSize);
+            for (int i = 0; i < astr->boundStreams.size(); i++) {
+                BoundStream_t bstr = astr->boundStreams[i];
+                if (bstr.type == STREAM_TYPE_STEREO) {
+                    bstr.m2s->stop();
+                    bstr.m2s->setBlockSize(blockSize);
+                    bstr.sampleRateChangeHandler(bstr.ctx, sampleRate, blockSize);
+                    bstr.m2s->start();
+                    continue;
+                }
+                bstr.sampleRateChangeHandler(bstr.ctx, sampleRate, blockSize);
+            }
+        }
+        else {
+            astr->stereoDynSplit->setBlockSize(blockSize);
+            for (int i = 0; i < astr->boundStreams.size(); i++) {
+                BoundStream_t bstr = astr->boundStreams[i];
+                if (bstr.type == STREAM_TYPE_MONO) {
+                    bstr.s2m->stop();
+                    bstr.s2m->setBlockSize(blockSize);
+                    bstr.sampleRateChangeHandler(bstr.ctx, sampleRate, blockSize);
+                    bstr.s2m->start();
+                    continue;
+                }
+                bstr.sampleRateChangeHandler(bstr.ctx, sampleRate, blockSize);
+            }
+        }
+    }
+
+    void setAudioDevice(std::string name, int deviceId, float sampleRate) {
+        AudioStream_t* astr = streams[name];
+        if (astr->running) {
+            return;
+        }
+        astr->deviceId = deviceId;
+        astr->audio->setDevice(deviceId);
+        setSampleRate(name, sampleRate);
+    }
+
+    std::vector<std::string> getStreamNameList() {
+        std::vector<std::string> list;
+        for (auto [name, stream] : streams) {
+            list.push_back(name);
+        }
+        return list;
+    }
+};
+

core/src/audio.h

@@ -0,0 +1,64 @@
+#pragma once
+#include <dsp/stream.h>
+#include <dsp/routing.h>
+#include <io/audio.h>
+#include <map>
+#include <watcher.h>
+
+namespace audio {
+    enum {
+        STREAM_TYPE_MONO,
+        STREAM_TYPE_STEREO,
+        _STREAM_TYPE_COUNT
+    };
+
+    struct BoundStream_t {
+        dsp::stream<float>* monoStream;
+        dsp::stream<dsp::StereoFloat_t>* stereoStream;
+        dsp::StereoToMono* s2m;
+        dsp::MonoToStereo* m2s;
+        void (*streamRemovedHandler)(void* ctx);
+        void (*sampleRateChangeHandler)(void* ctx, float sampleRate, int blockSize);
+        void* ctx;
+        int type;
+    };
+
+    struct AudioStream_t {
+        io::AudioSink* audio;
+        dsp::stream<float>* monoAudioStream;
+        dsp::stream<dsp::StereoFloat_t>* stereoAudioStream;
+        std::vector<BoundStream_t> boundStreams;
+        dsp::stream<float>* monoStream;
+        dsp::DynamicSplitter<float>* monoDynSplit;
+        dsp::stream<dsp::StereoFloat_t>* stereoStream;
+        dsp::DynamicSplitter<dsp::StereoFloat_t>* stereoDynSplit;
+        int (*sampleRateChangeHandler)(void* ctx, float sampleRate);
+        float sampleRate;
+        int blockSize;
+        int type;
+        bool running = false;
+        float volume;
+        int sampleRateId;
+        int deviceId;
+        void* ctx;
+        std::string vfoName;
+    };
+
+    extern std::map<std::string, AudioStream_t*> streams;
+
+    float registerMonoStream(dsp::stream<float>* stream, std::string name, std::string vfoName, int (*sampleRateChangeHandler)(void* ctx, float sampleRate), void* ctx);
+    float registerStereoStream(dsp::stream<dsp::StereoFloat_t>* stream, std::string name, std::string vfoName, int (*sampleRateChangeHandler)(void* ctx, float sampleRate), void* ctx);
+    void startStream(std::string name);
+    void stopStream(std::string name);
+    void removeStream(std::string name);
+    dsp::stream<float>* bindToStreamMono(std::string name, void (*streamRemovedHandler)(void* ctx), void (*sampleRateChangeHandler)(void* ctx, float sampleRate, int blockSize), void* ctx);
+    dsp::stream<dsp::StereoFloat_t>* bindToStreamStereo(std::string name, void (*streamRemovedHandler)(void* ctx), void (*sampleRateChangeHandler)(void* ctx, float sampleRate, int blockSize), void* ctx);
+    void setBlockSize(std::string name, int blockSize);
+    void unbindFromStreamMono(std::string name, dsp::stream<float>* stream);
+    void unbindFromStreamStereo(std::string name, dsp::stream<dsp::StereoFloat_t>* stream);
+    std::string getNameFromVFO(std::string vfoName);
+    void setSampleRate(std::string name, float sampleRate);
+    void setAudioDevice(std::string name, int deviceId, float sampleRate);
+    std::vector<std::string> getStreamNameList();
+};
+

core/src/bandplan.cpp

@@ -0,0 +1,122 @@
+#include <bandplan.h>
+
+namespace bandplan {
+    std::map<std::string, BandPlan_t> bandplans;
+    std::vector<std::string> bandplanNames;
+    std::string bandplanNameTxt;
+    std::map<std::string, BandPlanColor_t> colorTable;
+
+    void generateTxt() {
+        bandplanNameTxt = "";
+        for (int i = 0; i < bandplanNames.size(); i++) {
+            bandplanNameTxt += bandplanNames[i];
+            bandplanNameTxt += '\0';
+        }
+    }
+
+    void to_json(json& j, const Band_t& b) {
+        j = json{
+            {"name", b.name},
+            {"type", b.type},
+            {"start", b.start},
+            {"end", b.end},
+        };
+    }
+
+    void from_json(const json& j, Band_t& b) {
+        j.at("name").get_to(b.name);
+        j.at("type").get_to(b.type);
+        j.at("start").get_to(b.start);
+        j.at("end").get_to(b.end);
+    }
+
+    void to_json(json& j, const BandPlan_t& b) {
+        j = json{
+            {"name", b.name},
+            {"country_name", b.countryName},
+            {"country_code", b.countryCode},
+            {"author_name", b.authorName},
+            {"author_url", b.authorURL},
+            {"bands", b.bands}
+        };
+    }
+
+    void from_json(const json& j, BandPlan_t& b) {
+        j.at("name").get_to(b.name);
+        j.at("country_name").get_to(b.countryName);
+        j.at("country_code").get_to(b.countryCode);
+        j.at("author_name").get_to(b.authorName);
+        j.at("author_url").get_to(b.authorURL);
+        j.at("bands").get_to(b.bands);
+    }
+
+    void to_json(json& j, const BandPlanColor_t& ct) {
+        spdlog::error("ImGui color to JSON not implemented!!!");
+    }
+    
+    void from_json(const json& j, BandPlanColor_t& ct) {
+        std::string col = j.get<std::string>();
+        if (col[0] != '#' || !std::all_of(col.begin() + 1, col.end(), ::isxdigit)) {
+            return;
+        }
+        uint8_t r, g, b, a;
+        r = std::stoi(col.substr(1, 2), NULL, 16);
+        g = std::stoi(col.substr(3, 2), NULL, 16);
+        b = std::stoi(col.substr(5, 2), NULL, 16);
+        a = std::stoi(col.substr(7, 2), NULL, 16);
+        ct.colorValue = IM_COL32(r, g, b, a);
+        ct.transColorValue = IM_COL32(r, g, b, 100);
+    }
+
+    void loadBandPlan(std::string path) {
+        std::ifstream file(path.c_str());
+        json data;
+        data << file;
+        file.close();
+
+        BandPlan_t plan = data.get<BandPlan_t>();
+        if (bandplans.find(plan.name) != bandplans.end()) {
+            spdlog::error("Duplicate band plan name ({0}), not loading.", plan.name);
+            return;
+        }
+        bandplans[plan.name] = plan;
+        bandplanNames.push_back(plan.name);
+        generateTxt();
+    }
+
+    void loadFromDir(std::string path) {
+        if (!std::filesystem::exists(path)) {
+            spdlog::error("Band Plan directory does not exist");
+            return;
+        }
+        if (!std::filesystem::is_directory(path)) {
+            spdlog::error("Band Plan directory isn't a directory...");
+            return;
+        }
+        bandplans.clear();
+        for (const auto & file : std::filesystem::directory_iterator(path)) {
+            std::string path = file.path().generic_string();
+            if (file.path().extension().generic_string() != ".json") {
+                continue;
+            }
+            loadBandPlan(path);
+        }
+    }
+
+    void loadColorTable(std::string path) {
+        if (!std::filesystem::exists(path)) {
+            spdlog::error("Band Plan Color Table file does not exist");
+            return;
+        }
+        if (!std::filesystem::is_regular_file(path)) {
+            spdlog::error("Band Plan Color Table file isn't a file...");
+            return;
+        }
+        std::ifstream file(path.c_str());
+        json data;
+        data << file;
+        file.close();
+
+        colorTable = data.get<std::map<std::string, BandPlanColor_t>>();
+    }
+};

core/src/bandplan.h

@@ -0,0 +1,51 @@
+#pragma once
+#include <json.hpp>
+#include <fstream>
+#include <spdlog/spdlog.h>
+#include <filesystem>
+#include <sstream>
+#include <iomanip>
+#include <imgui/imgui.h>
+
+using nlohmann::json;
+
+namespace bandplan {
+    struct Band_t {
+        std::string name;
+        std::string type;
+        float start;
+        float end;
+    };
+
+    void to_json(json& j, const Band_t& b);
+    void from_json(const json& j, Band_t& b);
+
+    struct BandPlan_t {
+        std::string name;
+        std::string countryName;
+        std::string countryCode;
+        std::string authorName;
+        std::string authorURL;
+        std::vector<Band_t> bands;
+    };
+
+    void to_json(json& j, const BandPlan_t& b);
+    void from_json(const json& j, BandPlan_t& b);
+
+    struct BandPlanColor_t {
+        uint32_t colorValue;
+        uint32_t transColorValue;
+    };
+
+    void to_json(json& j, const BandPlanColor_t& ct);
+    void from_json(const json& j, BandPlanColor_t& ct);
+    
+    void loadBandPlan(std::string path);
+    void loadFromDir(std::string path);
+    void loadColorTable(std::string path);
+
+    extern std::map<std::string, BandPlan_t> bandplans;
+    extern std::vector<std::string> bandplanNames;
+    extern std::string bandplanNameTxt;
+    extern std::map<std::string, BandPlanColor_t> colorTable;
+};

core/src/config.cpp

@@ -0,0 +1,62 @@
+#include <config.h>
+
+namespace config {
+    bool configModified = false;
+    json config;
+    bool autoSaveRunning = false;
+    std::string _path;
+    std::thread _workerThread;
+    std::string rootDir;
+
+    void _autoSaveWorker() {
+        while (autoSaveRunning) {
+            if (configModified) {
+                configModified = false;
+                std::ofstream file(_path.c_str());
+                file << std::setw(4) << config;
+                file.close();
+                spdlog::info("Config saved");
+            }
+            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+        }
+    }
+    
+    void load(std::string path) {
+        if (!std::filesystem::exists(path)) {
+            spdlog::error("Config file does not exist");
+            return;
+        }
+        if (!std::filesystem::is_regular_file(path)) {
+            spdlog::error("Config file isn't a file...");
+            return;
+        }
+        _path = path;
+        std::ifstream file(path.c_str());
+        config << file;
+        file.close();
+    }
+
+    void startAutoSave() {
+        if (autoSaveRunning) {
+            return;
+        }
+        autoSaveRunning = true;
+        _workerThread = std::thread(_autoSaveWorker);
+    }
+
+    void stopAutoSave() {
+        if (!autoSaveRunning) {
+            return;
+        }
+        autoSaveRunning = false;
+        _workerThread.join();
+    }
+
+    void setRootDirectory(std::string dir) {
+        rootDir = dir;
+    }
+
+    std::string getRootDirectory() {
+        return rootDir;
+    }
+};

core/src/config.h

@@ -0,0 +1,22 @@
+#pragma once
+#include <json.hpp>
+#include <fstream>
+#include <spdlog/spdlog.h>
+#include <filesystem>
+#include <sstream>
+#include <iomanip>
+#include <thread>
+#include <chrono>
+
+using nlohmann::json;
+
+namespace config {
+    void load(std::string path);
+    void startAutoSave();
+    void stopAutoSave();
+    void setRootDirectory(std::string dir);
+    std::string getRootDirectory();
+
+    extern bool configModified;
+    extern json config;
+};

core/src/core.cpp

@@ -0,0 +1,250 @@
+#include "imgui.h"
+#include "imgui_impl_glfw.h"
+#include "imgui_impl_opengl3.h"
+#include <stdio.h>
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include <main_window.h>
+#include <style.h>
+#include <icons.h>
+#include <version.h>
+#include <spdlog/spdlog.h>
+#include <bandplan.h>
+#include <module.h>
+#include <stb_image.h>
+#include <config.h>
+
+#include <dsp/block.h>
+
+#define STB_IMAGE_RESIZE_IMPLEMENTATION
+#include <stb_image_resize.h>
+
+#ifdef _WIN32
+#include <Windows.h>
+#endif
+
+// Comment to build a normal release
+#define DEV_BUILD
+
+bool maximized = false;
+bool fullScreen = false;
+
+static void glfw_error_callback(int error, const char* description) {
+    spdlog::error("Glfw Error {0}: {1}", error, description);
+}
+
+static void maximized_callback(GLFWwindow* window, int n) {
+    if (n == GLFW_TRUE) {
+        maximized = true;
+    }
+    else {
+        maximized = false;
+    }
+}
+
+// main
+int sdrpp_main() {
+#ifdef _WIN32
+    //FreeConsole();
+#endif
+
+    spdlog::info("SDR++ v" VERSION_STR);
+
+#ifdef DEV_BUILD
+    config::setRootDirectory("../root_dev");
+#elif _WIN32
+    config::setRootDirectory(".");
+#else
+    config::setRootDirectory("/etc/sdrpp");
+#endif
+
+    // Load config
+    spdlog::info("Loading config");
+    config::load(config::getRootDirectory() + "/config.json");
+    config::startAutoSave();
+
+    // Setup window
+    glfwSetErrorCallback(glfw_error_callback);
+    if (!glfwInit()) {
+        return 1;
+    }
+
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);  // 3.2+ only
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);            // Required on Mac
+    
+    int winWidth = config::config["windowSize"]["w"];
+    int winHeight = config::config["windowSize"]["h"];
+    maximized = config::config["maximized"];
+
+    // Create window with graphics context
+    GLFWmonitor* monitor = glfwGetPrimaryMonitor();
+    GLFWwindow* window = glfwCreateWindow(winWidth, winHeight, "SDR++ v" VERSION_STR " (Built at " __TIME__ ", " __DATE__ ")", NULL, NULL);
+    if (window == NULL)
+        return 1;
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1); // Enable vsync
+
+    if (maximized) {
+        glfwMaximizeWindow(window);
+    }
+
+    glfwSetWindowMaximizeCallback(window, maximized_callback);
+
+    // Load app icon
+    GLFWimage icons[10];
+    icons[0].pixels = stbi_load((config::getRootDirectory() + "/res/icons/sdrpp.png").c_str(), &icons[0].width, &icons[0].height, 0, 4);
+    icons[1].pixels = (unsigned char*)malloc(16 * 16 * 4); icons[1].width = icons[1].height = 16;
+    icons[2].pixels = (unsigned char*)malloc(24 * 24 * 4); icons[2].width = icons[2].height = 24;
+    icons[3].pixels = (unsigned char*)malloc(32 * 32 * 4); icons[3].width = icons[3].height = 32;
+    icons[4].pixels = (unsigned char*)malloc(48 * 48 * 4); icons[4].width = icons[4].height = 48;
+    icons[5].pixels = (unsigned char*)malloc(64 * 64 * 4); icons[5].width = icons[5].height = 64;
+    icons[6].pixels = (unsigned char*)malloc(96 * 96 * 4); icons[6].width = icons[6].height = 96;
+    icons[7].pixels = (unsigned char*)malloc(128 * 128 * 4); icons[7].width = icons[7].height = 128;
+    icons[8].pixels = (unsigned char*)malloc(196 * 196 * 4); icons[8].width = icons[8].height = 196;
+    icons[9].pixels = (unsigned char*)malloc(256 * 256 * 4); icons[9].width = icons[9].height = 256;
+    stbir_resize_uint8(icons[0].pixels, icons[0].width, icons[0].height, icons[0].width * 4, icons[1].pixels, 16, 16, 16 * 4, 4);
+    stbir_resize_uint8(icons[0].pixels, icons[0].width, icons[0].height, icons[0].width * 4, icons[2].pixels, 24, 24, 24 * 4, 4);
+    stbir_resize_uint8(icons[0].pixels, icons[0].width, icons[0].height, icons[0].width * 4, icons[3].pixels, 32, 32, 32 * 4, 4);
+    stbir_resize_uint8(icons[0].pixels, icons[0].width, icons[0].height, icons[0].width * 4, icons[4].pixels, 48, 48, 48 * 4, 4);
+    stbir_resize_uint8(icons[0].pixels, icons[0].width, icons[0].height, icons[0].width * 4, icons[5].pixels, 64, 64, 64 * 4, 4);
+    stbir_resize_uint8(icons[0].pixels, icons[0].width, icons[0].height, icons[0].width * 4, icons[6].pixels, 96, 96, 96 * 4, 4);
+    stbir_resize_uint8(icons[0].pixels, icons[0].width, icons[0].height, icons[0].width * 4, icons[7].pixels, 128, 128, 128 * 4, 4);
+    stbir_resize_uint8(icons[0].pixels, icons[0].width, icons[0].height, icons[0].width * 4, icons[8].pixels, 196, 196, 196 * 4, 4);
+    stbir_resize_uint8(icons[0].pixels, icons[0].width, icons[0].height, icons[0].width * 4, icons[9].pixels, 256, 256, 256 * 4, 4);
+    glfwSetWindowIcon(window, 10, icons);
+    stbi_image_free(icons[0].pixels);
+    for (int i = 1; i < 10; i++) {
+        free(icons[i].pixels);
+    }
+
+    if (glewInit() != GLEW_OK) {
+        spdlog::error("Failed to initialize OpenGL loader!");
+        return 1;
+    }
+
+
+    // Setup Dear ImGui context
+    IMGUI_CHECKVERSION();
+    ImGui::CreateContext();
+    ImGuiIO& io = ImGui::GetIO(); (void)io;
+    io.IniFilename = NULL;
+
+    // Setup Platform/Renderer bindings
+    ImGui_ImplGlfw_InitForOpenGL(window, true);
+    ImGui_ImplOpenGL3_Init("#version 150");
+
+    style::setDarkStyle();
+
+
+    // ====================================================
+    // glfwPollEvents();
+    ImGui_ImplOpenGL3_NewFrame();
+    // ImGui_ImplGlfw_NewFrame();
+    // ImGui::NewFrame();
+
+    // ImGui::ShowDemoWindow();
+
+    // ImGui::Render();
+    int display_w, display_h;
+    glfwGetFramebufferSize(window, &display_w, &display_h);
+    glViewport(0, 0, display_w, display_h);
+    glClearColor(0.0666f, 0.0666f, 0.0666f, 1.0f);
+    //glClearColor(0.9f, 0.9f, 0.9f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    // ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+    glfwSwapBuffers(window);
+    // ====================================================
+
+    spdlog::info("Loading icons");
+    icons::load();
+
+    spdlog::info("Loading band plans");
+    bandplan::loadFromDir(config::getRootDirectory() + "/bandplans");
+
+    spdlog::info("Loading band plans color table");
+    bandplan::loadColorTable(config::getRootDirectory() + "/band_colors.json");
+
+    windowInit();
+
+    spdlog::info("Ready.");
+
+    bool _maximized = maximized;
+    int fsWidth, fsHeight, fsPosX, fsPosY;
+
+    // Main loop
+    while (!glfwWindowShouldClose(window)) {
+        glfwPollEvents();
+
+        // Start the Dear ImGui frame
+        ImGui_ImplOpenGL3_NewFrame();
+        ImGui_ImplGlfw_NewFrame();
+        ImGui::NewFrame();
+
+        if (_maximized != maximized) {
+            _maximized = maximized;
+            config::config["maximized"]= _maximized;
+            config::configModified = true;
+            if (!maximized) {
+                glfwSetWindowSize(window, config::config["windowSize"]["w"], config::config["windowSize"]["h"]);
+            }
+        }
+
+        int _winWidth, _winHeight;
+        glfwGetWindowSize(window, &_winWidth, &_winHeight);
+
+        if (ImGui::IsKeyPressed(GLFW_KEY_F11)) {
+            fullScreen = !fullScreen;
+            if (fullScreen) {
+                spdlog::info("Fullscreen: ON");
+                fsWidth = _winWidth;
+                fsHeight = _winHeight;
+                glfwGetWindowPos(window, &fsPosX, &fsPosY);
+                const GLFWvidmode * mode = glfwGetVideoMode(glfwGetPrimaryMonitor());
+                glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, 0);
+            }
+            else {
+                spdlog::info("Fullscreen: OFF");
+                glfwSetWindowMonitor(window, nullptr,  fsPosX, fsPosY, fsWidth, fsHeight, 0);
+            }
+        }
+
+        if ((_winWidth != winWidth || _winHeight != winHeight) && !maximized && _winWidth > 0 && _winHeight > 0) {
+            winWidth = _winWidth;
+            winHeight = _winHeight;
+            config::config["windowSize"]["w"] = winWidth;
+            config::config["windowSize"]["h"] = winHeight;
+            config::configModified = true;
+        }
+
+        if (winWidth > 0 && winHeight > 0) {
+            ImGui::SetNextWindowPos(ImVec2(0, 0));
+            ImGui::SetNextWindowSize(ImVec2(_winWidth, _winHeight));
+            drawWindow();
+        }
+
+        // Rendering
+        ImGui::Render();
+        int display_w, display_h;
+        glfwGetFramebufferSize(window, &display_w, &display_h);
+        glViewport(0, 0, display_w, display_h);
+        glClearColor(0.0666f, 0.0666f, 0.0666f, 1.0f);
+        //glClearColor(0.9f, 0.9f, 0.9f, 1.0f);
+        glClear(GL_COLOR_BUFFER_BIT);
+        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+        glfwSwapBuffers(window);
+    }
+
+    // Cleanup
+    ImGui_ImplOpenGL3_Shutdown();
+    ImGui_ImplGlfw_Shutdown();
+    ImGui::DestroyContext();
+
+    glfwDestroyWindow(window);
+    glfwTerminate();
+
+    return 0;
+}

core/src/core.h

@@ -0,0 +1,3 @@
+#pragma once
+
+int sdrpp_main();

core/src/dsp/block.h

@@ -0,0 +1,121 @@
+#pragma once
+#include <vector>
+#include <dsp/stream.h>
+
+namespace dsp {
+    template <class D, class I, class O, int IC, int OC>
+    class Block {
+    public:
+        Block(std::vector<int> inBs, std::vector<int> outBs, D* inst, void (*workerFunc)(D* _this)) {
+            derived = inst;
+            worker = workerFunc;
+            inputBlockSize = inBs;
+            outputBlockSize = outBs;
+            in.reserve(IC);
+            out.reserve(OC);
+            for (int i = 0; i < IC; i++) {
+                in.push_back(NULL);
+            }
+            for (int i = 0; i < OC; i++) {
+                out.push_back(new stream<I>(outBs[i] * 2));
+            }
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            startHandler();
+            workerThread = std::thread(worker, derived);
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            stopHandler();
+            for (auto is : in) {
+                is->stopReader();
+            }
+            for (auto os : out) {
+                os->stopWriter();
+            }
+            workerThread.join();
+            
+            for (auto is : in) {
+                is->clearReadStop();
+            }
+            for (auto os : out) {
+                os->clearWriteStop();
+            }
+            running = false;
+        }
+
+        virtual void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            for (int i = 0; i < IC; i++) {
+                in[i]->setMaxLatency(blockSize * 2);
+                inputBlockSize[i] = blockSize;
+            }
+            for (int i = 0; i < OC; i++) {
+                out[i]->setMaxLatency(blockSize * 2);
+                outputBlockSize[i] = blockSize;
+            }
+        }
+
+        std::vector<stream<I>*> out;
+
+    protected:
+        virtual void startHandler() {}
+        virtual void stopHandler() {}
+        std::vector<stream<I>*> in;
+        std::vector<int> inputBlockSize;
+        std::vector<int> outputBlockSize;
+        bool running = false;
+
+    private:
+        void (*worker)(D* _this);
+        std::thread workerThread;
+        D* derived;
+
+    };
+
+
+    class DemoMultiplier : public Block<DemoMultiplier, complex_t, complex_t, 2, 1> {
+    public:
+        DemoMultiplier() : Block({2}, {1}, this, worker) {}
+
+        void init(stream<complex_t>* a, stream<complex_t>* b, int blockSize) {
+            in[0] = a;
+            in[1] = b;
+            inputBlockSize[0] = blockSize;
+            inputBlockSize[1] = blockSize;
+            out[0]->setMaxLatency(blockSize * 2);
+            outputBlockSize[0] = blockSize;
+        }
+
+    private:
+        static void worker(DemoMultiplier* _this) {
+            int blockSize = _this->inputBlockSize[0];
+            stream<complex_t>* inA = _this->in[0];
+            stream<complex_t>* inB = _this->in[1];
+            stream<complex_t>* out = _this->out[0];
+            complex_t* aBuf = (complex_t*)volk_malloc(sizeof(complex_t) * blockSize, volk_get_alignment());
+            complex_t* bBuf = (complex_t*)volk_malloc(sizeof(complex_t) * blockSize, volk_get_alignment());
+            complex_t* outBuf = (complex_t*)volk_malloc(sizeof(complex_t) * blockSize, volk_get_alignment());
+            while (true) {
+                if (inA->read(aBuf, blockSize) < 0) { break; };
+                if (inB->read(bBuf, blockSize) < 0) { break; };
+                volk_32fc_x2_multiply_32fc((lv_32fc_t*)outBuf, (lv_32fc_t*)aBuf, (lv_32fc_t*)bBuf, blockSize);
+                if (out->write(outBuf, blockSize) < 0) { break; };
+            }
+            volk_free(aBuf);
+            volk_free(bBuf);
+            volk_free(outBuf);
+        }
+
+    };
+};

core/src/dsp/correction.h

@@ -0,0 +1,158 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <vector>
+
+namespace dsp {
+    class DCBiasRemover {
+    public:
+        DCBiasRemover() {
+            
+        }
+
+        DCBiasRemover(stream<complex_t>* input, int bufferSize) : output(bufferSize * 2) {
+            _in = input;
+            _bufferSize = bufferSize;
+            bypass = false;
+        }
+
+        void init(stream<complex_t>* input, int bufferSize) {
+            output.init(bufferSize * 2);
+            _in = input;
+            _bufferSize = bufferSize;
+            bypass = false;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _in->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _bufferSize = blockSize;
+            output.setMaxLatency(blockSize * 2);
+        }
+
+        stream<complex_t> output;
+        bool bypass;
+
+    private:
+        static void _worker(DCBiasRemover* _this) {
+            complex_t* buf = new complex_t[_this->_bufferSize];
+            float ibias = 0.0f;
+            float qbias = 0.0f;
+            while (true) {
+                if (_this->_in->read(buf, _this->_bufferSize) < 0) { break; };
+                if (_this->bypass) {
+                    if (_this->output.write(buf, _this->_bufferSize) < 0) { break; };
+                    continue;
+                }
+                for (int i = 0; i < _this->_bufferSize; i++) {
+                    ibias += buf[i].i;
+                    qbias += buf[i].q;
+                }
+                ibias /= _this->_bufferSize;
+                qbias /= _this->_bufferSize;
+                for (int i = 0; i < _this->_bufferSize; i++) {
+                    buf[i].i -= ibias;
+                    buf[i].q -= qbias;
+                }
+                if (_this->output.write(buf, _this->_bufferSize) < 0) { break; };
+            }
+            delete[] buf;
+        }
+
+        stream<complex_t>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+        bool running = false;
+    };
+
+    class ComplexToStereo {
+    public:
+        ComplexToStereo() {
+            
+        }
+
+        ComplexToStereo(stream<complex_t>* input, int bufferSize) : output(bufferSize * 2) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void init(stream<complex_t>* input, int bufferSize) {
+            output.init(bufferSize * 2);
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _in->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _bufferSize = blockSize;
+            output.setMaxLatency(blockSize * 2);
+        }
+
+        stream<StereoFloat_t> output;
+
+    private:
+        static void _worker(ComplexToStereo* _this) {
+            complex_t* inBuf = new complex_t[_this->_bufferSize];
+            StereoFloat_t* outBuf = new StereoFloat_t[_this->_bufferSize];
+            while (true) {
+                if (_this->_in->read(inBuf, _this->_bufferSize) < 0) { break; };
+                for (int i = 0; i < _this->_bufferSize; i++) {
+                    outBuf[i].l = inBuf[i].i;
+                    outBuf[i].r = inBuf[i].q;
+                }
+                if (_this->output.write(outBuf, _this->_bufferSize) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<complex_t>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+        bool running = false;
+    };
+};

core/src/dsp/demodulator.h

@@ -0,0 +1,424 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <dsp/source.h>
+#include <dsp/math.h>
+
+/*
+    TODO:
+        - Add a sample rate ajustment function to all demodulators
+*/
+
+#define FAST_ATAN2_COEF1 3.1415926535f / 4.0f
+#define FAST_ATAN2_COEF2 3.0f * FAST_ATAN2_COEF1
+
+inline float fast_arctan2(float y, float x) {
+   float abs_y = fabs(y) + (1e-10);
+   float r, angle;
+   if (x>=0) {
+      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) {
+       return -angle;
+   }
+   return angle;
+}
+
+namespace dsp {
+    class FMDemodulator {
+    public:
+        FMDemodulator() {
+            
+        }
+
+        FMDemodulator(stream<complex_t>* in, float deviation, long sampleRate, int blockSize) : output(blockSize * 2) {
+            running = false;
+            _input = in;
+            _blockSize = blockSize;
+            _phase = 0.0f;
+            _deviation = deviation;
+            _sampleRate = sampleRate;
+            _phasorSpeed = (2 * 3.1415926535) / (sampleRate / deviation);
+        }
+
+        void init(stream<complex_t>* in, float deviation, long sampleRate, int blockSize) {
+            output.init(blockSize * 2);
+            running = false;
+            _input = in;
+            _blockSize = blockSize;
+            _phase = 0.0f;
+            _phasorSpeed = (2 * 3.1415926535) / (sampleRate / deviation);
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            _workerThread = std::thread(_worker, this);
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _input->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            running = false;
+            _input->clearReadStop();
+            output.clearWriteStop();
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(_blockSize * 2);
+        }
+
+        void setSampleRate(float sampleRate) {
+            _sampleRate = sampleRate;
+            _phasorSpeed = (2 * 3.1415926535) / (sampleRate / _deviation);
+        }
+
+        void setDeviation(float deviation) {
+            _deviation = deviation;
+            _phasorSpeed = (2 * 3.1415926535) / (_sampleRate / _deviation);
+        }
+
+        stream<float> output;
+
+    private:
+        static void _worker(FMDemodulator* _this) {
+            complex_t* inBuf = new complex_t[_this->_blockSize];
+            float* outBuf = new float[_this->_blockSize];
+            float diff = 0;
+            float currentPhase = 0;
+            while (true) {
+                if (_this->_input->read(inBuf, _this->_blockSize) < 0) { return; };
+                for (int i = 0; i < _this->_blockSize; i++) {
+                    currentPhase = fast_arctan2(inBuf[i].i, inBuf[i].q);
+                    diff = currentPhase - _this->_phase;
+                    if (diff > 3.1415926535f)        { diff -= 2 * 3.1415926535f; }
+                    else if (diff <= -3.1415926535f) { diff += 2 * 3.1415926535f; }
+                    outBuf[i] = diff / _this->_phasorSpeed;
+                    _this->_phase = currentPhase;
+                }
+                if (_this->output.write(outBuf, _this->_blockSize) < 0) { return; };
+            }
+        }
+
+        stream<complex_t>* _input;
+        bool running;
+        int _blockSize;
+        float _phase;
+        float _phasorSpeed;
+        float _deviation;
+        float _sampleRate;
+        std::thread _workerThread;
+    };
+
+
+    class AMDemodulator {
+    public:
+        AMDemodulator() {
+            
+        }
+
+        AMDemodulator(stream<complex_t>* in, int blockSize) : output(blockSize * 2) {
+            running = false;
+            _input = in;
+            _blockSize = blockSize;
+        }
+
+        void init(stream<complex_t>* in, int blockSize) {
+            output.init(blockSize * 2);
+            running = false;
+            _input = in;
+            _blockSize = blockSize;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            _workerThread = std::thread(_worker, this);
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _input->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            running = false;
+            _input->clearReadStop();
+            output.clearWriteStop();
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(_blockSize * 2);
+        }
+
+        stream<float> output;
+
+    private:
+        static void _worker(AMDemodulator* _this) {
+            complex_t* inBuf = new complex_t[_this->_blockSize];
+            float* outBuf = new float[_this->_blockSize];
+            float min, max, amp;
+            while (true) {
+                if (_this->_input->read(inBuf, _this->_blockSize) < 0) { break; };
+                min = INFINITY;
+                max = 0.0f;
+                for (int i = 0; i < _this->_blockSize; i++) {
+                    outBuf[i] = sqrt((inBuf[i].i*inBuf[i].i) + (inBuf[i].q*inBuf[i].q));
+                    if (outBuf[i] < min) {
+                        min = outBuf[i];
+                    }
+                    if (outBuf[i] > max) {
+                        max = outBuf[i];
+                    }
+                }
+                amp = (max - min) / 2.0f;
+                for (int i = 0; i < _this->_blockSize; i++) {
+                    outBuf[i] = (outBuf[i] - min - amp) / amp;
+                }
+                if (_this->output.write(outBuf, _this->_blockSize) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<complex_t>* _input;
+        bool running;
+        int _blockSize;
+        std::thread _workerThread;
+    };
+
+    class SSBDemod {
+    public:
+        SSBDemod() {
+
+        }
+
+        void init(stream<complex_t>* input, float sampleRate, float bandWidth, int blockSize) {
+            _blockSize = blockSize;
+            _bandWidth = bandWidth;
+            _mode = MODE_USB;
+            output.init(blockSize * 2);
+            lo.init(bandWidth / 2.0f, sampleRate, blockSize);
+            mixer.init(input, &lo.output, blockSize);
+            lo.start();
+        }
+
+        void start() {
+            mixer.start();
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            mixer.stop();
+            mixer.output.stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            mixer.output.clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+        }
+
+        void setMode(int mode) {
+            if (mode < 0 && mode >= _MODE_COUNT) {
+                return;
+            }
+            _mode = mode;
+            if (mode == MODE_USB) {
+                lo.setFrequency(_bandWidth / 2.0f);
+            }
+            else if (mode == MODE_LSB) {
+                lo.setFrequency(-_bandWidth / 2.0f);
+            }
+            else if (mode == MODE_LSB) {
+                lo.setFrequency(0);
+            }
+        }
+
+        void setBandwidth(float bandwidth) {
+            _bandWidth = bandwidth;
+            if (_mode == MODE_USB) {
+                lo.setFrequency(_bandWidth / 2.0f);
+            }
+            else if (_mode == MODE_LSB) {
+                lo.setFrequency(-_bandWidth / 2.0f);
+            }
+        }
+
+        stream<float> output;
+
+        enum {
+            MODE_USB,
+            MODE_LSB,
+            MODE_DSB,
+            _MODE_COUNT
+        };
+
+    private:
+        static void _worker(SSBDemod* _this) {
+            complex_t* inBuf = new complex_t[_this->_blockSize];
+            float* outBuf = new float[_this->_blockSize];
+
+            float min, max, factor;
+
+            while (true) {
+                if (_this->mixer.output.read(inBuf, _this->_blockSize) < 0) { break; };
+                min = INFINITY;
+                max = -INFINITY;
+                for (int i = 0; i < _this->_blockSize; i++) {
+                    outBuf[i] = inBuf[i].q;
+                    if (inBuf[i].q < min) {
+                        min = inBuf[i].q;
+                    }
+                    if (inBuf[i].q > max) {
+                        max = inBuf[i].q;
+                    }
+                }
+                factor = (max - min) / 2;
+                for (int i = 0; i < _this->_blockSize; i++) {
+                    outBuf[i] /= factor;
+                }
+                if (_this->output.write(outBuf, _this->_blockSize) < 0) { break; };
+            }
+
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        std::thread _workerThread;
+        SineSource lo;
+        Multiplier mixer;
+        int _blockSize;
+        float _bandWidth;
+        int _mode;
+        bool running = false;
+    };
+
+
+
+
+
+    // class CWDemod {
+    // public:
+    //     CWDemod() {
+
+    //     }
+
+    //     void init(stream<complex_t>* input, float sampleRate, float bandWidth, int blockSize) {
+    //         _blockSize = blockSize;
+    //         _bandWidth = bandWidth;
+    //         _mode = MODE_USB;
+    //         output.init(blockSize * 2);
+    //         lo.init(bandWidth / 2.0f, sampleRate, blockSize);
+    //         mixer.init(input, &lo.output, blockSize);
+    //         lo.start();
+    //     }
+
+    //     void start() {
+    //         mixer.start();
+    //         _workerThread = std::thread(_worker, this);
+    //         running = true;
+    //     }
+
+    //     void stop() {
+    //         mixer.stop();
+    //         mixer.output.stopReader();
+    //         output.stopWriter();
+    //         _workerThread.join();
+    //         mixer.output.clearReadStop();
+    //         output.clearWriteStop();
+    //         running = false;
+    //     }
+
+    //     void setBlockSize(int blockSize) {
+    //         if (running) {
+    //             return;
+    //         }
+    //         _blockSize = blockSize;
+    //     }
+
+    //     void setMode(int mode) {
+    //         if (mode < 0 && mode >= _MODE_COUNT) {
+    //             return;
+    //         }
+    //         _mode = mode;
+    //         if (mode == MODE_USB) {
+    //             lo.setFrequency(_bandWidth / 2.0f);
+    //         }
+    //         else if (mode == MODE_LSB) {
+    //             lo.setFrequency(-_bandWidth / 2.0f);
+    //         }
+    //     }
+
+    //     stream<float> output;
+
+    // private:
+    //     static void _worker(CWDemod* _this) {
+    //         complex_t* inBuf = new complex_t[_this->_blockSize];
+    //         float* outBuf = new float[_this->_blockSize];
+
+    //         float min, max, factor;
+
+    //         while (true) {
+    //             if (_this->mixer.output.read(inBuf, _this->_blockSize) < 0) { break; };
+    //             min = INFINITY;
+    //             max = -INFINITY;
+    //             for (int i = 0; i < _this->_blockSize; i++) {
+    //                 outBuf[i] = inBuf[i].q;
+    //                 if (inBuf[i].q < min) {
+    //                     min = inBuf[i].q;
+    //                 }
+    //                 if (inBuf[i].q > max) {
+    //                     max = inBuf[i].q;
+    //                 }
+    //             }
+    //             factor = (max - min) / 2;
+    //             for (int i = 0; i < _this->_blockSize; i++) {
+    //                 outBuf[i] /= factor;
+    //             }
+    //             if (_this->output.write(outBuf, _this->_blockSize) < 0) { break; };
+    //         }
+
+    //         delete[] inBuf;
+    //         delete[] outBuf;
+    //     }
+
+    //     std::thread _workerThread;
+    //     SineSource lo;
+    //     Multiplier mixer;
+    //     int _blockSize;
+    //     float _bandWidth;
+    //     int _mode;
+    //     bool running = false;
+    // };
+};

core/src/dsp/filter.h

@@ -0,0 +1,489 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <vector>
+#include <dsp/math.h>
+#include <spdlog/spdlog.h>
+
+#define GET_FROM_RIGHT_BUF(buffer, delayLine, delayLineSz, n) (((n) < 0) ? delayLine[(delayLineSz) + (n)] : buffer[(n)])
+
+namespace dsp {
+    inline void BlackmanWindow(std::vector<float>& taps, float sampleRate, float cutoff, float transWidth, int addedTaps = 0) {
+        taps.clear();
+
+        float fc = cutoff / sampleRate;
+        if (fc > 1.0f) {
+            fc = 1.0f;
+        }
+
+        int _M = (4.0f / (transWidth / sampleRate)) + (float)addedTaps;
+        if (_M < 4) {
+            _M = 4;
+        }
+
+        if (_M % 2 == 0) { _M++; }
+        float M = _M;
+        float sum = 0.0f;
+        float val;
+        for (int i = 0; i < _M; i++) {
+            val = (sin(2.0f * M_PI * fc * ((float)i - (M / 2))) / ((float)i - (M / 2))) * (0.42f - (0.5f * cos(2.0f * M_PI / M)) + (0.8f * cos(4.0f * M_PI / M)));
+            taps.push_back(val);
+            sum += val;
+        }
+        for (int i = 0; i < M; i++) {
+            taps[i] /= sum;
+        }
+    }
+
+    class DecimatingFIRFilter {
+    public:
+        DecimatingFIRFilter() {
+            
+        }
+
+        DecimatingFIRFilter(stream<complex_t>* input, std::vector<float> taps, int blockSize, float decim) {
+            output.init((blockSize * 2) / decim);
+            _in = input;
+            _blockSize = blockSize;
+            _tapCount = taps.size();
+            delayBuf = new complex_t[_tapCount];
+
+            _taps = new float[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+            }
+
+            _decim = decim;
+
+            for (int i = 0; i < _tapCount; i++) {
+                delayBuf[i].i = 0.0f;
+                delayBuf[i].q = 0.0f;
+            }
+
+            running = false;
+        }
+
+        void init(stream<complex_t>* input, std::vector<float>& taps, int blockSize, float decim) {
+            output.init((blockSize * 2) / decim);
+            _in = input;
+            _blockSize = blockSize;
+            _tapCount = taps.size();
+            delayBuf = new complex_t[_tapCount];
+
+            _taps = new float[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+            }
+
+            _decim = decim;
+
+            for (int i = 0; i < _tapCount; i++) {
+                delayBuf[i].i = 0.0f;
+                delayBuf[i].q = 0.0f;
+            }
+
+            running = false;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            _workerThread = std::thread(_worker, this);
+        }
+        
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _in->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setTaps(std::vector<float>& taps) {
+            if (running) {
+                return;
+            }
+            _tapCount = taps.size();
+            delete[] _taps;
+            delete[] delayBuf;
+            _taps = new float[_tapCount];
+            delayBuf = new complex_t[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+                delayBuf[i].i = 0;
+                delayBuf[i].q = 0;
+            }
+        }
+
+        void setInput(stream<complex_t>* input) {
+            if (running) {
+                return;
+            }
+            _in = input;
+        }
+
+        void setDecimation(float decimation) {
+            if (running) {
+                return;
+            }
+            _decim = decimation;
+            output.setMaxLatency((_blockSize * 2) / _decim);
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(getOutputBlockSize() * 2);
+        }
+
+        int getOutputBlockSize() {
+            return _blockSize / _decim;
+        }
+
+        stream<complex_t> output;
+
+    private:
+        static void _worker(DecimatingFIRFilter* _this) {
+            int outputSize = _this->_blockSize / _this->_decim;
+            complex_t* inBuf = new complex_t[_this->_blockSize];
+            complex_t* outBuf = new complex_t[outputSize];
+            float tap = 0.0f;
+            int delayOff;
+            void* delayStart = &inBuf[_this->_blockSize - (_this->_tapCount - 1)];
+            int delaySize = (_this->_tapCount - 1) * sizeof(complex_t);
+
+            int blockSize = _this->_blockSize;
+            int outBufferLength = outputSize * sizeof(complex_t);
+            int tapCount = _this->_tapCount;
+            int decim = _this->_decim;
+            complex_t* delayBuf = _this->delayBuf;
+            int id = 0;
+
+            while (true) {
+                if (_this->_in->read(inBuf, blockSize) < 0) { break; };
+                memset(outBuf, 0, outBufferLength);
+                
+                for (int t = 0; t < tapCount; t++) {
+                    tap = _this->_taps[t];
+                    if (tap == 0.0f) {
+                        continue;
+                    }
+
+                    delayOff = tapCount - t;
+                    id = 0;
+
+                    for (int i = 0; i < blockSize; i += decim) {
+                        if (i < t) {
+                            outBuf[id].i += tap * delayBuf[delayOff + i].i;
+                            outBuf[id].q += tap * delayBuf[delayOff + i].q;
+                        }
+                        else {
+                            outBuf[id].i += tap * inBuf[i - t].i;
+                            outBuf[id].q += tap * inBuf[i - t].q;
+                        }
+                        id++;
+                    }
+                }
+                memcpy(delayBuf, delayStart, delaySize);
+                if (_this->output.write(outBuf, outputSize) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<complex_t>* _in;
+        complex_t* delayBuf;
+        int _blockSize;
+        int _tapCount = 0;
+        float _decim;
+        std::thread _workerThread;
+        float* _taps;
+        bool running;
+    };
+
+
+    class FloatDecimatingFIRFilter {
+    public:
+        FloatDecimatingFIRFilter() {
+            
+        }
+
+        FloatDecimatingFIRFilter(stream<float>* input, std::vector<float> taps, int blockSize, float decim) {
+            output.init((blockSize * 2) / decim);
+            _in = input;
+            _blockSize = blockSize;
+            _tapCount = taps.size();
+            delayBuf = new float[_tapCount];
+
+            _taps = new float[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+            }
+
+            _decim = decim;
+
+            for (int i = 0; i < _tapCount; i++) {
+                delayBuf[i] = 0.0f;
+            }
+
+            running = false;
+        }
+
+        void init(stream<float>* input, std::vector<float>& taps, int blockSize, float decim) {
+            output.init((blockSize * 2) / decim);
+            _in = input;
+            _blockSize = blockSize;
+            _tapCount = taps.size();
+            delayBuf = new float[_tapCount];
+
+            _taps = new float[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+            }
+
+            _decim = decim;
+
+            for (int i = 0; i < _tapCount; i++) {
+                delayBuf[i] = 0.0f;
+            }
+
+            running = false;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            _workerThread = std::thread(_worker, this);
+        }
+        
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _in->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setTaps(std::vector<float>& taps) {
+            if (running) {
+                return;
+            }
+            _tapCount = taps.size();
+            delete[] _taps;
+            delete[] delayBuf;
+            _taps = new float[_tapCount];
+            delayBuf = new float[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+                delayBuf[i] = 0;
+            }
+        }
+
+        void setInput(stream<float>* input) {
+            if (running) {
+                return;
+            }
+            _in = input;
+        }
+
+        void setDecimation(float decimation) {
+            if (running) {
+                return;
+            }
+            _decim = decimation;
+            output.setMaxLatency((_blockSize * 2) / _decim);
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency((_blockSize * 2) / _decim);
+        }
+
+        int getOutputBlockSize() {
+            return _blockSize / _decim;
+        }
+
+        stream<float> output;
+
+    private:
+        static void _worker(FloatDecimatingFIRFilter* _this) {
+            int outputSize = _this->_blockSize / _this->_decim;
+            float* inBuf = new float[_this->_blockSize];
+            float* outBuf = new float[outputSize];
+            float tap = 0.0f;
+            int delayOff;
+            void* delayStart = &inBuf[_this->_blockSize - (_this->_tapCount - 1)];
+            int delaySize = (_this->_tapCount - 1) * sizeof(float);
+
+            int blockSize = _this->_blockSize;
+            int outBufferLength = outputSize * sizeof(float);
+            int tapCount = _this->_tapCount;
+            int decim = _this->_decim;
+            float* delayBuf = _this->delayBuf;
+            int id = 0;
+
+            while (true) {
+                if (_this->_in->read(inBuf, blockSize) < 0) { break; };
+                memset(outBuf, 0, outBufferLength);
+                
+                for (int t = 0; t < tapCount; t++) {
+                    tap = _this->_taps[t];
+                    if (tap == 0.0f) {
+                        continue;
+                    }
+
+                    delayOff = tapCount - t;
+                    id = 0;
+
+                    for (int i = 0; i < blockSize; i += decim) {
+                        if (i < t) {
+                            outBuf[id] += tap * delayBuf[delayOff + i];
+                            id++;
+                            continue;
+                        }
+                        outBuf[id] += tap * inBuf[i - t];
+                        id++;
+                    }
+                }
+                memcpy(delayBuf, delayStart, delaySize);
+                if (_this->output.write(outBuf, outputSize) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<float>* _in;
+        float* delayBuf;
+        int _blockSize;
+        int _tapCount = 0;
+        float _decim;
+        std::thread _workerThread;
+        float* _taps;
+        bool running;
+    };
+
+    class FMDeemphasis {
+    public:
+        FMDeemphasis() {
+            
+        }
+
+        FMDeemphasis(stream<float>* input, int bufferSize, float tau, float sampleRate) : output(bufferSize * 2) {
+            _in = input;
+            _bufferSize = bufferSize;
+            bypass = false;
+            _tau = tau;
+            _sampleRate = sampleRate;
+        }
+
+        void init(stream<float>* input, int bufferSize, float tau, float sampleRate) {
+            output.init(bufferSize * 2);
+            _in = input;
+            _bufferSize = bufferSize;
+            bypass = false;
+            _tau = tau;
+            _sampleRate = sampleRate;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _in->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _bufferSize = blockSize;
+            output.setMaxLatency(blockSize * 2);
+        }
+
+        void setSamplerate(float sampleRate) {
+            if (running) {
+                return;
+            }
+            _sampleRate = sampleRate;
+        }
+
+        void setTau(float tau) {
+            if (running) {
+                return;
+            }
+            _tau = tau;
+        }
+
+        stream<float> output;
+        bool bypass;
+
+    private:
+        static void _worker(FMDeemphasis* _this) {
+            float* inBuf = new float[_this->_bufferSize];
+            float* outBuf = new float[_this->_bufferSize];
+            int count = _this->_bufferSize;
+            float lastOut = 0.0f;
+            float dt = 1.0f / _this->_sampleRate;
+            float alpha = dt / (_this->_tau + dt);
+
+            while (true) {
+                if (_this->_in->read(inBuf, count) < 0) { break; };
+                if (_this->bypass) {
+                    if (_this->output.write(inBuf, count) < 0) { break; };
+                    continue;
+                }
+
+                if (isnan(lastOut)) {
+                    lastOut = 0.0f;
+                }
+                outBuf[0] = (alpha * inBuf[0]) + ((1-alpha) * lastOut);
+                for (int i = 1; i < count; i++) {
+                    outBuf[i] = (alpha * inBuf[i]) + ((1 - alpha) * outBuf[i - 1]);
+                }
+                lastOut = outBuf[count - 1];
+                
+                if (_this->output.write(outBuf, count) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<float>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+        bool running = false;
+        float _sampleRate;
+        float _tau;
+    };
+};

core/src/dsp/math.h

@@ -0,0 +1,85 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <volk.h>
+
+#ifndef M_PI
+#define M_PI    3.1415926535f
+#endif
+
+namespace dsp {
+    class Multiplier {
+    public:
+        Multiplier() {
+            
+        }
+
+        Multiplier(stream<complex_t>* a, stream<complex_t>* b, int blockSize) : output(blockSize * 2) {
+            _a = a;
+            _b = b;
+            _blockSize = blockSize;
+        }
+
+        void init(stream<complex_t>* a, stream<complex_t>* b, int blockSize) {
+            output.init(blockSize * 2);
+            _a = a;
+            _b = b;
+            _blockSize = blockSize;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            _workerThread = std::thread(_worker, this);
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _a->stopReader();
+            _b->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            running = false;
+            _a->clearReadStop();
+            _b->clearReadStop();
+            output.clearWriteStop();
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(blockSize * 2);
+        }
+
+        stream<complex_t> output;
+
+    private:
+        static void _worker(Multiplier* _this) {
+            complex_t* aBuf = (complex_t*)volk_malloc(sizeof(complex_t) * _this->_blockSize, volk_get_alignment());
+            complex_t* bBuf = (complex_t*)volk_malloc(sizeof(complex_t) * _this->_blockSize, volk_get_alignment());
+            complex_t* outBuf = (complex_t*)volk_malloc(sizeof(complex_t) * _this->_blockSize, volk_get_alignment());
+            while (true) {
+                if (_this->_a->read(aBuf, _this->_blockSize) < 0) { break; };
+                if (_this->_b->read(bBuf, _this->_blockSize) < 0) { break; };
+                volk_32fc_x2_multiply_32fc((lv_32fc_t*)outBuf, (lv_32fc_t*)aBuf, (lv_32fc_t*)bBuf, _this->_blockSize);
+                if (_this->output.write(outBuf, _this->_blockSize) < 0) { break; };
+            }
+            volk_free(aBuf);
+            volk_free(bBuf);
+            volk_free(outBuf);
+        }
+
+        stream<complex_t>* _a;
+        stream<complex_t>* _b;
+        int _blockSize;
+        bool running = false;
+        std::thread _workerThread;
+    };
+};

core/src/dsp/resampling.h

@@ -0,0 +1,958 @@
+#pragma once
+#include <thread>
+#include <dsp/filter.h>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <numeric>
+#include <algorithm>
+
+namespace dsp {
+    template <class T>
+    class Interpolator {
+    public:
+        Interpolator() {
+            
+        }
+
+        Interpolator(stream<T>* in, float interpolation, int blockSize) : output(blockSize * interpolation * 2) {
+            _input = in;
+            _interpolation = interpolation;
+            _blockSize = blockSize;
+        }
+
+        void init(stream<T>* in, float interpolation, int blockSize) {
+            output.init(blockSize * 2 * interpolation);
+            _input = in;
+            _interpolation = interpolation;
+            _blockSize = blockSize;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _input->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _input->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setInterpolation(float interpolation) {
+            if (running) {
+                return;
+            }
+            _interpolation = interpolation;
+            output.setMaxLatency(_blockSize * _interpolation * 2);
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(_blockSize * _interpolation * 2);
+        }
+
+        void setInput(stream<T>* input) {
+            if (running) {
+                return;
+            }
+            _input = input;
+        }
+
+        stream<T> output;
+
+    private:
+        static void _worker(Interpolator<T>* _this) {
+            T* inBuf = new T[_this->_blockSize];
+            T* outBuf = new T[_this->_blockSize * _this->_interpolation];
+            int outCount = _this->_blockSize * _this->_interpolation;
+            int interp = _this->_interpolation;
+            int count = 0;
+            while (true) {
+                if (_this->_input->read(inBuf, _this->_blockSize) < 0) { break; };
+                for (int i = 0; i < outCount; i++) {
+                    outBuf[i] = inBuf[(int)((float)i / _this->_interpolation)];
+                }
+
+                // for (int i = 0; i < outCount; i += interp) {
+                //     outBuf[i] = inBuf[count];
+                //     count++;
+                // }
+
+                count = 0;
+                if (_this->output.write(outBuf, outCount) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<T>* _input;
+        int _blockSize;
+        float _interpolation;
+        std::thread _workerThread;
+        bool running = false;
+    };
+
+    class BlockDecimator {
+    public:
+        BlockDecimator() {
+            
+        }
+
+        BlockDecimator(stream<complex_t>* in, int skip, int blockSize) : output(blockSize * 2) {
+            _input = in;
+            _skip = skip;
+            _blockSize = blockSize;
+        }
+
+        void init(stream<complex_t>* in, int skip, int blockSize) {
+            output.init(blockSize * 2);
+            _input = in;
+            _skip = skip;
+            _blockSize = blockSize;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _input->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _input->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(blockSize * 2);
+        }
+
+        void setSkip(int skip) {
+            if (running) {
+                return;
+            }
+            _skip = skip;
+        }
+
+        stream<complex_t> output;
+
+    private:
+        static void _worker(BlockDecimator* _this) {
+            complex_t* buf = new complex_t[_this->_blockSize];
+            bool delay = _this->_skip < 0;
+
+            int readCount = std::min<int>(_this->_blockSize + _this->_skip, _this->_blockSize);
+            int skip = std::max<int>(_this->_skip, 0);
+            int delaySize = (-_this->_skip) * sizeof(complex_t);
+
+            complex_t* start = &buf[std::max<int>(-_this->_skip, 0)];
+            complex_t* delayStart = &buf[_this->_blockSize + _this->_skip];
+
+            while (true) {
+                if (delay) {
+                    memmove(buf, delayStart, delaySize);
+                }
+                if (_this->_input->readAndSkip(start, readCount, skip) < 0) { break; };
+                if (_this->output.write(buf, _this->_blockSize) < 0) { break; };
+            }
+            delete[] buf;
+        }
+
+        stream<complex_t>* _input;
+        int _blockSize;
+        int _skip;
+        std::thread _workerThread;
+        bool running = false;
+    };
+
+    // class FIRResampler {
+    // public:
+    //     FIRResampler() {
+
+    //     }
+
+    //     void init(stream<complex_t>* in, float inputSampleRate, float outputSampleRate, int blockSize, float passBand = -1.0f, float transWidth = -1.0f) {
+    //         _input = in;
+    //         _outputSampleRate = outputSampleRate;
+    //         _inputSampleRate = inputSampleRate;
+    //         int _gcd = std::gcd((int)inputSampleRate, (int)outputSampleRate);
+    //         _interp = outputSampleRate / _gcd;
+    //         _decim = inputSampleRate / _gcd;
+    //         _blockSize = blockSize;
+    //         outputBlockSize = (blockSize * _interp) / _decim;
+    //         output.init(outputBlockSize * 2);
+
+    //         float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+    //         if (passBand > 0.0f && transWidth > 0.0f) {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+    //         }
+    //         else {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, cutoff, cutoff);
+    //         }
+    //     }
+
+    //     void start() {
+    //         if (running) {
+    //             return;
+    //         }
+    //         _workerThread = std::thread(_worker, this);
+    //         running = true;
+    //     }
+
+    //     void stop() {
+    //         if (!running) {
+    //             return;
+    //         }
+    //         _input->stopReader();
+    //         output.stopWriter();
+    //         _workerThread.join();
+    //         _input->clearReadStop();
+    //         output.clearWriteStop();
+    //         running = false;
+    //     }
+
+    //     void setInputSampleRate(float inputSampleRate, int blockSize = -1, float passBand = -1.0f, float transWidth = -1.0f) {
+    //         stop();
+    //         _inputSampleRate = inputSampleRate;
+    //         int _gcd = std::gcd((int)inputSampleRate, (int)_outputSampleRate);
+    //         _interp = _outputSampleRate / _gcd;
+    //         _decim = inputSampleRate / _gcd;
+
+    //         float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+    //         if (passBand > 0.0f && transWidth > 0.0f) {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+    //         }
+    //         else {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, cutoff, cutoff);
+    //         }
+
+    //         if (blockSize > 0) {
+    //             _blockSize = blockSize;
+    //         }
+    //         outputBlockSize = (_blockSize * _interp) / _decim;
+    //         output.setMaxLatency(outputBlockSize * 2);
+    //         start();
+    //     }
+
+    //     void setOutputSampleRate(float outputSampleRate, float passBand = -1.0f, float transWidth = -1.0f) {
+    //         stop();
+    //         _outputSampleRate = outputSampleRate;
+    //         int _gcd = std::gcd((int)_inputSampleRate, (int)outputSampleRate);
+    //         _interp = outputSampleRate / _gcd;
+    //         _decim = _inputSampleRate / _gcd;
+    //         outputBlockSize = (_blockSize * _interp) / _decim;
+    //         output.setMaxLatency(outputBlockSize * 2);
+
+    //         float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+    //         if (passBand > 0.0f && transWidth > 0.0f) {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+    //         }
+    //         else {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, cutoff, cutoff);
+    //         }
+            
+    //         start();
+    //     }
+
+    //     void setFilterParams(float passBand, float transWidth) {
+    //         stop();
+    //         dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+    //         start();
+    //     }
+
+    //     void setBlockSize(int blockSize) {
+    //         stop();
+    //         _blockSize = blockSize;
+    //         outputBlockSize = (_blockSize * _interp) / _decim;
+    //         output.setMaxLatency(outputBlockSize * 2);
+    //         start();
+    //     }
+
+    //     void setInput(stream<complex_t>* input) {
+    //         if (running) {
+    //             return;
+    //         }
+    //         _input = input;
+    //     }
+
+    //     int getOutputBlockSize() {
+    //         return outputBlockSize;
+    //     }
+
+    //     stream<complex_t> output;
+
+    // private:
+    //     static void _worker(FIRResampler* _this) {
+    //         complex_t* inBuf = new complex_t[_this->_blockSize];
+    //         complex_t* outBuf = new complex_t[_this->outputBlockSize];
+            
+    //         int inCount = _this->_blockSize;
+    //         int outCount = _this->outputBlockSize;
+
+    //         int interp = _this->_interp;
+    //         int decim = _this->_decim;
+    //         float correction = interp;//(float)sqrt((float)interp);
+
+    //         int tapCount = _this->_taps.size();
+    //         float* taps = new float[tapCount];
+    //         for (int i = 0; i < tapCount; i++) {
+    //             taps[i] = _this->_taps[i] * correction;
+    //         }
+            
+    //         complex_t* delayBuf = new complex_t[tapCount];
+
+    //         complex_t* delayStart = &inBuf[std::max<int>(inCount - tapCount, 0)];
+    //         int delaySize = tapCount * sizeof(complex_t);
+    //         complex_t* delayBufEnd = &delayBuf[std::max<int>(tapCount - inCount, 0)];
+    //         int moveSize = std::min<int>(inCount, tapCount - inCount) * sizeof(complex_t);
+    //         int inSize = inCount * sizeof(complex_t);
+            
+    //         int afterInterp = inCount * interp;
+    //         int outIndex = 0;
+    //         while (true) {
+    //             if (_this->_input->read(inBuf, inCount) < 0) { break; };
+    //             for (int i = 0; outIndex < outCount; i += decim) {
+    //                 outBuf[outIndex].i = 0;
+    //                 outBuf[outIndex].q = 0;
+    //                 for (int j = i % interp; j < tapCount; j += interp) {
+    //                     outBuf[outIndex].i += GET_FROM_RIGHT_BUF(inBuf, delayBuf, tapCount, (i - j) / interp).i * taps[j];
+    //                     outBuf[outIndex].q += GET_FROM_RIGHT_BUF(inBuf, delayBuf, tapCount, (i - j) / interp).q * taps[j];
+    //                 }
+    //                 outIndex++;
+    //             }
+    //             outIndex = 0;
+    //             if (tapCount > inCount) {
+    //                 memmove(delayBuf, delayBufEnd, moveSize);
+    //                 memcpy(delayBufEnd, delayStart, inSize);
+    //             }
+    //             else {
+    //                 memcpy(delayBuf, delayStart, delaySize);
+    //             }
+                
+    //             if (_this->output.write(outBuf, _this->outputBlockSize) < 0) { break; };
+    //         }
+    //         delete[] inBuf;
+    //         delete[] outBuf;
+    //         delete[] delayBuf;
+    //         delete[] taps;
+    //     }
+
+    //     std::thread _workerThread;
+
+    //     stream<complex_t>* _input;
+    //     std::vector<float> _taps;
+    //     int _interp;
+    //     int _decim;
+    //     int outputBlockSize;
+    //     float _outputSampleRate;
+    //     float _inputSampleRate;
+    //     int _blockSize;
+    //     bool running = false;
+    // };
+
+    // class FloatFIRResampler {
+    // public:
+    //     FloatFIRResampler() {
+
+    //     }
+
+    //     void init(stream<float>* in, float inputSampleRate, float outputSampleRate, int blockSize, float passBand = -1.0f, float transWidth = -1.0f) {
+    //         _input = in;
+    //         _outputSampleRate = outputSampleRate;
+    //         _inputSampleRate = inputSampleRate;
+    //         int _gcd = std::gcd((int)inputSampleRate, (int)outputSampleRate);
+    //         _interp = outputSampleRate / _gcd;
+    //         _decim = inputSampleRate / _gcd;
+    //         _blockSize = blockSize;
+    //         outputBlockSize = (blockSize * _interp) / _decim;
+    //         output.init(outputBlockSize * 2);
+
+    //         float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+    //         if (passBand > 0.0f && transWidth > 0.0f) {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+    //         }
+    //         else {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, cutoff, cutoff);
+    //         }
+    //     }
+
+    //     void start() {
+    //         if (running) {
+    //             return;
+    //         }
+    //         _workerThread = std::thread(_worker, this);
+    //         running = true;
+    //     }
+
+    //     void stop() {
+    //         if (!running) {
+    //             return;
+    //         }
+    //         _input->stopReader();
+    //         output.stopWriter();
+    //         _workerThread.join();
+    //         _input->clearReadStop();
+    //         output.clearWriteStop();
+    //         running = false;
+    //     }
+
+    //     void setInputSampleRate(float inputSampleRate, int blockSize = -1, float passBand = -1.0f, float transWidth = -1.0f) {
+    //         stop();
+    //         _inputSampleRate = inputSampleRate;
+    //         int _gcd = std::gcd((int)inputSampleRate, (int)_outputSampleRate);
+    //         _interp = _outputSampleRate / _gcd;
+    //         _decim = inputSampleRate / _gcd;
+
+    //         float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+    //         if (passBand > 0.0f && transWidth > 0.0f) {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+    //         }
+    //         else {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, cutoff, cutoff);
+    //         }
+
+    //         if (blockSize > 0) {
+    //             _blockSize = blockSize;
+    //         }
+    //         outputBlockSize = (blockSize * _interp) / _decim;
+    //         output.setMaxLatency(outputBlockSize * 2);
+    //         start();
+    //     }
+
+    //     void setOutputSampleRate(float outputSampleRate, float passBand = -1.0f, float transWidth = -1.0f) {
+    //         stop();
+    //         _outputSampleRate = outputSampleRate;
+    //         int _gcd = std::gcd((int)_inputSampleRate, (int)outputSampleRate);
+    //         _interp = outputSampleRate / _gcd;
+    //         _decim = _inputSampleRate / _gcd;
+    //         outputBlockSize = (_blockSize * _interp) / _decim;
+    //         output.setMaxLatency(outputBlockSize * 2);
+
+    //         float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+    //         if (passBand > 0.0f && transWidth > 0.0f) {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+    //         }
+    //         else {
+    //             dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, cutoff, cutoff);
+    //         }
+            
+    //         start();
+    //     }
+
+    //     void setFilterParams(float passBand, float transWidth) {
+    //         stop();
+    //         dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+    //         start();
+    //     }
+
+    //     void setBlockSize(int blockSize) {
+    //         stop();
+    //         _blockSize = blockSize;
+    //         outputBlockSize = (_blockSize * _interp) / _decim;
+    //         output.setMaxLatency(outputBlockSize * 2);
+    //         start();
+    //     }
+
+    //     void setInput(stream<float>* input) {
+    //         if (running) {
+    //             return;
+    //         }
+    //         _input = input;
+    //     }
+
+    //     int getOutputBlockSize() {
+    //         return outputBlockSize;
+    //     }
+
+    //     stream<float> output;
+
+    // private:
+    //     static void _worker(FloatFIRResampler* _this) {
+    //         float* inBuf = new float[_this->_blockSize];
+    //         float* outBuf = new float[_this->outputBlockSize];
+            
+    //         int inCount = _this->_blockSize;
+    //         int outCount = _this->outputBlockSize;
+
+    //         int interp = _this->_interp;
+    //         int decim = _this->_decim;
+    //         float correction = interp;//(float)sqrt((float)interp);
+            
+    //         int tapCount = _this->_taps.size();
+    //         float* taps = new float[tapCount];
+    //         for (int i = 0; i < tapCount; i++) {
+    //             taps[i] = _this->_taps[i] * correction;
+    //         }
+
+    //         float* delayBuf = new float[tapCount];
+
+    //         float* delayStart = &inBuf[std::max<int>(inCount - tapCount, 0)];
+    //         int delaySize = tapCount * sizeof(float);
+    //         float* delayBufEnd = &delayBuf[std::max<int>(tapCount - inCount, 0)];
+    //         int moveSize = std::min<int>(inCount, tapCount - inCount) * sizeof(float);
+    //         int inSize = inCount * sizeof(float);
+            
+    //         int afterInterp = inCount * interp;
+    //         int outIndex = 0;
+    //         while (true) {
+    //             if (_this->_input->read(inBuf, inCount) < 0) { break; };
+
+
+    //             for (int i = 0; outIndex < outCount; i += decim) {
+    //                 outBuf[outIndex] = 0;
+    //                 for (int j = (i % interp); j < tapCount; j += interp) {
+    //                     outBuf[outIndex] += GET_FROM_RIGHT_BUF(inBuf, delayBuf, tapCount, (i - j) / interp) * taps[j];
+    //                 }
+    //                 outIndex++;
+    //             }
+
+
+                
+    //             outIndex = 0;
+    //             if (tapCount > inCount) {
+    //                 memmove(delayBuf, delayBufEnd, moveSize);
+    //                 memcpy(delayBufEnd, delayStart, inSize);
+    //             }
+    //             else {
+    //                 memcpy(delayBuf, delayStart, delaySize);
+    //             }
+                
+    //             if (_this->output.write(outBuf, _this->outputBlockSize) < 0) { break; };
+    //         }
+    //         delete[] inBuf;
+    //         delete[] outBuf;
+    //         delete[] delayBuf;
+    //     }
+
+    //     std::thread _workerThread;
+
+    //     stream<float>* _input;
+    //     std::vector<float> _taps;
+    //     int _interp;
+    //     int _decim;
+    //     int outputBlockSize;
+    //     float _outputSampleRate;
+    //     float _inputSampleRate;
+    //     int _blockSize;
+    //     bool running = false;
+    // };
+
+
+
+
+    template <class T>
+    class FIRResampler {
+    public:
+        FIRResampler() {
+
+        }
+
+        void init(stream<T>* in, float inputSampleRate, float outputSampleRate, int blockSize, float passBand = -1.0f, float transWidth = -1.0f) {
+            _input = in;
+            _outputSampleRate = outputSampleRate;
+            _inputSampleRate = inputSampleRate;
+            int _gcd = std::gcd((int)inputSampleRate, (int)outputSampleRate);
+            _interp = outputSampleRate / _gcd;
+            _decim = inputSampleRate / _gcd;
+            _blockSize = blockSize;
+            outputBlockSize = (blockSize * _interp) / _decim;
+            output.init(outputBlockSize * 2);
+
+            float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+            if (passBand > 0.0f && transWidth > 0.0f) {
+                dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+            }
+            else {
+                dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, cutoff, cutoff);
+            }
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _input->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _input->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setInputSampleRate(float inputSampleRate, int blockSize = -1, float passBand = -1.0f, float transWidth = -1.0f) {
+            stop();
+            _inputSampleRate = inputSampleRate;
+            int _gcd = std::gcd((int)inputSampleRate, (int)_outputSampleRate);
+            _interp = _outputSampleRate / _gcd;
+            _decim = inputSampleRate / _gcd;
+
+            float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+            if (passBand > 0.0f && transWidth > 0.0f) {
+                dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+            }
+            else {
+                dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, cutoff, cutoff);
+            }
+
+            if (blockSize > 0) {
+                _blockSize = blockSize;
+            }
+            outputBlockSize = (blockSize * _interp) / _decim;
+            output.setMaxLatency(outputBlockSize * 2);
+            start();
+        }
+
+        void setOutputSampleRate(float outputSampleRate, float passBand = -1.0f, float transWidth = -1.0f) {
+            stop();
+            _outputSampleRate = outputSampleRate;
+            int _gcd = std::gcd((int)_inputSampleRate, (int)outputSampleRate);
+            _interp = outputSampleRate / _gcd;
+            _decim = _inputSampleRate / _gcd;
+            outputBlockSize = (_blockSize * _interp) / _decim;
+            output.setMaxLatency(outputBlockSize * 2);
+
+            float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+            if (passBand > 0.0f && transWidth > 0.0f) {
+                dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+            }
+            else {
+                dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, cutoff, cutoff);
+            }
+            
+            start();
+        }
+
+        void setFilterParams(float passBand, float transWidth) {
+            stop();
+            dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, passBand, transWidth);
+            start();
+        }
+
+        void setBlockSize(int blockSize) {
+            stop();
+            _blockSize = blockSize;
+            outputBlockSize = (_blockSize * _interp) / _decim;
+            output.setMaxLatency(outputBlockSize * 2);
+            start();
+        }
+
+        void setInput(stream<float>* input) {
+            if (running) {
+                return;
+            }
+            _input = input;
+        }
+
+        int getOutputBlockSize() {
+            return outputBlockSize;
+        }
+
+        stream<T> output;
+
+    private:
+
+        // Float worker
+        static void _worker(FIRResampler<T>* _this) {
+            T* inBuf = new T[_this->_blockSize];
+            T* outBuf = new T[_this->outputBlockSize];
+            
+            int inCount = _this->_blockSize;
+            int outCount = _this->outputBlockSize;
+
+            int interp = _this->_interp;
+            int decim = _this->_decim;
+            float correction = interp;
+            
+            int tapCount = _this->_taps.size();
+            float* taps = new float[tapCount];
+            for (int i = 0; i < tapCount; i++) {
+                taps[i] = _this->_taps[i] * correction;
+            }
+
+            T* delayBuf = new T[tapCount];
+
+            T* delayStart = &inBuf[std::max<int>(inCount - tapCount, 0)];
+            int delaySize = tapCount * sizeof(T);
+            T* delayBufEnd = &delayBuf[std::max<int>(tapCount - inCount, 0)];
+            int moveSize = std::min<int>(inCount, tapCount - inCount) * sizeof(T);
+            int inSize = inCount * sizeof(T);
+            
+            int afterInterp = inCount * interp;
+            int outIndex = 0;
+            while (true) {
+                if (_this->_input->read(inBuf, inCount) < 0) { break; };
+
+                if constexpr (std::is_same_v<T, float>) {
+                    for (int i = 0; outIndex < outCount; i += decim) {
+                        outBuf[outIndex] = 0;
+                        for (int j = (i % interp); j < tapCount; j += interp) {
+                            outBuf[outIndex] += GET_FROM_RIGHT_BUF(inBuf, delayBuf, tapCount, (i - j) / interp) * taps[j];
+                        }
+                        outIndex++;
+                    }
+                }
+                if constexpr (std::is_same_v<T, complex_t>) {
+                    for (int i = 0; outIndex < outCount; i += decim) {
+                        outBuf[outIndex].i = 0;
+                        outBuf[outIndex].q = 0;
+                        for (int j = i % interp; j < tapCount; j += interp) {
+                            outBuf[outIndex].i += GET_FROM_RIGHT_BUF(inBuf, delayBuf, tapCount, (i - j) / interp).i * taps[j];
+                            outBuf[outIndex].q += GET_FROM_RIGHT_BUF(inBuf, delayBuf, tapCount, (i - j) / interp).q * taps[j];
+                        }
+                        outIndex++;
+                    }
+                }
+                
+                outIndex = 0;
+                if (tapCount > inCount) {
+                    memmove(delayBuf, delayBufEnd, moveSize);
+                    memcpy(delayBufEnd, delayStart, inSize);
+                }
+                else {
+                    memcpy(delayBuf, delayStart, delaySize);
+                }
+                
+                if (_this->output.write(outBuf, _this->outputBlockSize) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+            delete[] delayBuf;
+        }
+
+        std::thread _workerThread;
+        stream<T>* _input;
+        std::vector<float> _taps;
+        int _interp;
+        int _decim;
+        int outputBlockSize;
+        float _outputSampleRate;
+        float _inputSampleRate;
+        int _blockSize;
+        bool running = false;
+    };
+
+    // class FloatPolyphaseFIRResampler {
+    // public:
+    //     FloatPolyphaseFIRResampler() {
+
+    //     }
+
+    //     void init(stream<float>* in, float inputSampleRate, float outputSampleRate, int blockSize, float passBand = -1.0f, float transWidth = -1.0f) {
+    //         _input = in;
+    //         _outputSampleRate = outputSampleRate;
+    //         _inputSampleRate = inputSampleRate;
+    //         int _gcd = std::gcd((int)inputSampleRate, (int)outputSampleRate);
+    //         _interp = outputSampleRate / _gcd;
+    //         _decim = inputSampleRate / _gcd;
+    //         _blockSize = blockSize;
+    //         outputBlockSize = (blockSize * _interp) / _decim;
+    //         output.init(outputBlockSize * 2);
+
+    //         float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+    //         if (passBand > 0.0f && transWidth > 0.0f) {
+    //             dsp::BlackmanWindow(_taps, _outputSampleRate, passBand, transWidth, _interp - 1);
+    //         }
+    //         else {
+    //             dsp::BlackmanWindow(_taps, _outputSampleRate, cutoff, cutoff, _interp - 1);
+    //         }
+    //     }
+
+    //     void start() {
+    //         if (running) {
+    //             return;
+    //         }
+    //         _workerThread = std::thread(_worker, this);
+    //         running = true;
+    //     }
+
+    //     void stop() {
+    //         if (!running) {
+    //             return;
+    //         }
+    //         _input->stopReader();
+    //         output.stopWriter();
+    //         _workerThread.join();
+    //         _input->clearReadStop();
+    //         output.clearWriteStop();
+    //         running = false;
+    //     }
+
+    //     void setInputSampleRate(float inputSampleRate, int blockSize = -1, float passBand = -1.0f, float transWidth = -1.0f) {
+    //         stop();
+    //         _inputSampleRate = inputSampleRate;
+    //         int _gcd = std::gcd((int)inputSampleRate, (int)_outputSampleRate);
+    //         _interp = _outputSampleRate / _gcd;
+    //         _decim = inputSampleRate / _gcd;
+
+    //         float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+    //         if (passBand > 0.0f && transWidth > 0.0f) {
+    //             dsp::BlackmanWindow(_taps, _outputSampleRate, passBand, transWidth, _interp - 1);
+    //         }
+    //         else {
+    //             dsp::BlackmanWindow(_taps,_outputSampleRate, cutoff, cutoff, _interp - 1);
+    //         }
+
+    //         if (blockSize > 0) {
+    //             _blockSize = blockSize;
+    //         }
+    //         outputBlockSize = (blockSize * _interp) / _decim;
+    //         output.setMaxLatency(outputBlockSize * 2);
+    //         start();
+    //     }
+
+    //     void setOutputSampleRate(float outputSampleRate, float passBand = -1.0f, float transWidth = -1.0f) {
+    //         stop();
+    //         _outputSampleRate = outputSampleRate;
+    //         int _gcd = std::gcd((int)_inputSampleRate, (int)outputSampleRate);
+    //         _interp = outputSampleRate / _gcd;
+    //         _decim = _inputSampleRate / _gcd;
+    //         outputBlockSize = (_blockSize * _interp) / _decim;
+    //         output.setMaxLatency(outputBlockSize * 2);
+
+    //         float cutoff = std::min<float>(_outputSampleRate / 2.0f, _inputSampleRate / 2.0f);
+    //         if (passBand > 0.0f && transWidth > 0.0f) {
+    //             dsp::BlackmanWindow(_taps, _outputSampleRate, passBand, transWidth, _interp - 1);
+    //         }
+    //         else {
+    //             dsp::BlackmanWindow(_taps, _outputSampleRate, cutoff, cutoff, _interp - 1);
+    //         }
+            
+    //         start();
+    //     }
+
+    //     void setFilterParams(float passBand, float transWidth) {
+    //         stop();
+    //         dsp::BlackmanWindow(_taps, _outputSampleRate, passBand, transWidth, _interp - 1);
+    //         start();
+    //     }
+
+    //     void setBlockSize(int blockSize) {
+    //         stop();
+    //         _blockSize = blockSize;
+    //         outputBlockSize = (_blockSize * _interp) / _decim;
+    //         output.setMaxLatency(outputBlockSize * 2);
+    //         start();
+    //     }
+
+    //     void setInput(stream<float>* input) {
+    //         if (running) {
+    //             return;
+    //         }
+    //         _input = input;
+    //     }
+
+    //     int getOutputBlockSize() {
+    //         return outputBlockSize;
+    //     }
+
+    //     stream<float> output;
+
+    // private:
+    //     static void _worker(FloatPolyphaseFIRResampler* _this) {
+    //         float* inBuf = new float[_this->_blockSize];
+    //         float* outBuf = new float[_this->outputBlockSize];
+            
+    //         int inCount = _this->_blockSize;
+    //         int outCount = _this->outputBlockSize;
+
+    //         int interp = _this->_interp;
+    //         int decim = _this->_decim;
+    //         float correction = interp;//(float)sqrt((float)interp);
+            
+    //         int tapCount = _this->_taps.size();
+    //         float* taps = new float[tapCount];
+    //         for (int i = 0; i < tapCount; i++) {
+    //             taps[i] = _this->_taps[i] * correction;
+    //         }
+
+    //         float* delayBuf = new float[tapCount];
+
+    //         float* delayStart = &inBuf[std::max<int>(inCount - tapCount, 0)];
+    //         int delaySize = tapCount * sizeof(float);
+    //         float* delayBufEnd = &delayBuf[std::max<int>(tapCount - inCount, 0)];
+    //         int moveSize = std::min<int>(inCount, tapCount - inCount) * sizeof(float);
+    //         int inSize = inCount * sizeof(float);
+            
+    //         int afterInterp = inCount * interp;
+    //         int outIndex = 0;
+
+    //         tapCount -= interp - 1;
+
+    //         while (true) {
+    //             if (_this->_input->read(inBuf, inCount) < 0) { break; };
+
+
+    //             for (int i = 0; i < outCount; i++) {
+    //                 outBuf[i] = 0;
+    //                 int filterId = (i * decim) % interp;
+    //                 int inputId = (i * decim) / interp;
+    //                 for (int j = 0; j < tapCount; j++) {
+    //                     outBuf[i] += GET_FROM_RIGHT_BUF(inBuf, delayBuf, tapCount, inputId - j) * taps[j + filterId];
+    //                 }
+    //             }
+
+
+
+
+
+                
+    //             if (tapCount > inCount) {
+    //                 memmove(delayBuf, delayBufEnd, moveSize);
+    //                 memcpy(delayBufEnd, delayStart, inSize);
+    //             }
+    //             else {
+    //                 memcpy(delayBuf, delayStart, delaySize);
+    //             }
+                
+    //             if (_this->output.write(outBuf, _this->outputBlockSize) < 0) { break; };
+    //         }
+    //         delete[] inBuf;
+    //         delete[] outBuf;
+    //         delete[] delayBuf;
+    //     }
+
+    //     std::thread _workerThread;
+
+    //     stream<float>* _input;
+    //     std::vector<float> _taps;
+    //     int _interp;
+    //     int _decim;
+    //     int outputBlockSize;
+    //     float _outputSampleRate;
+    //     float _inputSampleRate;
+    //     int _blockSize;
+    //     bool running = false;
+    // };
+};

core/src/dsp/routing.h

@@ -0,0 +1,310 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <vector>
+#include <spdlog/spdlog.h>
+
+namespace dsp {
+    class Splitter {
+    public:
+        Splitter() {
+            
+        }
+
+        Splitter(stream<complex_t>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+            output_a.init(bufferSize);
+            output_b.init(bufferSize);
+        }
+
+        void init(stream<complex_t>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+            output_a.init(bufferSize);
+            output_b.init(bufferSize);
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            output_a.stopWriter();
+            output_b.stopWriter();
+            _workerThread.join();
+            _in->clearReadStop();
+            output_a.clearWriteStop();
+            output_b.clearWriteStop();
+            running = false;
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _bufferSize = blockSize;
+            output_a.setMaxLatency(blockSize * 2);
+            output_b.setMaxLatency(blockSize * 2);
+        }
+
+        stream<complex_t> output_a;
+        stream<complex_t> output_b;
+
+    private:
+        static void _worker(Splitter* _this) {
+            complex_t* buf = new complex_t[_this->_bufferSize];
+            while (true) {
+                if (_this->_in->read(buf, _this->_bufferSize) < 0) { break; };
+                if (_this->output_a.write(buf, _this->_bufferSize) < 0) { break; };
+                if (_this->output_b.write(buf, _this->_bufferSize) < 0) { break; };
+            }
+            delete[] buf;
+        }
+
+        stream<complex_t>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+        bool running = false;
+    };
+
+    template <class T>
+    class DynamicSplitter {
+    public:
+        DynamicSplitter() {
+            
+        }
+
+        DynamicSplitter(stream<T>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void init(stream<T>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            int outputCount = outputs.size();
+            for (int i = 0; i < outputCount; i++) {
+                outputs[i]->stopWriter();
+            }
+            _workerThread.join();
+            _in->clearReadStop();
+            for (int i = 0; i < outputCount; i++) {
+                outputs[i]->clearWriteStop();
+            }
+            running = false;
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _bufferSize = blockSize;
+            int outputCount = outputs.size();
+            for (int i = 0; i < outputCount; i++) {
+                outputs[i]->setMaxLatency(blockSize * 2);
+            }
+        }
+
+        void bind(stream<T>* stream) {
+            if (running) {
+                return;
+            }
+            outputs.push_back(stream);
+        }
+
+        void unbind(stream<T>* stream) {
+            if (running) {
+                return;
+            }
+            int outputCount = outputs.size();
+            for (int i = 0; i < outputCount; i++) {
+                if (outputs[i] == stream) {
+                    outputs.erase(outputs.begin() + i);
+                    return;
+                }
+            }
+        }
+
+    private:
+        static void _worker(DynamicSplitter* _this) {
+            T* buf = new T[_this->_bufferSize];
+            int outputCount = _this->outputs.size();
+            while (true) {
+                if (_this->_in->read(buf, _this->_bufferSize) < 0) { break; };
+                for (int i = 0; i < outputCount; i++) {
+                    if (_this->outputs[i]->write(buf, _this->_bufferSize) < 0) { break; };
+                }
+            }
+            delete[] buf;
+        }
+
+        stream<T>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+        bool running = false;
+        std::vector<stream<T>*> outputs;
+    };
+
+
+    class MonoToStereo {
+    public:
+        MonoToStereo() {
+            
+        }
+
+        MonoToStereo(stream<float>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+            output.init(bufferSize * 2);
+        }
+
+        void init(stream<float>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+            output.init(bufferSize * 2);
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _in->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _bufferSize = blockSize;
+            output.setMaxLatency(blockSize * 2);
+        }
+
+        stream<StereoFloat_t> output;
+
+    private:
+        static void _worker(MonoToStereo* _this) {
+            float* inBuf = new float[_this->_bufferSize];
+            StereoFloat_t* outBuf = new StereoFloat_t[_this->_bufferSize];
+            while (true) {
+                if (_this->_in->read(inBuf, _this->_bufferSize) < 0) { break; };
+                for (int i = 0; i < _this->_bufferSize; i++) {
+                    outBuf[i].l = inBuf[i];
+                    outBuf[i].r = inBuf[i];
+                }
+                if (_this->output.write(outBuf, _this->_bufferSize) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<float>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+        bool running = false;
+    };
+
+    class StereoToMono {
+    public:
+        StereoToMono() {
+            
+        }
+
+        StereoToMono(stream<StereoFloat_t>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void init(stream<StereoFloat_t>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _in->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _bufferSize = blockSize;
+            output.setMaxLatency(blockSize * 2);
+        }
+
+        stream<float> output;
+
+    private:
+        static void _worker(StereoToMono* _this) {
+            StereoFloat_t* inBuf = new StereoFloat_t[_this->_bufferSize];
+            float* outBuf = new float[_this->_bufferSize];
+            while (true) {
+                if (_this->_in->read(inBuf, _this->_bufferSize) < 0) { break; };
+                for (int i = 0; i < _this->_bufferSize; i++) {
+                    outBuf[i] = (inBuf[i].l + inBuf[i].r) / 2.0f;
+                }
+                if (_this->output.write(outBuf, _this->_bufferSize) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<StereoFloat_t>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+        bool running = false;
+    };
+};

core/src/dsp/sink.h

@@ -0,0 +1,133 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <vector>
+
+namespace dsp {
+    class HandlerSink {
+    public:
+        HandlerSink() {
+            
+        }
+
+        HandlerSink(stream<complex_t>* input, complex_t* buffer, int bufferSize, void handler(complex_t*)) {
+            _in = input;
+            _bufferSize = bufferSize;
+            _buffer = buffer;
+            _handler = handler;
+        }
+
+        void init(stream<complex_t>* input, complex_t* buffer, int bufferSize, void handler(complex_t*)) {
+            _in = input;
+            _bufferSize = bufferSize;
+            _buffer = buffer;
+            _handler = handler;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            _workerThread.join();
+            _in->clearReadStop();
+            running = false;
+        }
+
+        bool bypass;
+
+    private:
+        static void _worker(HandlerSink* _this) {
+            while (true) {
+                if (_this->_in->read(_this->_buffer, _this->_bufferSize) < 0) { break; };
+                _this->_handler(_this->_buffer);
+            }
+        }
+
+        stream<complex_t>* _in;
+        int _bufferSize;
+        complex_t* _buffer;
+        std::thread _workerThread;
+        void (*_handler)(complex_t*);
+        bool running = false;
+    };
+
+    class NullSink {
+    public:
+        NullSink() {
+            
+        }
+
+        NullSink(stream<complex_t>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void init(stream<complex_t>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void start() {
+            _workerThread = std::thread(_worker, this);
+        }
+
+        bool bypass;
+
+    private:
+        static void _worker(NullSink* _this) {
+            complex_t* buf = new complex_t[_this->_bufferSize];
+            while (true) {
+                _this->_in->read(buf, _this->_bufferSize);
+            }
+        }
+
+        stream<complex_t>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+    };
+
+    class FloatNullSink {
+    public:
+        FloatNullSink() {
+            
+        }
+
+        FloatNullSink(stream<float>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void init(stream<float>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void start() {
+            _workerThread = std::thread(_worker, this);
+        }
+
+        bool bypass;
+
+    private:
+        static void _worker(FloatNullSink* _this) {
+            float* buf = new float[_this->_bufferSize];
+            while (true) {
+                _this->_in->read(buf, _this->_bufferSize);
+            }
+        }
+
+        stream<float>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+    };
+};

core/src/dsp/source.h

@@ -0,0 +1,92 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <volk.h>
+#include <spdlog/spdlog.h>
+
+namespace dsp {
+    class SineSource {
+    public:
+        SineSource() {
+            
+        }
+
+        SineSource(float frequency, long sampleRate, int blockSize) : output(blockSize * 2) {
+            _blockSize = blockSize;
+            _sampleRate = sampleRate;
+            _frequency = frequency;
+            _phasorSpeed = (2 * 3.1415926535 * frequency) / sampleRate;
+            _phase = 0;
+        }
+
+        void init(float frequency, long sampleRate, int blockSize) {
+            output.init(blockSize * 2);
+            _sampleRate = sampleRate;
+            _blockSize = blockSize;
+            _frequency = frequency;
+            _phasorSpeed = (2 * 3.1415926535 * frequency) / sampleRate;
+            _phase = 0;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            output.stopWriter();
+            _workerThread.join();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setFrequency(float frequency) {
+            _phasorSpeed = (2 * 3.1415926535) / (_sampleRate / frequency);
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(blockSize * 2);
+        }
+
+        void setSampleRate(float sampleRate) {
+            _sampleRate = sampleRate;
+            _phasorSpeed = (2 * 3.1415926535 * _frequency) / sampleRate;
+        }
+
+        stream<complex_t> output;
+
+    private:
+        static void _worker(SineSource* _this) {
+            complex_t* outBuf = new complex_t[_this->_blockSize];
+            while (true) {
+                for (int i = 0; i < _this->_blockSize; i++) {
+                    _this->_phase += _this->_phasorSpeed;
+                    outBuf[i].i = sin(_this->_phase);
+                    outBuf[i].q = cos(_this->_phase);
+                    _this->_phase = fmodf(_this->_phase, 2.0f * 3.1415926535); // TODO: Get a more efficient generator
+                }
+                if (_this->output.write(outBuf, _this->_blockSize) < 0) { break; };
+            }
+            delete[] outBuf;
+        }
+
+        int _blockSize;
+        float _phasorSpeed;
+        float _phase;
+        long _sampleRate;
+        float _frequency;
+        std::thread _workerThread;
+        bool running = false;
+    };
+};

core/src/dsp/stream.h

@@ -0,0 +1,228 @@
+#pragma once
+#include <condition_variable>
+#include <algorithm>
+#include <math.h>
+#include <string.h>
+
+#define STREAM_BUF_SZ   1000000
+
+namespace dsp {
+    template <class T>
+    class stream {
+    public:
+        stream() {
+
+        }
+
+        stream(int maxLatency) {
+            size = STREAM_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));
+        }
+
+        void init(int maxLatency) {
+            size = STREAM_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));
+        }
+
+        int read(T* data, int len) {
+            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) {
+            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() {
+            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) {
+            if (lock) { _readable_mtx.lock(); };
+            int _r = readable;
+            if (lock) { _readable_mtx.unlock(); };
+            return _r;
+        }
+
+        int write(T* data, int len) {
+            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() {
+            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) {
+            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() {
+            _stopReader = true;
+            canReadVar.notify_one();
+        }
+
+        void stopWriter() {
+            _stopWriter = true;
+            canWriteVar.notify_one();
+        }
+
+        bool getReadStop() {
+            return _stopReader;
+        }
+
+        bool getWriteStop() {
+            return _stopWriter;
+        }
+
+        void clearReadStop() {
+            _stopReader = false;
+        }
+
+        void clearWriteStop() {
+            _stopWriter = false;
+        }
+
+        void setMaxLatency(int maxLatency) {
+            this->maxLatency = maxLatency;
+        }
+
+    private:
+        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;
+    };
+};

core/src/dsp/types.h

@@ -0,0 +1,55 @@
+#pragma once
+
+namespace dsp {
+    struct complex_t {
+        float q;
+        float i;
+
+        complex_t operator+(complex_t& c) {
+            complex_t res;
+            res.i = c.i + i;
+            res.q = c.q + q;
+            return res;
+        }
+
+        complex_t operator-(complex_t& c) {
+            complex_t res;
+            res.i = i - c.i;
+            res.q = q - c.q;
+            return res;
+        }
+
+        complex_t operator*(float& f) {
+            complex_t res;
+            res.i = i * f;
+            res.q = q * f;
+            return res;
+        }
+    };
+
+    struct StereoFloat_t {
+        float l;
+        float r;
+
+        StereoFloat_t operator+(StereoFloat_t& s) {
+            StereoFloat_t res;
+            res.l = s.l + l;
+            res.r = s.r + r;
+            return res;
+        }
+
+        StereoFloat_t operator-(StereoFloat_t& s) {
+            StereoFloat_t res;
+            res.l = l - s.l;
+            res.r = r - s.r;
+            return res;
+        }
+
+        StereoFloat_t operator*(float& f) {
+            StereoFloat_t res;
+            res.l = l * f;
+            res.r = r * f;
+            return res;
+        }
+    };
+};

core/src/dsp/vfo.h

@@ -0,0 +1,103 @@
+#pragma once
+#include <dsp/source.h>
+#include <dsp/math.h>
+#include <dsp/resampling.h>
+#include <dsp/filter.h>
+#include <spdlog/spdlog.h>
+#include <dsp/block.h>
+
+namespace dsp {
+    class VFO {
+    public:
+        VFO() {
+
+        }
+
+        void init(stream<complex_t>* in, float inputSampleRate, float outputSampleRate, float bandWidth, float offset, int blockSize) {
+            _input = in;
+            _outputSampleRate = outputSampleRate;
+            _inputSampleRate = inputSampleRate;
+            _bandWidth = bandWidth;
+            _blockSize = blockSize;
+            output = &resamp.output;
+
+            lo.init(offset, inputSampleRate, blockSize);
+            mixer.init(in, &lo.output, blockSize);
+            //resamp.init(&mixer.output, inputSampleRate, outputSampleRate, blockSize, _bandWidth * 0.8f, _bandWidth);
+            resamp.init(mixer.out[0], inputSampleRate, outputSampleRate, blockSize, _bandWidth * 0.8f, _bandWidth);
+        }
+
+        void start() {
+            lo.start();
+            mixer.start();
+            resamp.start();
+        }
+
+        void stop(bool resampler = true) {
+            lo.stop();
+            mixer.stop();
+            if (resampler) { resamp.stop(); };
+        }
+
+        void setInputSampleRate(float inputSampleRate, int blockSize = -1) {
+            lo.stop();
+            lo.setSampleRate(inputSampleRate);
+
+            _inputSampleRate = inputSampleRate;
+
+            if (blockSize > 0) {
+                _blockSize = blockSize;
+                mixer.stop();
+                lo.setBlockSize(_blockSize);
+                mixer.setBlockSize(_blockSize);
+                mixer.start();
+            }
+            resamp.setInputSampleRate(inputSampleRate, _blockSize, _bandWidth * 0.8f, _bandWidth);
+            lo.start();
+        }
+
+        void setOutputSampleRate(float outputSampleRate, float bandWidth = -1) {
+            if (bandWidth > 0) {
+                _bandWidth = bandWidth;
+            }
+            resamp.setOutputSampleRate(outputSampleRate, _bandWidth * 0.8f, _bandWidth);
+        }
+
+        void setBandwidth(float bandWidth) {
+            _bandWidth = bandWidth;
+            resamp.setFilterParams(_bandWidth * 0.8f, _bandWidth);
+        }
+
+        void setOffset(float offset) {
+            lo.setFrequency(-offset);
+        }
+
+        void setBlockSize(int blockSize) {
+            stop(false);
+            _blockSize = blockSize;
+            lo.setBlockSize(_blockSize);
+            mixer.setBlockSize(_blockSize);
+            resamp.setBlockSize(_blockSize);
+            start();
+        }
+
+        int getOutputBlockSize() {
+            return resamp.getOutputBlockSize();
+        }
+
+        stream<complex_t>* output;
+
+    private:
+        SineSource lo;
+        //Multiplier mixer;
+        DemoMultiplier mixer;
+        FIRResampler<complex_t> resamp;
+        DecimatingFIRFilter filter;
+        stream<complex_t>* _input;
+
+        float _outputSampleRate;
+        float _inputSampleRate;
+        float _bandWidth;
+        float _blockSize;
+    };
+};

core/src/frequency_select.cpp

@@ -0,0 +1,164 @@
+#include <frequency_select.h>
+
+bool isInArea(ImVec2 val, ImVec2 min, ImVec2 max) {
+    return val.x >= min.x && val.x < max.x && val.y >= min.y && val.y < max.y;
+}
+
+FrequencySelect::FrequencySelect() {
+    
+}
+
+void FrequencySelect::init() {
+    font = ImGui::GetIO().Fonts->AddFontFromFileTTF((config::getRootDirectory() + "/res/fonts/Roboto-Medium.ttf").c_str(), 42.0f);
+    for (int i = 0; i < 12; i++) {
+        digits[i] = 0;
+        
+    }
+}
+
+void FrequencySelect::onPosChange() {
+    int digitHeight = ImGui::CalcTextSize("0").y;
+    int commaOffset = 0;
+    for (int i = 0; i < 12; i++) {
+        digitTopMins[i] = ImVec2(widgetPos.x + (i * 22) + commaOffset, widgetPos.y);
+        digitBottomMins[i] = ImVec2(widgetPos.x + (i * 22) + commaOffset, widgetPos.y + (digitHeight / 2));
+
+        digitTopMaxs[i] = ImVec2(widgetPos.x + (i * 22) + commaOffset + 22, widgetPos.y + (digitHeight / 2));
+        digitBottomMaxs[i] = ImVec2(widgetPos.x + (i * 22) + commaOffset + 22, widgetPos.y + digitHeight);
+
+        if ((i + 1) % 3 == 0 && i < 11) {
+            commaOffset += 12;
+        }
+    }
+}
+
+void FrequencySelect::onResize() {
+    
+}
+
+void FrequencySelect::incrementDigit(int i) {
+    if (i < 0) {
+        return;
+    }
+    if (digits[i] < 9) {
+        digits[i]++;
+    }
+    else {
+        digits[i] = 0;
+        incrementDigit(i - 1);
+    }
+    frequencyChanged = true;
+}
+
+void FrequencySelect::decrementDigit(int i) {
+    if (i < 0) {
+        return;
+    }
+    if (digits[i] > 0) {
+        digits[i]--;
+    }
+    else {
+        digits[i] = 9;
+        decrementDigit(i - 1);
+    }
+    frequencyChanged = true;
+}
+
+void FrequencySelect::draw() {
+    window = ImGui::GetCurrentWindow();
+    widgetPos = ImGui::GetWindowContentRegionMin();
+    widgetEndPos = ImGui::GetWindowContentRegionMax();
+    ImVec2 cursorPos = ImGui::GetCursorPos();
+    widgetPos.x += window->Pos.x + cursorPos.x;
+    widgetPos.y += window->Pos.y - 3;
+    widgetEndPos.x += window->Pos.x + cursorPos.x;
+    widgetEndPos.y += window->Pos.y - 3;
+    widgetSize = ImVec2(widgetEndPos.x - widgetPos.x, widgetEndPos.y - widgetPos.y);
+
+    ImGui::PushFont(font);
+
+    if (widgetPos.x != lastWidgetPos.x || widgetPos.y != lastWidgetPos.y) {
+        lastWidgetPos = widgetPos;
+        onPosChange();
+    }
+    if (widgetSize.x != lastWidgetSize.x || widgetSize.y != lastWidgetSize.y) {
+        lastWidgetSize = widgetSize;
+        onResize();
+    }
+
+    ImU32 disabledColor = ImGui::GetColorU32(ImGuiCol_Text, 0.3f);
+    ImU32 textColor = ImGui::GetColorU32(ImGuiCol_Text);
+
+    int commaOffset = 0;
+    bool zeros = true;
+    for (int i = 0; i < 12; i++) {
+        if (digits[i] != 0) {
+            zeros = false;
+        }
+        sprintf(buf, "%d", digits[i]);
+        window->DrawList->AddText(ImVec2(widgetPos.x + (i * 22) + commaOffset, widgetPos.y), 
+                                zeros ? disabledColor : textColor, buf);
+        if ((i + 1) % 3 == 0 && i < 11) {
+            commaOffset += 12;
+            window->DrawList->AddText(ImVec2(widgetPos.x + (i * 22) + commaOffset + 10, widgetPos.y), 
+                                    zeros ? disabledColor : textColor, ".");
+        }
+    }
+
+    ImVec2 mousePos = ImGui::GetMousePos();
+    bool leftClick = ImGui::IsMouseClicked(ImGuiMouseButton_Left);
+    bool rightClick = ImGui::IsMouseClicked(ImGuiMouseButton_Right);
+    int mw = ImGui::GetIO().MouseWheel;
+    bool onDigit = false;
+
+    for (int i = 0; i < 12; i++) {
+        onDigit = false;
+        if (isInArea(mousePos, digitTopMins[i], digitTopMaxs[i])) {
+            window->DrawList->AddRectFilled(digitTopMins[i], digitTopMaxs[i], IM_COL32(255, 0, 0, 75));
+            if (leftClick) {
+                incrementDigit(i);
+            }
+            onDigit = true;
+        }
+        if (isInArea(mousePos, digitBottomMins[i], digitBottomMaxs[i])) {
+            window->DrawList->AddRectFilled(digitBottomMins[i], digitBottomMaxs[i], IM_COL32(0, 0, 255, 75));
+            if (leftClick) {
+                decrementDigit(i);
+            }
+            onDigit = true;
+        }
+        if (onDigit) {
+            if (rightClick) {
+                for (int j = i; j < 12; j++) {
+                    digits[j] = 0;
+                }
+                frequencyChanged = true;
+            }
+            if (mw != 0) {
+                int count = abs(mw);
+                for (int j = 0; j < count; j++) {
+                    mw > 0 ? incrementDigit(i) : decrementDigit(i);
+                }
+            }
+        }
+    }
+
+    uint64_t freq = 0;
+    for (int i = 0; i < 12; i++) {
+        freq += digits[i] * pow(10, 11 - i);
+    }
+    frequency = freq;
+
+    ImGui::PopFont();
+    ImGui::NewLine();
+}
+
+void FrequencySelect::setFrequency(uint64_t freq) {
+    int i = 11;
+    for (uint64_t f = freq; i >= 0; i--) {
+        digits[i] = f % 10;
+        f -= digits[i];
+        f /= 10;
+    }
+    frequency = freq;
+}

core/src/frequency_select.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <imgui.h>
+#include <imgui_internal.h>
+#include <stdint.h>
+#include <config.h>
+
+class FrequencySelect {
+public:
+    FrequencySelect();
+    void init();
+    void draw();
+    void setFrequency(uint64_t freq);
+
+    uint64_t frequency;
+    bool frequencyChanged = false;
+
+private:
+    void onPosChange();
+    void onResize();
+    void incrementDigit(int i);
+    void decrementDigit(int i);
+
+    ImVec2 widgetPos;
+    ImVec2 widgetEndPos;
+    ImVec2 widgetSize;
+
+    ImVec2 lastWidgetPos;
+    ImVec2 lastWidgetSize;
+
+    ImGuiWindow* window;
+    ImFont* font;
+
+    int digits[12];
+    ImVec2 digitBottomMins[12];
+    ImVec2 digitTopMins[12];
+    ImVec2 digitBottomMaxs[12];
+    ImVec2 digitTopMaxs[12];
+
+    char buf[100];
+};

core/src/icons.cpp

@@ -0,0 +1,32 @@
+#include <icons.h>
+
+#define STB_IMAGE_IMPLEMENTATION
+#include <imgui/stb_image.h>
+
+namespace icons {
+    ImTextureID LOGO;
+    ImTextureID PLAY;
+    ImTextureID STOP;
+    ImTextureID MENU;
+
+    GLuint loadTexture(std::string path) {
+        int w,h,n;
+        stbi_uc* data = stbi_load(path.c_str(), &w, &h, &n, NULL);
+        GLuint texId;
+        glGenTextures(1, &texId);
+        glBindTexture(GL_TEXTURE_2D, texId);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (uint8_t*)data);
+        stbi_image_free(data);
+        return texId;
+    }
+
+    void load() {
+        LOGO = (ImTextureID)loadTexture(config::getRootDirectory() + "/res/icons/sdrpp.png");
+        PLAY = (ImTextureID)loadTexture(config::getRootDirectory() + "/res/icons/play.png");
+        STOP = (ImTextureID)loadTexture(config::getRootDirectory() + "/res/icons/stop.png");
+        MENU = (ImTextureID)loadTexture(config::getRootDirectory() + "/res/icons/menu.png");
+    }
+}

core/src/icons.h

@@ -0,0 +1,15 @@
+#pragma once
+#include <imgui/imgui.h>
+#include <stdint.h>
+#include <GL/glew.h>
+#include <config.h>
+
+namespace icons {
+    extern ImTextureID LOGO;
+    extern ImTextureID PLAY;
+    extern ImTextureID STOP;
+    extern ImTextureID MENU;
+
+    GLuint loadTexture(char* path);
+    void load();
+}

core/src/imgui/imconfig.h

@@ -0,0 +1,108 @@
+//-----------------------------------------------------------------------------
+// COMPILE-TIME OPTIONS FOR DEAR IMGUI
+// Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
+// You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
+//-----------------------------------------------------------------------------
+// A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/branch with your modifications to imconfig.h)
+// B) or add configuration directives in your own file and compile with #define IMGUI_USER_CONFIG "myfilename.h"
+// If you do so you need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include
+// the imgui*.cpp files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on data structures.
+// Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts.
+// Call IMGUI_CHECKVERSION() from your .cpp files to verify that the data structures your files are using are matching the ones imgui.cpp is using.
+//-----------------------------------------------------------------------------
+
+#pragma once
+
+//---- Define assertion handler. Defaults to calling assert().
+// If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
+//#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
+//#define IM_ASSERT(_EXPR)  ((void)(_EXPR))     // Disable asserts
+
+//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
+// Using dear imgui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
+//#define IMGUI_API __declspec( dllexport )
+//#define IMGUI_API __declspec( dllimport )
+
+//---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to avoid using soon-to-be obsolete function/names.
+//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+
+//---- Disable all of Dear ImGui or don't implement standard windows.
+// It is very strongly recommended to NOT disable the demo windows during development. Please read comments in imgui_demo.cpp.
+//#define IMGUI_DISABLE                                     // Disable everything: all headers and source files will be empty.
+//#define IMGUI_DISABLE_DEMO_WINDOWS                        // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty. Not recommended.
+//#define IMGUI_DISABLE_METRICS_WINDOW                      // Disable debug/metrics window: ShowMetricsWindow() will be empty.
+
+//---- Don't implement some functions to reduce linkage requirements.
+//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc.
+//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // [Win32] Don't implement default IME handler. Won't use and link with ImmGetContext/ImmSetCompositionWindow.
+//#define IMGUI_DISABLE_WIN32_FUNCTIONS                     // [Win32] Won't use and link with any Win32 function (clipboard, ime).
+//#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS      // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
+//#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS            // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf)
+//#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS              // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself.
+//#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS              // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
+//#define IMGUI_DISABLE_DEFAULT_ALLOCATORS                  // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
+
+//---- Include imgui_user.h at the end of imgui.h as a convenience
+//#define IMGUI_INCLUDE_IMGUI_USER_H
+
+//---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
+//#define IMGUI_USE_BGRA_PACKED_COLOR
+
+//---- Use 32-bit for ImWchar (default is 16-bit) to support full unicode code points.
+//#define IMGUI_USE_WCHAR32
+
+//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
+// By default the embedded implementations are declared static and not available outside of imgui cpp files.
+//#define IMGUI_STB_TRUETYPE_FILENAME   "my_folder/stb_truetype.h"
+//#define IMGUI_STB_RECT_PACK_FILENAME  "my_folder/stb_rect_pack.h"
+//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
+//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
+
+//---- Unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined, use the much faster STB sprintf library implementation of vsnprintf instead of the one from the default C library.
+// Note that stb_sprintf.h is meant to be provided by the user and available in the include path at compile time. Also, the compatibility checks of the arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by STB sprintf.
+// #define IMGUI_USE_STB_SPRINTF
+
+//---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
+// This will be inlined as part of ImVec2 and ImVec4 class declarations.
+/*
+#define IM_VEC2_CLASS_EXTRA                                                 \
+        ImVec2(const MyVec2& f) { x = f.x; y = f.y; }                       \
+        operator MyVec2() const { return MyVec2(x,y); }
+
+#define IM_VEC4_CLASS_EXTRA                                                 \
+        ImVec4(const MyVec4& f) { x = f.x; y = f.y; z = f.z; w = f.w; }     \
+        operator MyVec4() const { return MyVec4(x,y,z,w); }
+*/
+
+//---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices.
+// Your renderer back-end will need to support it (most example renderer back-ends support both 16/32-bit indices).
+// Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer.
+// Read about ImGuiBackendFlags_RendererHasVtxOffset for details.
+//#define ImDrawIdx unsigned int
+
+//---- Override ImDrawCallback signature (will need to modify renderer back-ends accordingly)
+//struct ImDrawList;
+//struct ImDrawCmd;
+//typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data);
+//#define ImDrawCallback MyImDrawCallback
+
+//---- Debug Tools: Macro to break in Debugger
+// (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.)
+//#define IM_DEBUG_BREAK  IM_ASSERT(0)
+//#define IM_DEBUG_BREAK  __debugbreak()
+
+//---- Debug Tools: Have the Item Picker break in the ItemAdd() function instead of ItemHoverable(),
+// (which comes earlier in the code, will catch a few extra items, allow picking items other than Hovered one.)
+// This adds a small runtime cost which is why it is not enabled by default.
+//#define IMGUI_DEBUG_TOOL_ITEM_PICKER_EX
+
+//---- Debug Tools: Enable slower asserts
+//#define IMGUI_DEBUG_PARANOID
+
+//---- Tip: You can add extra functions within the ImGui:: namespace, here or in your own headers files.
+/*
+namespace ImGui
+{
+    void MyFunction(const char* name, const MyMatrix44& v);
+}
+*/

core/src/imgui/imgui_impl_glfw.cpp

@@ -0,0 +1,369 @@
+// dear imgui: Platform Binding for GLFW
+// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan..)
+// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
+// (Requires: GLFW 3.1+)
+
+// Implemented features:
+//  [X] Platform: Clipboard support.
+//  [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
+//  [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
+//  [X] Platform: Keyboard arrays indexed using GLFW_KEY_* codes, e.g. ImGui::IsKeyPressed(GLFW_KEY_SPACE).
+
+// You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this.
+// If you are new to dear imgui, read examples/README.txt and read the documentation at the top of imgui.cpp.
+// https://github.com/ocornut/imgui
+
+// CHANGELOG
+// (minor and older changes stripped away, please see git history for details)
+//  2020-01-17: Inputs: Disable error callback while assigning mouse cursors because some X11 setup don't have them and it generates errors.
+//  2019-12-05: Inputs: Added support for new mouse cursors added in GLFW 3.4+ (resizing cursors, not allowed cursor).
+//  2019-10-18: Misc: Previously installed user callbacks are now restored on shutdown.
+//  2019-07-21: Inputs: Added mapping for ImGuiKey_KeyPadEnter.
+//  2019-05-11: Inputs: Don't filter value from character callback before calling AddInputCharacter().
+//  2019-03-12: Misc: Preserve DisplayFramebufferScale when main window is minimized.
+//  2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
+//  2018-11-07: Inputs: When installing our GLFW callbacks, we save user's previously installed ones - if any - and chain call them.
+//  2018-08-01: Inputs: Workaround for Emscripten which doesn't seem to handle focus related calls.
+//  2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
+//  2018-06-08: Misc: Extracted imgui_impl_glfw.cpp/.h away from the old combined GLFW+OpenGL/Vulkan examples.
+//  2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
+//  2018-02-20: Inputs: Added support for mouse cursors (ImGui::GetMouseCursor() value, passed to glfwSetCursor()).
+//  2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
+//  2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
+//  2018-01-25: Inputs: Added gamepad support if ImGuiConfigFlags_NavEnableGamepad is set.
+//  2018-01-25: Inputs: Honoring the io.WantSetMousePos by repositioning the mouse (when using navigation and ImGuiConfigFlags_NavMoveMouse is set).
+//  2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
+//  2018-01-18: Inputs: Added mapping for ImGuiKey_Insert.
+//  2017-08-25: Inputs: MousePos set to -FLT_MAX,-FLT_MAX when mouse is unavailable/missing (instead of -1,-1).
+//  2016-10-15: Misc: Added a void* user_data parameter to Clipboard function handlers.
+
+#include "imgui.h"
+#include "imgui_impl_glfw.h"
+
+// GLFW
+#include <GLFW/glfw3.h>
+#ifdef _WIN32
+#undef APIENTRY
+#define GLFW_EXPOSE_NATIVE_WIN32
+#include <GLFW/glfw3native.h>   // for glfwGetWin32Window
+#endif
+#define GLFW_HAS_WINDOW_TOPMOST       (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3200) // 3.2+ GLFW_FLOATING
+#define GLFW_HAS_WINDOW_HOVERED       (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3300) // 3.3+ GLFW_HOVERED
+#define GLFW_HAS_WINDOW_ALPHA         (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3300) // 3.3+ glfwSetWindowOpacity
+#define GLFW_HAS_PER_MONITOR_DPI      (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3300) // 3.3+ glfwGetMonitorContentScale
+#define GLFW_HAS_VULKAN               (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3200) // 3.2+ glfwCreateWindowSurface
+#ifdef GLFW_RESIZE_NESW_CURSOR  // let's be nice to people who pulled GLFW between 2019-04-16 (3.4 define) and 2019-11-29 (cursors defines) // FIXME: Remove when GLFW 3.4 is released?
+#define GLFW_HAS_NEW_CURSORS          (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3400) // 3.4+ GLFW_RESIZE_ALL_CURSOR, GLFW_RESIZE_NESW_CURSOR, GLFW_RESIZE_NWSE_CURSOR, GLFW_NOT_ALLOWED_CURSOR
+#else
+#define GLFW_HAS_NEW_CURSORS          (0)
+#endif
+
+// Data
+enum GlfwClientApi
+{
+    GlfwClientApi_Unknown,
+    GlfwClientApi_OpenGL,
+    GlfwClientApi_Vulkan
+};
+static GLFWwindow*          g_Window = NULL;    // Main window
+static GlfwClientApi        g_ClientApi = GlfwClientApi_Unknown;
+static double               g_Time = 0.0;
+static bool                 g_MouseJustPressed[ImGuiMouseButton_COUNT] = {};
+static GLFWcursor*          g_MouseCursors[ImGuiMouseCursor_COUNT] = {};
+static bool                 g_InstalledCallbacks = false;
+
+// Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
+static GLFWmousebuttonfun   g_PrevUserCallbackMousebutton = NULL;
+static GLFWscrollfun        g_PrevUserCallbackScroll = NULL;
+static GLFWkeyfun           g_PrevUserCallbackKey = NULL;
+static GLFWcharfun          g_PrevUserCallbackChar = NULL;
+
+static const char* ImGui_ImplGlfw_GetClipboardText(void* user_data)
+{
+    return glfwGetClipboardString((GLFWwindow*)user_data);
+}
+
+static void ImGui_ImplGlfw_SetClipboardText(void* user_data, const char* text)
+{
+    glfwSetClipboardString((GLFWwindow*)user_data, text);
+}
+
+void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods)
+{
+    if (g_PrevUserCallbackMousebutton != NULL)
+        g_PrevUserCallbackMousebutton(window, button, action, mods);
+
+    if (action == GLFW_PRESS && button >= 0 && button < IM_ARRAYSIZE(g_MouseJustPressed))
+        g_MouseJustPressed[button] = true;
+}
+
+void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset)
+{
+    if (g_PrevUserCallbackScroll != NULL)
+        g_PrevUserCallbackScroll(window, xoffset, yoffset);
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.MouseWheelH += (float)xoffset;
+    io.MouseWheel += (float)yoffset;
+}
+
+void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (g_PrevUserCallbackKey != NULL)
+        g_PrevUserCallbackKey(window, key, scancode, action, mods);
+
+    ImGuiIO& io = ImGui::GetIO();
+    if (action == GLFW_PRESS)
+        io.KeysDown[key] = true;
+    if (action == GLFW_RELEASE)
+        io.KeysDown[key] = false;
+
+    // Modifiers are not reliable across systems
+    io.KeyCtrl = io.KeysDown[GLFW_KEY_LEFT_CONTROL] || io.KeysDown[GLFW_KEY_RIGHT_CONTROL];
+    io.KeyShift = io.KeysDown[GLFW_KEY_LEFT_SHIFT] || io.KeysDown[GLFW_KEY_RIGHT_SHIFT];
+    io.KeyAlt = io.KeysDown[GLFW_KEY_LEFT_ALT] || io.KeysDown[GLFW_KEY_RIGHT_ALT];
+#ifdef _WIN32
+    io.KeySuper = false;
+#else
+    io.KeySuper = io.KeysDown[GLFW_KEY_LEFT_SUPER] || io.KeysDown[GLFW_KEY_RIGHT_SUPER];
+#endif
+}
+
+void ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c)
+{
+    if (g_PrevUserCallbackChar != NULL)
+        g_PrevUserCallbackChar(window, c);
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.AddInputCharacter(c);
+}
+
+static bool ImGui_ImplGlfw_Init(GLFWwindow* window, bool install_callbacks, GlfwClientApi client_api)
+{
+    g_Window = window;
+    g_Time = 0.0;
+
+    // Setup back-end capabilities flags
+    ImGuiIO& io = ImGui::GetIO();
+    io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;         // We can honor GetMouseCursor() values (optional)
+    io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos;          // We can honor io.WantSetMousePos requests (optional, rarely used)
+    io.BackendPlatformName = "imgui_impl_glfw";
+
+    // Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array.
+    io.KeyMap[ImGuiKey_Tab] = GLFW_KEY_TAB;
+    io.KeyMap[ImGuiKey_LeftArrow] = GLFW_KEY_LEFT;
+    io.KeyMap[ImGuiKey_RightArrow] = GLFW_KEY_RIGHT;
+    io.KeyMap[ImGuiKey_UpArrow] = GLFW_KEY_UP;
+    io.KeyMap[ImGuiKey_DownArrow] = GLFW_KEY_DOWN;
+    io.KeyMap[ImGuiKey_PageUp] = GLFW_KEY_PAGE_UP;
+    io.KeyMap[ImGuiKey_PageDown] = GLFW_KEY_PAGE_DOWN;
+    io.KeyMap[ImGuiKey_Home] = GLFW_KEY_HOME;
+    io.KeyMap[ImGuiKey_End] = GLFW_KEY_END;
+    io.KeyMap[ImGuiKey_Insert] = GLFW_KEY_INSERT;
+    io.KeyMap[ImGuiKey_Delete] = GLFW_KEY_DELETE;
+    io.KeyMap[ImGuiKey_Backspace] = GLFW_KEY_BACKSPACE;
+    io.KeyMap[ImGuiKey_Space] = GLFW_KEY_SPACE;
+    io.KeyMap[ImGuiKey_Enter] = GLFW_KEY_ENTER;
+    io.KeyMap[ImGuiKey_Escape] = GLFW_KEY_ESCAPE;
+    io.KeyMap[ImGuiKey_KeyPadEnter] = GLFW_KEY_KP_ENTER;
+    io.KeyMap[ImGuiKey_A] = GLFW_KEY_A;
+    io.KeyMap[ImGuiKey_C] = GLFW_KEY_C;
+    io.KeyMap[ImGuiKey_V] = GLFW_KEY_V;
+    io.KeyMap[ImGuiKey_X] = GLFW_KEY_X;
+    io.KeyMap[ImGuiKey_Y] = GLFW_KEY_Y;
+    io.KeyMap[ImGuiKey_Z] = GLFW_KEY_Z;
+
+    io.SetClipboardTextFn = ImGui_ImplGlfw_SetClipboardText;
+    io.GetClipboardTextFn = ImGui_ImplGlfw_GetClipboardText;
+    io.ClipboardUserData = g_Window;
+#if defined(_WIN32)
+    io.ImeWindowHandle = (void*)glfwGetWin32Window(g_Window);
+#endif
+
+    // Create mouse cursors
+    // (By design, on X11 cursors are user configurable and some cursors may be missing. When a cursor doesn't exist,
+    // GLFW will emit an error which will often be printed by the app, so we temporarily disable error reporting.
+    // Missing cursors will return NULL and our _UpdateMouseCursor() function will use the Arrow cursor instead.)
+    GLFWerrorfun prev_error_callback = glfwSetErrorCallback(NULL);
+    g_MouseCursors[ImGuiMouseCursor_Arrow] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    g_MouseCursors[ImGuiMouseCursor_TextInput] = glfwCreateStandardCursor(GLFW_IBEAM_CURSOR);
+    g_MouseCursors[ImGuiMouseCursor_ResizeNS] = glfwCreateStandardCursor(GLFW_VRESIZE_CURSOR);
+    g_MouseCursors[ImGuiMouseCursor_ResizeEW] = glfwCreateStandardCursor(GLFW_HRESIZE_CURSOR);
+    g_MouseCursors[ImGuiMouseCursor_Hand] = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
+#if GLFW_HAS_NEW_CURSORS
+    g_MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_RESIZE_ALL_CURSOR);
+    g_MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_RESIZE_NESW_CURSOR);
+    g_MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_RESIZE_NWSE_CURSOR);
+    g_MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_NOT_ALLOWED_CURSOR);
+#else
+    g_MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    g_MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    g_MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    g_MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+#endif
+    glfwSetErrorCallback(prev_error_callback);
+
+    // Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
+    g_PrevUserCallbackMousebutton = NULL;
+    g_PrevUserCallbackScroll = NULL;
+    g_PrevUserCallbackKey = NULL;
+    g_PrevUserCallbackChar = NULL;
+    if (install_callbacks)
+    {
+        g_InstalledCallbacks = true;
+        g_PrevUserCallbackMousebutton = glfwSetMouseButtonCallback(window, ImGui_ImplGlfw_MouseButtonCallback);
+        g_PrevUserCallbackScroll = glfwSetScrollCallback(window, ImGui_ImplGlfw_ScrollCallback);
+        g_PrevUserCallbackKey = glfwSetKeyCallback(window, ImGui_ImplGlfw_KeyCallback);
+        g_PrevUserCallbackChar = glfwSetCharCallback(window, ImGui_ImplGlfw_CharCallback);
+    }
+
+    g_ClientApi = client_api;
+    return true;
+}
+
+bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks)
+{
+    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_OpenGL);
+}
+
+bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks)
+{
+    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_Vulkan);
+}
+
+void ImGui_ImplGlfw_Shutdown()
+{
+    if (g_InstalledCallbacks)
+    {
+        glfwSetMouseButtonCallback(g_Window, g_PrevUserCallbackMousebutton);
+        glfwSetScrollCallback(g_Window, g_PrevUserCallbackScroll);
+        glfwSetKeyCallback(g_Window, g_PrevUserCallbackKey);
+        glfwSetCharCallback(g_Window, g_PrevUserCallbackChar);
+        g_InstalledCallbacks = false;
+    }
+
+    for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++)
+    {
+        glfwDestroyCursor(g_MouseCursors[cursor_n]);
+        g_MouseCursors[cursor_n] = NULL;
+    }
+    g_ClientApi = GlfwClientApi_Unknown;
+}
+
+static void ImGui_ImplGlfw_UpdateMousePosAndButtons()
+{
+    // Update buttons
+    ImGuiIO& io = ImGui::GetIO();
+    for (int i = 0; i < IM_ARRAYSIZE(io.MouseDown); i++)
+    {
+        // If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
+        io.MouseDown[i] = g_MouseJustPressed[i] || glfwGetMouseButton(g_Window, i) != 0;
+        g_MouseJustPressed[i] = false;
+    }
+
+    // Update mouse position
+    const ImVec2 mouse_pos_backup = io.MousePos;
+    io.MousePos = ImVec2(-FLT_MAX, -FLT_MAX);
+#ifdef __EMSCRIPTEN__
+    const bool focused = true; // Emscripten
+#else
+    const bool focused = glfwGetWindowAttrib(g_Window, GLFW_FOCUSED) != 0;
+#endif
+    if (focused)
+    {
+        if (io.WantSetMousePos)
+        {
+            glfwSetCursorPos(g_Window, (double)mouse_pos_backup.x, (double)mouse_pos_backup.y);
+        }
+        else
+        {
+            double mouse_x, mouse_y;
+            glfwGetCursorPos(g_Window, &mouse_x, &mouse_y);
+            io.MousePos = ImVec2((float)mouse_x, (float)mouse_y);
+        }
+    }
+}
+
+static void ImGui_ImplGlfw_UpdateMouseCursor()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    if ((io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) || glfwGetInputMode(g_Window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
+        return;
+
+    ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
+    if (imgui_cursor == ImGuiMouseCursor_None || io.MouseDrawCursor)
+    {
+        // Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
+        glfwSetInputMode(g_Window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
+    }
+    else
+    {
+        // Show OS mouse cursor
+        // FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
+        glfwSetCursor(g_Window, g_MouseCursors[imgui_cursor] ? g_MouseCursors[imgui_cursor] : g_MouseCursors[ImGuiMouseCursor_Arrow]);
+        glfwSetInputMode(g_Window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+    }
+}
+
+static void ImGui_ImplGlfw_UpdateGamepads()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    memset(io.NavInputs, 0, sizeof(io.NavInputs));
+    if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0)
+        return;
+
+    // Update gamepad inputs
+    #define MAP_BUTTON(NAV_NO, BUTTON_NO)       { if (buttons_count > BUTTON_NO && buttons[BUTTON_NO] == GLFW_PRESS) io.NavInputs[NAV_NO] = 1.0f; }
+    #define MAP_ANALOG(NAV_NO, AXIS_NO, V0, V1) { float v = (axes_count > AXIS_NO) ? axes[AXIS_NO] : V0; v = (v - V0) / (V1 - V0); if (v > 1.0f) v = 1.0f; if (io.NavInputs[NAV_NO] < v) io.NavInputs[NAV_NO] = v; }
+    int axes_count = 0, buttons_count = 0;
+    const float* axes = glfwGetJoystickAxes(GLFW_JOYSTICK_1, &axes_count);
+    const unsigned char* buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_1, &buttons_count);
+    MAP_BUTTON(ImGuiNavInput_Activate,   0);     // Cross / A
+    MAP_BUTTON(ImGuiNavInput_Cancel,     1);     // Circle / B
+    MAP_BUTTON(ImGuiNavInput_Menu,       2);     // Square / X
+    MAP_BUTTON(ImGuiNavInput_Input,      3);     // Triangle / Y
+    MAP_BUTTON(ImGuiNavInput_DpadLeft,   13);    // D-Pad Left
+    MAP_BUTTON(ImGuiNavInput_DpadRight,  11);    // D-Pad Right
+    MAP_BUTTON(ImGuiNavInput_DpadUp,     10);    // D-Pad Up
+    MAP_BUTTON(ImGuiNavInput_DpadDown,   12);    // D-Pad Down
+    MAP_BUTTON(ImGuiNavInput_FocusPrev,  4);     // L1 / LB
+    MAP_BUTTON(ImGuiNavInput_FocusNext,  5);     // R1 / RB
+    MAP_BUTTON(ImGuiNavInput_TweakSlow,  4);     // L1 / LB
+    MAP_BUTTON(ImGuiNavInput_TweakFast,  5);     // R1 / RB
+    MAP_ANALOG(ImGuiNavInput_LStickLeft, 0,  -0.3f,  -0.9f);
+    MAP_ANALOG(ImGuiNavInput_LStickRight,0,  +0.3f,  +0.9f);
+    MAP_ANALOG(ImGuiNavInput_LStickUp,   1,  +0.3f,  +0.9f);
+    MAP_ANALOG(ImGuiNavInput_LStickDown, 1,  -0.3f,  -0.9f);
+    #undef MAP_BUTTON
+    #undef MAP_ANALOG
+    if (axes_count > 0 && buttons_count > 0)
+        io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
+    else
+        io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
+}
+
+void ImGui_ImplGlfw_NewFrame()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    IM_ASSERT(io.Fonts->IsBuilt() && "Font atlas not built! It is generally built by the renderer back-end. Missing call to renderer _NewFrame() function? e.g. ImGui_ImplOpenGL3_NewFrame().");
+
+    // Setup display size (every frame to accommodate for window resizing)
+    int w, h;
+    int display_w, display_h;
+    glfwGetWindowSize(g_Window, &w, &h);
+    glfwGetFramebufferSize(g_Window, &display_w, &display_h);
+    io.DisplaySize = ImVec2((float)w, (float)h);
+    if (w > 0 && h > 0)
+        io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h);
+
+    // Setup time step
+    double current_time = glfwGetTime();
+    io.DeltaTime = g_Time > 0.0 ? (float)(current_time - g_Time) : (float)(1.0f/60.0f);
+    g_Time = current_time;
+
+    ImGui_ImplGlfw_UpdateMousePosAndButtons();
+    ImGui_ImplGlfw_UpdateMouseCursor();
+
+    // Update game controllers (if enabled and available)
+    ImGui_ImplGlfw_UpdateGamepads();
+}

core/src/imgui/imgui_impl_glfw.h

@@ -0,0 +1,35 @@
+// dear imgui: Platform Binding for GLFW
+// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan..)
+// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
+
+// Implemented features:
+//  [X] Platform: Clipboard support.
+//  [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
+//  [x] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'. FIXME: 3 cursors types are missing from GLFW.
+//  [X] Platform: Keyboard arrays indexed using GLFW_KEY_* codes, e.g. ImGui::IsKeyPressed(GLFW_KEY_SPACE).
+
+// You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this.
+// If you are new to dear imgui, read examples/README.txt and read the documentation at the top of imgui.cpp.
+// https://github.com/ocornut/imgui
+
+// About GLSL version:
+// The 'glsl_version' initialization parameter defaults to "#version 150" if NULL.
+// Only override if your GL version doesn't handle this GLSL version. Keep NULL if unsure!
+
+#pragma once
+#include "imgui.h"      // IMGUI_IMPL_API
+
+struct GLFWwindow;
+
+IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks);
+IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_Shutdown();
+IMGUI_IMPL_API void     ImGui_ImplGlfw_NewFrame();
+
+// GLFW callbacks
+// - When calling Init with 'install_callbacks=true': GLFW callbacks will be installed for you. They will call user's previously installed callbacks, if any.
+// - When calling Init with 'install_callbacks=false': GLFW callbacks won't be installed. You will need to call those function yourself from your own GLFW callbacks.
+IMGUI_IMPL_API void     ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c);

core/src/imgui/imgui_impl_opengl3.cpp

@@ -0,0 +1,677 @@
+// dear imgui: Renderer for modern OpenGL with shaders / programmatic pipeline
+// - Desktop GL: 2.x 3.x 4.x
+// - Embedded GL: ES 2.0 (WebGL 1.0), ES 3.0 (WebGL 2.0)
+// This needs to be used along with a Platform Binding (e.g. GLFW, SDL, Win32, custom..)
+
+// Implemented features:
+//  [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
+//  [x] Renderer: Desktop GL only: Support for large meshes (64k+ vertices) with 16-bit indices.
+
+// You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this.
+// If you are new to dear imgui, read examples/README.txt and read the documentation at the top of imgui.cpp.
+// https://github.com/ocornut/imgui
+
+// CHANGELOG
+// (minor and older changes stripped away, please see git history for details)
+//  2020-05-08: OpenGL: Made default GLSL version 150 (instead of 130) on OSX.
+//  2020-04-21: OpenGL: Fixed handling of glClipControl(GL_UPPER_LEFT) by inverting projection matrix.
+//  2020-04-12: OpenGL: Fixed context version check mistakenly testing for 4.0+ instead of 3.2+ to enable ImGuiBackendFlags_RendererHasVtxOffset.
+//  2020-03-24: OpenGL: Added support for glbinding 2.x OpenGL loader.
+//  2020-01-07: OpenGL: Added support for glbinding 3.x OpenGL loader.
+//  2019-10-25: OpenGL: Using a combination of GL define and runtime GL version to decide whether to use glDrawElementsBaseVertex(). Fix building with pre-3.2 GL loaders.
+//  2019-09-22: OpenGL: Detect default GL loader using __has_include compiler facility.
+//  2019-09-16: OpenGL: Tweak initialization code to allow application calling ImGui_ImplOpenGL3_CreateFontsTexture() before the first NewFrame() call.
+//  2019-05-29: OpenGL: Desktop GL only: Added support for large mesh (64K+ vertices), enable ImGuiBackendFlags_RendererHasVtxOffset flag.
+//  2019-04-30: OpenGL: Added support for special ImDrawCallback_ResetRenderState callback to reset render state.
+//  2019-03-29: OpenGL: Not calling glBindBuffer more than necessary in the render loop.
+//  2019-03-15: OpenGL: Added a dummy GL call + comments in ImGui_ImplOpenGL3_Init() to detect uninitialized GL function loaders early.
+//  2019-03-03: OpenGL: Fix support for ES 2.0 (WebGL 1.0).
+//  2019-02-20: OpenGL: Fix for OSX not supporting OpenGL 4.5, we don't try to read GL_CLIP_ORIGIN even if defined by the headers/loader.
+//  2019-02-11: OpenGL: Projecting clipping rectangles correctly using draw_data->FramebufferScale to allow multi-viewports for retina display.
+//  2019-02-01: OpenGL: Using GLSL 410 shaders for any version over 410 (e.g. 430, 450).
+//  2018-11-30: Misc: Setting up io.BackendRendererName so it can be displayed in the About Window.
+//  2018-11-13: OpenGL: Support for GL 4.5's glClipControl(GL_UPPER_LEFT) / GL_CLIP_ORIGIN.
+//  2018-08-29: OpenGL: Added support for more OpenGL loaders: glew and glad, with comments indicative that any loader can be used.
+//  2018-08-09: OpenGL: Default to OpenGL ES 3 on iOS and Android. GLSL version default to "#version 300 ES".
+//  2018-07-30: OpenGL: Support for GLSL 300 ES and 410 core. Fixes for Emscripten compilation.
+//  2018-07-10: OpenGL: Support for more GLSL versions (based on the GLSL version string). Added error output when shaders fail to compile/link.
+//  2018-06-08: Misc: Extracted imgui_impl_opengl3.cpp/.h away from the old combined GLFW/SDL+OpenGL3 examples.
+//  2018-06-08: OpenGL: Use draw_data->DisplayPos and draw_data->DisplaySize to setup projection matrix and clipping rectangle.
+//  2018-05-25: OpenGL: Removed unnecessary backup/restore of GL_ELEMENT_ARRAY_BUFFER_BINDING since this is part of the VAO state.
+//  2018-05-14: OpenGL: Making the call to glBindSampler() optional so 3.2 context won't fail if the function is a NULL pointer.
+//  2018-03-06: OpenGL: Added const char* glsl_version parameter to ImGui_ImplOpenGL3_Init() so user can override the GLSL version e.g. "#version 150".
+//  2018-02-23: OpenGL: Create the VAO in the render function so the setup can more easily be used with multiple shared GL context.
+//  2018-02-16: Misc: Obsoleted the io.RenderDrawListsFn callback and exposed ImGui_ImplSdlGL3_RenderDrawData() in the .h file so you can call it yourself.
+//  2018-01-07: OpenGL: Changed GLSL shader version from 330 to 150.
+//  2017-09-01: OpenGL: Save and restore current bound sampler. Save and restore current polygon mode.
+//  2017-05-01: OpenGL: Fixed save and restore of current blend func state.
+//  2017-05-01: OpenGL: Fixed save and restore of current GL_ACTIVE_TEXTURE.
+//  2016-09-05: OpenGL: Fixed save and restore of current scissor rectangle.
+//  2016-07-29: OpenGL: Explicitly setting GL_UNPACK_ROW_LENGTH to reduce issues because SDL changes it. (#752)
+
+//----------------------------------------
+// OpenGL    GLSL      GLSL
+// version   version   string
+//----------------------------------------
+//  2.0       110       "#version 110"
+//  2.1       120       "#version 120"
+//  3.0       130       "#version 130"
+//  3.1       140       "#version 140"
+//  3.2       150       "#version 150"
+//  3.3       330       "#version 330 core"
+//  4.0       400       "#version 400 core"
+//  4.1       410       "#version 410 core"
+//  4.2       420       "#version 410 core"
+//  4.3       430       "#version 430 core"
+//  ES 2.0    100       "#version 100"      = WebGL 1.0
+//  ES 3.0    300       "#version 300 es"   = WebGL 2.0
+//----------------------------------------
+
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "imgui.h"
+#include "imgui_impl_opengl3.h"
+#include <stdio.h>
+#if defined(_MSC_VER) && _MSC_VER <= 1500 // MSVC 2008 or earlier
+#include <stddef.h>     // intptr_t
+#else
+#include <stdint.h>     // intptr_t
+#endif
+
+
+// GL includes
+#if defined(IMGUI_IMPL_OPENGL_ES2)
+#include <GLES2/gl2.h>
+#elif defined(IMGUI_IMPL_OPENGL_ES3)
+#if (defined(__APPLE__) && (TARGET_OS_IOS || TARGET_OS_TV))
+#include <OpenGLES/ES3/gl.h>    // Use GL ES 3
+#else
+#include <GLES3/gl3.h>          // Use GL ES 3
+#endif
+#else
+// About Desktop OpenGL function loaders:
+//  Modern desktop OpenGL doesn't have a standard portable header file to load OpenGL function pointers.
+//  Helper libraries are often used for this purpose! Here we are supporting a few common ones (gl3w, glew, glad).
+//  You may use another loader/header of your choice (glext, glLoadGen, etc.), or chose to manually implement your own.
+#if defined(IMGUI_IMPL_OPENGL_LOADER_GL3W)
+#include <GL/gl3w.h>            // Needs to be initialized with gl3wInit() in user's code
+#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLEW)
+#include <GL/glew.h>            // Needs to be initialized with glewInit() in user's code.
+#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLAD)
+#include <glad/glad.h>          // Needs to be initialized with gladLoadGL() in user's code.
+#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING2)
+#ifndef GLFW_INCLUDE_NONE
+#define GLFW_INCLUDE_NONE       // GLFW including OpenGL headers causes ambiguity or multiple definition errors.
+#endif
+#include <glbinding/Binding.h>  // Needs to be initialized with glbinding::Binding::initialize() in user's code.
+#include <glbinding/gl/gl.h>
+using namespace gl;
+#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING3)
+#ifndef GLFW_INCLUDE_NONE
+#define GLFW_INCLUDE_NONE       // GLFW including OpenGL headers causes ambiguity or multiple definition errors.
+#endif
+#include <glbinding/glbinding.h>// Needs to be initialized with glbinding::initialize() in user's code.
+#include <glbinding/gl/gl.h>
+using namespace gl;
+#else
+#include IMGUI_IMPL_OPENGL_LOADER_CUSTOM
+#endif
+#endif
+
+// Desktop GL 3.2+ has glDrawElementsBaseVertex() which GL ES and WebGL don't have.
+#if defined(IMGUI_IMPL_OPENGL_ES2) || defined(IMGUI_IMPL_OPENGL_ES3) || !defined(GL_VERSION_3_2)
+#define IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET   0
+#else
+#define IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET   1
+#endif
+
+// OpenGL Data
+static GLuint       g_GlVersion = 0;                // Extracted at runtime using GL_MAJOR_VERSION, GL_MINOR_VERSION queries (e.g. 320 for GL 3.2)
+static char         g_GlslVersionString[32] = "";   // Specified by user or detected based on compile time GL settings.
+static GLuint       g_FontTexture = 0;
+static GLuint       g_ShaderHandle = 0, g_VertHandle = 0, g_FragHandle = 0;
+static GLint        g_AttribLocationTex = 0, g_AttribLocationProjMtx = 0;                                // Uniforms location
+static GLuint       g_AttribLocationVtxPos = 0, g_AttribLocationVtxUV = 0, g_AttribLocationVtxColor = 0; // Vertex attributes location
+static unsigned int g_VboHandle = 0, g_ElementsHandle = 0;
+
+// Functions
+bool    ImGui_ImplOpenGL3_Init(const char* glsl_version)
+{
+    // Query for GL version (e.g. 320 for GL 3.2)
+#if !defined(IMGUI_IMPL_OPENGL_ES2)
+    GLint major, minor;
+    glGetIntegerv(GL_MAJOR_VERSION, &major);
+    glGetIntegerv(GL_MINOR_VERSION, &minor);
+    g_GlVersion = (GLuint)(major * 100 + minor * 10);
+#else
+    g_GlVersion = 200; // GLES 2
+#endif
+
+    // Setup back-end capabilities flags
+    ImGuiIO& io = ImGui::GetIO();
+    io.BackendRendererName = "imgui_impl_opengl3";
+#if IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
+    if (g_GlVersion >= 320)
+        io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset;  // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
+#endif
+
+    // Store GLSL version string so we can refer to it later in case we recreate shaders.
+    // Note: GLSL version is NOT the same as GL version. Leave this to NULL if unsure.
+#if defined(IMGUI_IMPL_OPENGL_ES2)
+    if (glsl_version == NULL)
+        glsl_version = "#version 100";
+#elif defined(IMGUI_IMPL_OPENGL_ES3)
+    if (glsl_version == NULL)
+        glsl_version = "#version 300 es";
+#elif defined(__APPLE__)
+    if (glsl_version == NULL)
+        glsl_version = "#version 150";
+#else
+    if (glsl_version == NULL)
+        glsl_version = "#version 130";
+#endif
+    IM_ASSERT((int)strlen(glsl_version) + 2 < IM_ARRAYSIZE(g_GlslVersionString));
+    strcpy(g_GlslVersionString, glsl_version);
+    strcat(g_GlslVersionString, "\n");
+
+    // Dummy construct to make it easily visible in the IDE and debugger which GL loader has been selected.
+    // The code actually never uses the 'gl_loader' variable! It is only here so you can read it!
+    // If auto-detection fails or doesn't select the same GL loader file as used by your application,
+    // you are likely to get a crash below.
+    // You can explicitly select a loader by using '#define IMGUI_IMPL_OPENGL_LOADER_XXX' in imconfig.h or compiler command-line.
+    const char* gl_loader = "Unknown";
+    IM_UNUSED(gl_loader);
+#if defined(IMGUI_IMPL_OPENGL_LOADER_GL3W)
+    gl_loader = "GL3W";
+#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLEW)
+    gl_loader = "GLEW";
+#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLAD)
+    gl_loader = "GLAD";
+#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING2)
+    gl_loader = "glbinding2";
+#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING3)
+    gl_loader = "glbinding3";
+#elif defined(IMGUI_IMPL_OPENGL_LOADER_CUSTOM)
+    gl_loader = "custom";
+#else
+    gl_loader = "none";
+#endif
+
+    // Make a dummy GL call (we don't actually need the result)
+    // IF YOU GET A CRASH HERE: it probably means that you haven't initialized the OpenGL function loader used by this code.
+    // Desktop OpenGL 3/4 need a function loader. See the IMGUI_IMPL_OPENGL_LOADER_xxx explanation above.
+    GLint current_texture;
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
+
+    return true;
+}
+
+void    ImGui_ImplOpenGL3_Shutdown()
+{
+    ImGui_ImplOpenGL3_DestroyDeviceObjects();
+}
+
+void    ImGui_ImplOpenGL3_NewFrame()
+{
+    if (!g_ShaderHandle)
+        ImGui_ImplOpenGL3_CreateDeviceObjects();
+}
+
+static void ImGui_ImplOpenGL3_SetupRenderState(ImDrawData* draw_data, int fb_width, int fb_height, GLuint vertex_array_object)
+{
+    // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, polygon fill
+    glEnable(GL_BLEND);
+    glBlendEquation(GL_FUNC_ADD);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glDisable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glEnable(GL_SCISSOR_TEST);
+#ifdef GL_POLYGON_MODE
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+#endif
+
+    // Support for GL 4.5 rarely used glClipControl(GL_UPPER_LEFT)
+    bool clip_origin_lower_left = true;
+#if defined(GL_CLIP_ORIGIN) && !defined(__APPLE__)
+    GLenum current_clip_origin = 0; glGetIntegerv(GL_CLIP_ORIGIN, (GLint*)&current_clip_origin);
+    if (current_clip_origin == GL_UPPER_LEFT)
+        clip_origin_lower_left = false;
+#endif
+
+    // Setup viewport, orthographic projection matrix
+    // Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayPos is (0,0) for single viewport apps.
+    glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height);
+    float L = draw_data->DisplayPos.x;
+    float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
+    float T = draw_data->DisplayPos.y;
+    float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
+    if (!clip_origin_lower_left) { float tmp = T; T = B; B = tmp; } // Swap top and bottom if origin is upper left
+    const float ortho_projection[4][4] =
+    {
+        { 2.0f/(R-L),   0.0f,         0.0f,   0.0f },
+        { 0.0f,         2.0f/(T-B),   0.0f,   0.0f },
+        { 0.0f,         0.0f,        -1.0f,   0.0f },
+        { (R+L)/(L-R),  (T+B)/(B-T),  0.0f,   1.0f },
+    };
+    glUseProgram(g_ShaderHandle);
+    glUniform1i(g_AttribLocationTex, 0);
+    glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
+#ifdef GL_SAMPLER_BINDING
+    glBindSampler(0, 0); // We use combined texture/sampler state. Applications using GL 3.3 may set that otherwise.
+#endif
+
+    (void)vertex_array_object;
+#ifndef IMGUI_IMPL_OPENGL_ES2
+    glBindVertexArray(vertex_array_object);
+#endif
+
+    // Bind vertex/index buffers and setup attributes for ImDrawVert
+    glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle);
+    glEnableVertexAttribArray(g_AttribLocationVtxPos);
+    glEnableVertexAttribArray(g_AttribLocationVtxUV);
+    glEnableVertexAttribArray(g_AttribLocationVtxColor);
+    glVertexAttribPointer(g_AttribLocationVtxPos,   2, GL_FLOAT,         GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, pos));
+    glVertexAttribPointer(g_AttribLocationVtxUV,    2, GL_FLOAT,         GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, uv));
+    glVertexAttribPointer(g_AttribLocationVtxColor, 4, GL_UNSIGNED_BYTE, GL_TRUE,  sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, col));
+}
+
+// OpenGL3 Render function.
+// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop)
+// Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly, in order to be able to run within any OpenGL engine that doesn't do so.
+void    ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data)
+{
+    // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
+    int fb_width = (int)(draw_data->DisplaySize.x * draw_data->FramebufferScale.x);
+    int fb_height = (int)(draw_data->DisplaySize.y * draw_data->FramebufferScale.y);
+    if (fb_width <= 0 || fb_height <= 0)
+        return;
+
+    // Backup GL state
+    GLenum last_active_texture; glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint*)&last_active_texture);
+    glActiveTexture(GL_TEXTURE0);
+    GLuint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, (GLint*)&last_program);
+    GLuint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*)&last_texture);
+#ifdef GL_SAMPLER_BINDING
+    GLuint last_sampler; glGetIntegerv(GL_SAMPLER_BINDING, (GLint*)&last_sampler);
+#endif
+    GLuint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (GLint*)&last_array_buffer);
+#ifndef IMGUI_IMPL_OPENGL_ES2
+    GLuint last_vertex_array_object; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, (GLint*)&last_vertex_array_object);
+#endif
+#ifdef GL_POLYGON_MODE
+    GLint last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode);
+#endif
+    GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
+    GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box);
+    GLenum last_blend_src_rgb; glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*)&last_blend_src_rgb);
+    GLenum last_blend_dst_rgb; glGetIntegerv(GL_BLEND_DST_RGB, (GLint*)&last_blend_dst_rgb);
+    GLenum last_blend_src_alpha; glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*)&last_blend_src_alpha);
+    GLenum last_blend_dst_alpha; glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*)&last_blend_dst_alpha);
+    GLenum last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*)&last_blend_equation_rgb);
+    GLenum last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*)&last_blend_equation_alpha);
+    GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
+    GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
+    GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
+    GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
+
+    // Setup desired GL state
+    // Recreate the VAO every time (this is to easily allow multiple GL contexts to be rendered to. VAO are not shared among GL contexts)
+    // The renderer would actually work without any VAO bound, but then our VertexAttrib calls would overwrite the default one currently bound.
+    GLuint vertex_array_object = 0;
+#ifndef IMGUI_IMPL_OPENGL_ES2
+    glGenVertexArrays(1, &vertex_array_object);
+#endif
+    ImGui_ImplOpenGL3_SetupRenderState(draw_data, fb_width, fb_height, vertex_array_object);
+
+    // Will project scissor/clipping rectangles into framebuffer space
+    ImVec2 clip_off = draw_data->DisplayPos;         // (0,0) unless using multi-viewports
+    ImVec2 clip_scale = draw_data->FramebufferScale; // (1,1) unless using retina display which are often (2,2)
+
+    // Render command lists
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
+    {
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+
+        // Upload vertex/index buffers
+        glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.Size * (int)sizeof(ImDrawVert), (const GLvoid*)cmd_list->VtxBuffer.Data, GL_STREAM_DRAW);
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.Size * (int)sizeof(ImDrawIdx), (const GLvoid*)cmd_list->IdxBuffer.Data, GL_STREAM_DRAW);
+
+        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
+        {
+            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
+            if (pcmd->UserCallback != NULL)
+            {
+                // User callback, registered via ImDrawList::AddCallback()
+                // (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
+                if (pcmd->UserCallback == ImDrawCallback_ResetRenderState)
+                    ImGui_ImplOpenGL3_SetupRenderState(draw_data, fb_width, fb_height, vertex_array_object);
+                else
+                    pcmd->UserCallback(cmd_list, pcmd);
+            }
+            else
+            {
+                // Project scissor/clipping rectangles into framebuffer space
+                ImVec4 clip_rect;
+                clip_rect.x = (pcmd->ClipRect.x - clip_off.x) * clip_scale.x;
+                clip_rect.y = (pcmd->ClipRect.y - clip_off.y) * clip_scale.y;
+                clip_rect.z = (pcmd->ClipRect.z - clip_off.x) * clip_scale.x;
+                clip_rect.w = (pcmd->ClipRect.w - clip_off.y) * clip_scale.y;
+
+                if (clip_rect.x < fb_width && clip_rect.y < fb_height && clip_rect.z >= 0.0f && clip_rect.w >= 0.0f)
+                {
+                    // Apply scissor/clipping rectangle
+                    glScissor((int)clip_rect.x, (int)(fb_height - clip_rect.w), (int)(clip_rect.z - clip_rect.x), (int)(clip_rect.w - clip_rect.y));
+
+                    // Bind texture, Draw
+                    glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
+#if IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
+                    if (g_GlVersion >= 320)
+                        glDrawElementsBaseVertex(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx)), (GLint)pcmd->VtxOffset);
+                    else
+#endif
+                    glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx)));
+                }
+            }
+        }
+    }
+
+    // Destroy the temporary VAO
+#ifndef IMGUI_IMPL_OPENGL_ES2
+    glDeleteVertexArrays(1, &vertex_array_object);
+#endif
+
+    // Restore modified GL state
+    glUseProgram(last_program);
+    glBindTexture(GL_TEXTURE_2D, last_texture);
+#ifdef GL_SAMPLER_BINDING
+    glBindSampler(0, last_sampler);
+#endif
+    glActiveTexture(last_active_texture);
+#ifndef IMGUI_IMPL_OPENGL_ES2
+    glBindVertexArray(last_vertex_array_object);
+#endif
+    glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
+    glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
+    glBlendFuncSeparate(last_blend_src_rgb, last_blend_dst_rgb, last_blend_src_alpha, last_blend_dst_alpha);
+    if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND);
+    if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE);
+    if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
+    if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
+#ifdef GL_POLYGON_MODE
+    glPolygonMode(GL_FRONT_AND_BACK, (GLenum)last_polygon_mode[0]);
+#endif
+    glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
+    glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]);
+}
+
+bool ImGui_ImplOpenGL3_CreateFontsTexture()
+{
+    // Build texture atlas
+    ImGuiIO& io = ImGui::GetIO();
+    unsigned char* pixels;
+    int width, height;
+    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);   // Load as RGBA 32-bit (75% of the memory is wasted, but default font is so small) because it is more likely to be compatible with user's existing shaders. If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory.
+
+    // Upload texture to graphics system
+    GLint last_texture;
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
+    glGenTextures(1, &g_FontTexture);
+    glBindTexture(GL_TEXTURE_2D, g_FontTexture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+#ifdef GL_UNPACK_ROW_LENGTH
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+#endif
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+
+    // Store our identifier
+    io.Fonts->TexID = (ImTextureID)(intptr_t)g_FontTexture;
+
+    // Restore state
+    glBindTexture(GL_TEXTURE_2D, last_texture);
+
+    return true;
+}
+
+void ImGui_ImplOpenGL3_DestroyFontsTexture()
+{
+    if (g_FontTexture)
+    {
+        ImGuiIO& io = ImGui::GetIO();
+        glDeleteTextures(1, &g_FontTexture);
+        io.Fonts->TexID = 0;
+        g_FontTexture = 0;
+    }
+}
+
+// If you get an error please report on github. You may try different GL context version or GLSL version. See GL<>GLSL version table at the top of this file.
+static bool CheckShader(GLuint handle, const char* desc)
+{
+    GLint status = 0, log_length = 0;
+    glGetShaderiv(handle, GL_COMPILE_STATUS, &status);
+    glGetShaderiv(handle, GL_INFO_LOG_LENGTH, &log_length);
+    if ((GLboolean)status == GL_FALSE)
+        fprintf(stderr, "ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to compile %s!\n", desc);
+    if (log_length > 1)
+    {
+        ImVector<char> buf;
+        buf.resize((int)(log_length + 1));
+        glGetShaderInfoLog(handle, log_length, NULL, (GLchar*)buf.begin());
+        fprintf(stderr, "%s\n", buf.begin());
+    }
+    return (GLboolean)status == GL_TRUE;
+}
+
+// If you get an error please report on GitHub. You may try different GL context version or GLSL version.
+static bool CheckProgram(GLuint handle, const char* desc)
+{
+    GLint status = 0, log_length = 0;
+    glGetProgramiv(handle, GL_LINK_STATUS, &status);
+    glGetProgramiv(handle, GL_INFO_LOG_LENGTH, &log_length);
+    if ((GLboolean)status == GL_FALSE)
+        fprintf(stderr, "ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to link %s! (with GLSL '%s')\n", desc, g_GlslVersionString);
+    if (log_length > 1)
+    {
+        ImVector<char> buf;
+        buf.resize((int)(log_length + 1));
+        glGetProgramInfoLog(handle, log_length, NULL, (GLchar*)buf.begin());
+        fprintf(stderr, "%s\n", buf.begin());
+    }
+    return (GLboolean)status == GL_TRUE;
+}
+
+bool    ImGui_ImplOpenGL3_CreateDeviceObjects()
+{
+    // Backup GL state
+    GLint last_texture, last_array_buffer;
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
+#ifndef IMGUI_IMPL_OPENGL_ES2
+    GLint last_vertex_array;
+    glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
+#endif
+
+    // Parse GLSL version string
+    int glsl_version = 130;
+    sscanf(g_GlslVersionString, "#version %d", &glsl_version);
+
+    const GLchar* vertex_shader_glsl_120 =
+        "uniform mat4 ProjMtx;\n"
+        "attribute vec2 Position;\n"
+        "attribute vec2 UV;\n"
+        "attribute vec4 Color;\n"
+        "varying vec2 Frag_UV;\n"
+        "varying vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
+
+    const GLchar* vertex_shader_glsl_130 =
+        "uniform mat4 ProjMtx;\n"
+        "in vec2 Position;\n"
+        "in vec2 UV;\n"
+        "in vec4 Color;\n"
+        "out vec2 Frag_UV;\n"
+        "out vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
+
+    const GLchar* vertex_shader_glsl_300_es =
+        "precision mediump float;\n"
+        "layout (location = 0) in vec2 Position;\n"
+        "layout (location = 1) in vec2 UV;\n"
+        "layout (location = 2) in vec4 Color;\n"
+        "uniform mat4 ProjMtx;\n"
+        "out vec2 Frag_UV;\n"
+        "out vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
+
+    const GLchar* vertex_shader_glsl_410_core =
+        "layout (location = 0) in vec2 Position;\n"
+        "layout (location = 1) in vec2 UV;\n"
+        "layout (location = 2) in vec4 Color;\n"
+        "uniform mat4 ProjMtx;\n"
+        "out vec2 Frag_UV;\n"
+        "out vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
+
+    const GLchar* fragment_shader_glsl_120 =
+        "#ifdef GL_ES\n"
+        "    precision mediump float;\n"
+        "#endif\n"
+        "uniform sampler2D Texture;\n"
+        "varying vec2 Frag_UV;\n"
+        "varying vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st);\n"
+        "}\n";
+
+    const GLchar* fragment_shader_glsl_130 =
+        "uniform sampler2D Texture;\n"
+        "in vec2 Frag_UV;\n"
+        "in vec4 Frag_Color;\n"
+        "out vec4 Out_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
+        "}\n";
+
+    const GLchar* fragment_shader_glsl_300_es =
+        "precision mediump float;\n"
+        "uniform sampler2D Texture;\n"
+        "in vec2 Frag_UV;\n"
+        "in vec4 Frag_Color;\n"
+        "layout (location = 0) out vec4 Out_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
+        "}\n";
+
+    const GLchar* fragment_shader_glsl_410_core =
+        "in vec2 Frag_UV;\n"
+        "in vec4 Frag_Color;\n"
+        "uniform sampler2D Texture;\n"
+        "layout (location = 0) out vec4 Out_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
+        "}\n";
+
+    // Select shaders matching our GLSL versions
+    const GLchar* vertex_shader = NULL;
+    const GLchar* fragment_shader = NULL;
+    if (glsl_version < 130)
+    {
+        vertex_shader = vertex_shader_glsl_120;
+        fragment_shader = fragment_shader_glsl_120;
+    }
+    else if (glsl_version >= 410)
+    {
+        vertex_shader = vertex_shader_glsl_410_core;
+        fragment_shader = fragment_shader_glsl_410_core;
+    }
+    else if (glsl_version == 300)
+    {
+        vertex_shader = vertex_shader_glsl_300_es;
+        fragment_shader = fragment_shader_glsl_300_es;
+    }
+    else
+    {
+        vertex_shader = vertex_shader_glsl_130;
+        fragment_shader = fragment_shader_glsl_130;
+    }
+
+    // Create shaders
+    const GLchar* vertex_shader_with_version[2] = { g_GlslVersionString, vertex_shader };
+    g_VertHandle = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(g_VertHandle, 2, vertex_shader_with_version, NULL);
+    glCompileShader(g_VertHandle);
+    CheckShader(g_VertHandle, "vertex shader");
+
+    const GLchar* fragment_shader_with_version[2] = { g_GlslVersionString, fragment_shader };
+    g_FragHandle = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(g_FragHandle, 2, fragment_shader_with_version, NULL);
+    glCompileShader(g_FragHandle);
+    CheckShader(g_FragHandle, "fragment shader");
+
+    g_ShaderHandle = glCreateProgram();
+    glAttachShader(g_ShaderHandle, g_VertHandle);
+    glAttachShader(g_ShaderHandle, g_FragHandle);
+    glLinkProgram(g_ShaderHandle);
+    CheckProgram(g_ShaderHandle, "shader program");
+
+    g_AttribLocationTex = glGetUniformLocation(g_ShaderHandle, "Texture");
+    g_AttribLocationProjMtx = glGetUniformLocation(g_ShaderHandle, "ProjMtx");
+    g_AttribLocationVtxPos = (GLuint)glGetAttribLocation(g_ShaderHandle, "Position");
+    g_AttribLocationVtxUV = (GLuint)glGetAttribLocation(g_ShaderHandle, "UV");
+    g_AttribLocationVtxColor = (GLuint)glGetAttribLocation(g_ShaderHandle, "Color");
+
+    // Create buffers
+    glGenBuffers(1, &g_VboHandle);
+    glGenBuffers(1, &g_ElementsHandle);
+
+    ImGui_ImplOpenGL3_CreateFontsTexture();
+
+    // Restore modified GL state
+    glBindTexture(GL_TEXTURE_2D, last_texture);
+    glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
+#ifndef IMGUI_IMPL_OPENGL_ES2
+    glBindVertexArray(last_vertex_array);
+#endif
+
+    return true;
+}
+
+void    ImGui_ImplOpenGL3_DestroyDeviceObjects()
+{
+    if (g_VboHandle)        { glDeleteBuffers(1, &g_VboHandle); g_VboHandle = 0; }
+    if (g_ElementsHandle)   { glDeleteBuffers(1, &g_ElementsHandle); g_ElementsHandle = 0; }
+    if (g_ShaderHandle && g_VertHandle) { glDetachShader(g_ShaderHandle, g_VertHandle); }
+    if (g_ShaderHandle && g_FragHandle) { glDetachShader(g_ShaderHandle, g_FragHandle); }
+    if (g_VertHandle)       { glDeleteShader(g_VertHandle); g_VertHandle = 0; }
+    if (g_FragHandle)       { glDeleteShader(g_FragHandle); g_FragHandle = 0; }
+    if (g_ShaderHandle)     { glDeleteProgram(g_ShaderHandle); g_ShaderHandle = 0; }
+
+    ImGui_ImplOpenGL3_DestroyFontsTexture();
+}

core/src/imgui/imgui_impl_opengl3.h

@@ -0,0 +1,84 @@
+// dear imgui: Renderer for modern OpenGL with shaders / programmatic pipeline
+// - Desktop GL: 2.x 3.x 4.x
+// - Embedded GL: ES 2.0 (WebGL 1.0), ES 3.0 (WebGL 2.0)
+// This needs to be used along with a Platform Binding (e.g. GLFW, SDL, Win32, custom..)
+
+// Implemented features:
+//  [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
+//  [x] Renderer: Desktop GL only: Support for large meshes (64k+ vertices) with 16-bit indices.
+
+// You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this.
+// If you are new to dear imgui, read examples/README.txt and read the documentation at the top of imgui.cpp.
+// https://github.com/ocornut/imgui
+
+// About Desktop OpenGL function loaders:
+//  Modern Desktop OpenGL doesn't have a standard portable header file to load OpenGL function pointers.
+//  Helper libraries are often used for this purpose! Here we are supporting a few common ones (gl3w, glew, glad).
+//  You may use another loader/header of your choice (glext, glLoadGen, etc.), or chose to manually implement your own.
+
+// About GLSL version:
+//  The 'glsl_version' initialization parameter should be NULL (default) or a "#version XXX" string.
+//  On computer platform the GLSL version default to "#version 130". On OpenGL ES 3 platform it defaults to "#version 300 es"
+//  Only override if your GL version doesn't handle this GLSL version. See GLSL version table at the top of imgui_impl_opengl3.cpp.
+
+#pragma once
+#include "imgui.h"      // IMGUI_IMPL_API
+
+// Backend API
+IMGUI_IMPL_API bool     ImGui_ImplOpenGL3_Init(const char* glsl_version = NULL);
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_Shutdown();
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_NewFrame();
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
+
+// (Optional) Called by Init/NewFrame/Shutdown
+IMGUI_IMPL_API bool     ImGui_ImplOpenGL3_CreateFontsTexture();
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_DestroyFontsTexture();
+IMGUI_IMPL_API bool     ImGui_ImplOpenGL3_CreateDeviceObjects();
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_DestroyDeviceObjects();
+
+// Specific OpenGL ES versions
+//#define IMGUI_IMPL_OPENGL_ES2     // Auto-detected on Emscripten
+//#define IMGUI_IMPL_OPENGL_ES3     // Auto-detected on iOS/Android
+
+// Attempt to auto-detect the default Desktop GL loader based on available header files.
+// If auto-detection fails or doesn't select the same GL loader file as used by your application,
+// you are likely to get a crash in ImGui_ImplOpenGL3_Init().
+// You can explicitly select a loader by using one of the '#define IMGUI_IMPL_OPENGL_LOADER_XXX' in imconfig.h or compiler command-line.
+#if !defined(IMGUI_IMPL_OPENGL_ES2) \
+ && !defined(IMGUI_IMPL_OPENGL_ES3) \
+ && !defined(IMGUI_IMPL_OPENGL_LOADER_GL3W) \
+ && !defined(IMGUI_IMPL_OPENGL_LOADER_GLEW) \
+ && !defined(IMGUI_IMPL_OPENGL_LOADER_GLAD) \
+ && !defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING2) \
+ && !defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING3) \
+ && !defined(IMGUI_IMPL_OPENGL_LOADER_CUSTOM)
+
+// Try to detect GLES on matching platforms
+#if defined(__APPLE__)
+#include "TargetConditionals.h"
+#endif
+#if (defined(__APPLE__) && (TARGET_OS_IOS || TARGET_OS_TV)) || (defined(__ANDROID__))
+#define IMGUI_IMPL_OPENGL_ES3               // iOS, Android  -> GL ES 3, "#version 300 es"
+#elif defined(__EMSCRIPTEN__)
+#define IMGUI_IMPL_OPENGL_ES2               // Emscripten    -> GL ES 2, "#version 100"
+
+// Otherwise try to detect supported Desktop OpenGL loaders..
+#elif defined(__has_include)
+#if __has_include(<GL/glew.h>)
+    #define IMGUI_IMPL_OPENGL_LOADER_GLEW
+#elif __has_include(<glad/glad.h>)
+    #define IMGUI_IMPL_OPENGL_LOADER_GLAD
+#elif __has_include(<GL/gl3w.h>)
+    #define IMGUI_IMPL_OPENGL_LOADER_GL3W
+#elif __has_include(<glbinding/glbinding.h>)
+    #define IMGUI_IMPL_OPENGL_LOADER_GLBINDING3
+#elif __has_include(<glbinding/Binding.h>)
+    #define IMGUI_IMPL_OPENGL_LOADER_GLBINDING2
+#else
+    #error "Cannot detect OpenGL loader!"
+#endif
+#else
+    #define IMGUI_IMPL_OPENGL_LOADER_GL3W   // Default to GL3W embedded in our repository
+#endif
+
+#endif

core/src/imgui/imgui_plot.cpp

@@ -0,0 +1,263 @@
+#include <imgui_plot.h>
+#include <imgui.h>
+#ifndef IMGUI_DEFINE_MATH_OPERATORS
+#define IMGUI_DEFINE_MATH_OPERATORS
+#endif
+#include <imgui_internal.h>
+
+namespace ImGui {
+// [0..1] -> [0..1]
+static float rescale(float t, float min, float max, PlotConfig::Scale::Type type) {
+    switch (type) {
+    case PlotConfig::Scale::Linear:
+        return t;
+    case PlotConfig::Scale::Log10:
+        return log10(ImLerp(min, max, t) / min) / log10(max / min);
+    }
+    return 0;
+}
+
+// [0..1] -> [0..1]
+static float rescale_inv(float t, float min, float max, PlotConfig::Scale::Type type) {
+    switch (type) {
+    case PlotConfig::Scale::Linear:
+        return t;
+    case PlotConfig::Scale::Log10:
+        return (pow(max/min, t) * min - min) / (max - min);
+    }
+    return 0;
+}
+
+static int cursor_to_idx(const ImVec2& pos, const ImRect& bb, const PlotConfig& conf, float x_min, float x_max) {
+    const float t = ImClamp((pos.x - bb.Min.x) / (bb.Max.x - bb.Min.x), 0.0f, 0.9999f);
+    const int v_idx = (int)(rescale_inv(t, x_min, x_max, conf.scale.type) * (conf.values.count - 1));
+    IM_ASSERT(v_idx >= 0 && v_idx < conf.values.count);
+
+    return v_idx;
+}
+
+PlotStatus Plot(const char* label, const PlotConfig& conf) {
+    PlotStatus status = PlotStatus::nothing;
+
+    ImGuiWindow* window = GetCurrentWindow();
+    if (window->SkipItems)
+        return status;
+
+    const float* const* ys_list = conf.values.ys_list;
+    int ys_count = conf.values.ys_count;
+    const ImU32* colors = conf.values.colors;
+    if (conf.values.ys != nullptr) { // draw only a single plot
+        ys_list = &conf.values.ys;
+        ys_count = 1;
+        colors = &conf.values.color;
+    }
+
+    ImGuiContext& g = *GImGui;
+    const ImGuiStyle& style = g.Style;
+    const ImGuiID id = window->GetID(label);
+
+    const ImRect frame_bb(
+        window->DC.CursorPos,
+        window->DC.CursorPos + conf.frame_size);
+    const ImRect inner_bb(
+        frame_bb.Min + style.FramePadding,
+        frame_bb.Max - style.FramePadding);
+    const ImRect total_bb = frame_bb;
+    ItemSize(total_bb, style.FramePadding.y);
+    if (!ItemAdd(total_bb, 0, &frame_bb))
+        return status;
+    const bool hovered = ItemHoverable(frame_bb, id);
+
+    RenderFrame(
+        frame_bb.Min,
+        frame_bb.Max,
+        GetColorU32(ImGuiCol_WindowBg),
+        true,
+        style.FrameRounding);
+
+    if (conf.values.count > 0) {
+        int res_w;
+        if (conf.skip_small_lines)
+            res_w = ImMin((int)conf.frame_size.x, conf.values.count);
+        else
+            res_w = conf.values.count;
+        res_w -= 1;
+        int item_count = conf.values.count - 1;
+
+        float x_min = conf.values.offset;
+        float x_max = conf.values.offset + conf.values.count - 1;
+        if (conf.values.xs) {
+            x_min = conf.values.xs[size_t(x_min)];
+            x_max = conf.values.xs[size_t(x_max)];
+        }
+
+        // Tooltip on hover
+        int v_hovered = -1;
+        if (conf.tooltip.show && hovered && inner_bb.Contains(g.IO.MousePos)) {
+            const int v_idx = cursor_to_idx(g.IO.MousePos, inner_bb, conf, x_min, x_max);
+            const size_t data_idx = conf.values.offset + (v_idx % conf.values.count);
+            const float x0 = conf.values.xs ? conf.values.xs[data_idx] : v_idx;
+            const float y0 = ys_list[0][data_idx]; // TODO: tooltip is only shown for the first y-value!
+            SetTooltip(conf.tooltip.format, x0, y0);
+            v_hovered = v_idx;
+        }
+
+        const float t_step = 1.0f / (float)res_w;
+        const float inv_scale = (conf.scale.min == conf.scale.max) ?
+                                    0.0f : (1.0f / (conf.scale.max - conf.scale.min));
+
+        if (conf.grid_x.show) {
+            int y0 = inner_bb.Min.y;
+            int y1 = inner_bb.Max.y;
+            switch (conf.scale.type) {
+            case PlotConfig::Scale::Linear: {
+                float cnt = conf.values.count / (conf.grid_x.size / conf.grid_x.subticks);
+                float inc = 1.f / cnt;
+                for (int i = 0; i <= cnt; ++i) {
+                    int x0 = ImLerp(inner_bb.Min.x, inner_bb.Max.x, i * inc);
+                    window->DrawList->AddLine(
+                        ImVec2(x0, y0),
+                        ImVec2(x0, y1),
+                        IM_COL32(200, 200, 200, (i % conf.grid_x.subticks) ? 128 : 255));
+                }
+                break;
+            }
+            case PlotConfig::Scale::Log10: {
+                float start = 1.f;
+                while (start < x_max) {
+                    for (int i = 1; i < 10; ++i) {
+                        float x = start * i;
+                        if (x < x_min) continue;
+                        if (x > x_max) break;
+                        float t = log10(x / x_min) / log10(x_max / x_min);
+                        int x0 = ImLerp(inner_bb.Min.x, inner_bb.Max.x, t);
+                        window->DrawList->AddLine(
+                            ImVec2(x0, y0),
+                            ImVec2(x0, y1),
+                            IM_COL32(200, 200, 200, (i > 1) ? 128 : 255));
+                    }
+                    start *= 10.f;
+                }
+                break;
+            }
+            }
+        }
+        if (conf.grid_y.show) {
+            int x0 = inner_bb.Min.x;
+            int x1 = inner_bb.Max.x;
+            float cnt = (conf.scale.max - conf.scale.min) / (conf.grid_y.size / conf.grid_y.subticks);
+            float inc = 1.f / cnt;
+            for (int i = 0; i <= cnt; ++i) {
+                int y0 = ImLerp(inner_bb.Min.y, inner_bb.Max.y, i * inc);
+                window->DrawList->AddLine(
+                    ImVec2(x0, y0),
+                    ImVec2(x1, y0),
+                    IM_COL32(0, 0, 0, (i % conf.grid_y.subticks) ? 16 : 64));
+            }
+        }
+
+        const ImU32 col_hovered = GetColorU32(ImGuiCol_PlotLinesHovered);
+        ImU32 col_base = GetColorU32(ImGuiCol_PlotLines);
+
+        for (int i = 0; i < ys_count; ++i) {
+            if (colors) {
+                if (colors[i]) col_base = colors[i];
+                else col_base = GetColorU32(ImGuiCol_PlotLines);
+            }
+            float v0 = ys_list[i][conf.values.offset];
+            float t0 = 0.0f;
+            // Point in the normalized space of our target rectangle
+            ImVec2 tp0 = ImVec2(t0, 1.0f - ImSaturate((v0 - conf.scale.min) * inv_scale));
+
+            for (int n = 0; n < res_w; n++)
+            {
+                const float t1 = t0 + t_step;
+                const int v1_idx = (int)(t0 * item_count + 0.5f);
+                IM_ASSERT(v1_idx >= 0 && v1_idx < conf.values.count);
+                const float v1 = ys_list[i][conf.values.offset + (v1_idx + 1) % conf.values.count];
+                const ImVec2 tp1 = ImVec2(
+                    rescale(t1, x_min, x_max, conf.scale.type),
+                    1.0f - ImSaturate((v1 - conf.scale.min) * inv_scale));
+
+            // NB: Draw calls are merged together by the DrawList system. Still, we should render our batch are lower level to save a bit of CPU.
+                ImVec2 pos0 = ImLerp(inner_bb.Min, inner_bb.Max, tp0);
+                ImVec2 pos1 = ImLerp(inner_bb.Min, inner_bb.Max, tp1);
+
+                if (v1_idx == v_hovered) {
+                    window->DrawList->AddCircleFilled(pos0, 3, col_hovered);
+                }
+
+                window->DrawList->AddLine(
+                    pos0,
+                    pos1,
+                    col_base,
+                    conf.line_thickness);
+
+                t0 = t1;
+                tp0 = tp1;
+            }
+        }
+
+        if (conf.v_lines.show) {
+            for (size_t i = 0; i < conf.v_lines.count; ++i) {
+                const size_t idx = conf.v_lines.indices[i];
+                const float t1 = rescale(idx * t_step, x_min, x_max, conf.scale.type);
+                ImVec2 pos0 = ImLerp(inner_bb.Min, inner_bb.Max, ImVec2(t1, 0.f));
+                ImVec2 pos1 = ImLerp(inner_bb.Min, inner_bb.Max, ImVec2(t1, 1.f));
+                window->DrawList->AddLine(pos0, pos1, IM_COL32(0xff, 0, 0, 0x88));
+            }
+        }
+
+        if (conf.selection.show) {
+            if (hovered) {
+                if (g.IO.MouseClicked[0]) {
+                    SetActiveID(id, window);
+                    FocusWindow(window);
+
+                    const int v_idx = cursor_to_idx(g.IO.MousePos, inner_bb, conf, x_min, x_max);
+                    uint32_t start = conf.values.offset + (v_idx % conf.values.count);
+                    uint32_t end = start;
+                    if (conf.selection.sanitize_fn)
+                        end = conf.selection.sanitize_fn(end - start) + start;
+                    if (end < conf.values.offset + conf.values.count) {
+                        *conf.selection.start = start;
+                        *conf.selection.length = end - start;
+                        status = PlotStatus::selection_updated;
+                    }
+                }
+            }
+
+            if (g.ActiveId == id) {
+                if (g.IO.MouseDown[0]) {
+                    const int v_idx = cursor_to_idx(g.IO.MousePos, inner_bb, conf, x_min, x_max);
+                    const uint32_t start = *conf.selection.start;
+                    uint32_t end = conf.values.offset + (v_idx % conf.values.count);
+                    if (end > start) {
+                        if (conf.selection.sanitize_fn)
+                            end = conf.selection.sanitize_fn(end - start) + start;
+                        if (end < conf.values.offset + conf.values.count) {
+                            *conf.selection.length = end - start;
+                            status = PlotStatus::selection_updated;
+                        }
+                    }
+                } else {
+                    ClearActiveID();
+                }
+            }
+            float fSelectionStep = 1.0 / item_count;
+            ImVec2 pos0 = ImLerp(inner_bb.Min, inner_bb.Max,
+                                 ImVec2(fSelectionStep * *conf.selection.start, 0.f));
+            ImVec2 pos1 = ImLerp(inner_bb.Min, inner_bb.Max,
+                                ImVec2(fSelectionStep * (*conf.selection.start + *conf.selection.length), 1.f));
+            window->DrawList->AddRectFilled(pos0, pos1, IM_COL32(128, 128, 128, 32));
+            window->DrawList->AddRect(pos0, pos1, IM_COL32(128, 128, 128, 128));
+        }
+    }
+
+    // Text overlay
+    if (conf.overlay_text)
+        RenderTextClipped(ImVec2(frame_bb.Min.x, frame_bb.Min.y + style.FramePadding.y), frame_bb.Max, conf.overlay_text, NULL, NULL, ImVec2(0.5f,0.0f));
+
+    return status;
+}
+}

core/src/imgui/imgui_plot.h

@@ -0,0 +1,75 @@
+#pragma once
+#include <cstdint>
+#include <imgui.h>
+
+namespace ImGui {
+// Use this structure to pass the plot data and settings into the Plot function
+struct PlotConfig {
+    struct Values {
+        // if necessary, you can provide x-axis values
+        const float *xs = nullptr;
+        // array of y values. If null, use ys_list (below)
+        const float *ys = nullptr;
+        // the number of values in each array
+        int count;
+        // at which offset to start plotting.
+        // Warning: count+offset must be <= length of array!
+        int offset = 0;
+        // Plot color. If 0, use ImGuiCol_PlotLines.
+        ImU32 color = 0;
+
+        // in case you need to draw multiple plots at once, use this instead of ys
+        const float **ys_list = nullptr;
+        // the number of plots to draw
+        int ys_count = 0;
+        // colors for each plot
+        const ImU32* colors = nullptr;
+    } values;
+    struct Scale {
+        // Minimum plot value
+        float min;
+        // Maximum plot value
+        float max;
+        enum Type {
+            Linear,
+            Log10,
+        };
+        // How to scale the x-axis
+        Type type = Linear;
+    } scale;
+    struct Tooltip {
+        bool show = false;
+        const char* format = "%g: %8.4g";
+    } tooltip;
+    struct Grid {
+        bool show = false;
+        float size = 100; // at which intervals to draw the grid
+        int subticks = 10; // how many subticks in each tick
+    } grid_x, grid_y;
+    struct Selection {
+        bool show = false;
+        uint32_t* start = nullptr;
+        uint32_t* length = nullptr;
+        // "Sanitize" function. Give it selection length, and it will return
+        // the "allowed" length. Useful for FFT, where selection must be
+        // of power of two
+        uint32_t(*sanitize_fn)(uint32_t) = nullptr;
+    } selection;
+    struct VerticalLines {
+        bool show = false;
+        const size_t* indices = nullptr; // at which indices to draw the lines
+        size_t count = 0;
+    } v_lines;
+    ImVec2 frame_size = ImVec2(0.f, 0.f);
+    float line_thickness = 1.f;
+    bool skip_small_lines = true;
+    const char* overlay_text = nullptr;
+};
+
+enum class PlotStatus {
+    nothing,
+    selection_updated,
+};
+
+IMGUI_API PlotStatus Plot(const char* label, const PlotConfig& conf);
+}

core/src/imgui/imstb_rectpack.h

@@ -0,0 +1,639 @@
+// [DEAR IMGUI]
+// This is a slightly modified version of stb_rect_pack.h 1.00.
+// Those changes would need to be pushed into nothings/stb:
+// - Added STBRP__CDECL
+// Grep for [DEAR IMGUI] to find the changes.
+
+// stb_rect_pack.h - v1.00 - public domain - rectangle packing
+// Sean Barrett 2014
+//
+// Useful for e.g. packing rectangular textures into an atlas.
+// Does not do rotation.
+//
+// Not necessarily the awesomest packing method, but better than
+// the totally naive one in stb_truetype (which is primarily what
+// this is meant to replace).
+//
+// Has only had a few tests run, may have issues.
+//
+// More docs to come.
+//
+// No memory allocations; uses qsort() and assert() from stdlib.
+// Can override those by defining STBRP_SORT and STBRP_ASSERT.
+//
+// This library currently uses the Skyline Bottom-Left algorithm.
+//
+// Please note: better rectangle packers are welcome! Please
+// implement them to the same API, but with a different init
+// function.
+//
+// Credits
+//
+//  Library
+//    Sean Barrett
+//  Minor features
+//    Martins Mozeiko
+//    github:IntellectualKitty
+//    
+//  Bugfixes / warning fixes
+//    Jeremy Jaussaud
+//    Fabian Giesen
+//
+// Version history:
+//
+//     1.00  (2019-02-25)  avoid small space waste; gracefully fail too-wide rectangles
+//     0.99  (2019-02-07)  warning fixes
+//     0.11  (2017-03-03)  return packing success/fail result
+//     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
+//     0.09  (2016-08-27)  fix compiler warnings
+//     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
+//     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
+//     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
+//     0.05:  added STBRP_ASSERT to allow replacing assert
+//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
+//     0.01:  initial release
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//       INCLUDE SECTION
+//
+
+#ifndef STB_INCLUDE_STB_RECT_PACK_H
+#define STB_INCLUDE_STB_RECT_PACK_H
+
+#define STB_RECT_PACK_VERSION  1
+
+#ifdef STBRP_STATIC
+#define STBRP_DEF static
+#else
+#define STBRP_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct stbrp_context stbrp_context;
+typedef struct stbrp_node    stbrp_node;
+typedef struct stbrp_rect    stbrp_rect;
+
+#ifdef STBRP_LARGE_RECTS
+typedef int            stbrp_coord;
+#else
+typedef unsigned short stbrp_coord;
+#endif
+
+STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
+// Assign packed locations to rectangles. The rectangles are of type
+// 'stbrp_rect' defined below, stored in the array 'rects', and there
+// are 'num_rects' many of them.
+//
+// Rectangles which are successfully packed have the 'was_packed' flag
+// set to a non-zero value and 'x' and 'y' store the minimum location
+// on each axis (i.e. bottom-left in cartesian coordinates, top-left
+// if you imagine y increasing downwards). Rectangles which do not fit
+// have the 'was_packed' flag set to 0.
+//
+// You should not try to access the 'rects' array from another thread
+// while this function is running, as the function temporarily reorders
+// the array while it executes.
+//
+// To pack into another rectangle, you need to call stbrp_init_target
+// again. To continue packing into the same rectangle, you can call
+// this function again. Calling this multiple times with multiple rect
+// arrays will probably produce worse packing results than calling it
+// a single time with the full rectangle array, but the option is
+// available.
+//
+// The function returns 1 if all of the rectangles were successfully
+// packed and 0 otherwise.
+
+struct stbrp_rect
+{
+   // reserved for your use:
+   int            id;
+
+   // input:
+   stbrp_coord    w, h;
+
+   // output:
+   stbrp_coord    x, y;
+   int            was_packed;  // non-zero if valid packing
+
+}; // 16 bytes, nominally
+
+
+STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
+// Initialize a rectangle packer to:
+//    pack a rectangle that is 'width' by 'height' in dimensions
+//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
+//
+// You must call this function every time you start packing into a new target.
+//
+// There is no "shutdown" function. The 'nodes' memory must stay valid for
+// the following stbrp_pack_rects() call (or calls), but can be freed after
+// the call (or calls) finish.
+//
+// Note: to guarantee best results, either:
+//       1. make sure 'num_nodes' >= 'width'
+//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
+//
+// If you don't do either of the above things, widths will be quantized to multiples
+// of small integers to guarantee the algorithm doesn't run out of temporary storage.
+//
+// If you do #2, then the non-quantized algorithm will be used, but the algorithm
+// may run out of temporary storage and be unable to pack some rectangles.
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
+// Optionally call this function after init but before doing any packing to
+// change the handling of the out-of-temp-memory scenario, described above.
+// If you call init again, this will be reset to the default (false).
+
+
+STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
+// Optionally select which packing heuristic the library should use. Different
+// heuristics will produce better/worse results for different data sets.
+// If you call init again, this will be reset to the default.
+
+enum
+{
+   STBRP_HEURISTIC_Skyline_default=0,
+   STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
+   STBRP_HEURISTIC_Skyline_BF_sortHeight
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// the details of the following structures don't matter to you, but they must
+// be visible so you can handle the memory allocations for them
+
+struct stbrp_node
+{
+   stbrp_coord  x,y;
+   stbrp_node  *next;
+};
+
+struct stbrp_context
+{
+   int width;
+   int height;
+   int align;
+   int init_mode;
+   int heuristic;
+   int num_nodes;
+   stbrp_node *active_head;
+   stbrp_node *free_head;
+   stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     IMPLEMENTATION SECTION
+//
+
+#ifdef STB_RECT_PACK_IMPLEMENTATION
+#ifndef STBRP_SORT
+#include <stdlib.h>
+#define STBRP_SORT qsort
+#endif
+
+#ifndef STBRP_ASSERT
+#include <assert.h>
+#define STBRP_ASSERT assert
+#endif
+
+// [DEAR IMGUI] Added STBRP__CDECL
+#ifdef _MSC_VER
+#define STBRP__NOTUSED(v)  (void)(v)
+#define STBRP__CDECL __cdecl
+#else
+#define STBRP__NOTUSED(v)  (void)sizeof(v)
+#define STBRP__CDECL
+#endif
+
+enum
+{
+   STBRP__INIT_skyline = 1
+};
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
+{
+   switch (context->init_mode) {
+      case STBRP__INIT_skyline:
+         STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
+         context->heuristic = heuristic;
+         break;
+      default:
+         STBRP_ASSERT(0);
+   }
+}
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
+{
+   if (allow_out_of_mem)
+      // if it's ok to run out of memory, then don't bother aligning them;
+      // this gives better packing, but may fail due to OOM (even though
+      // the rectangles easily fit). @TODO a smarter approach would be to only
+      // quantize once we've hit OOM, then we could get rid of this parameter.
+      context->align = 1;
+   else {
+      // if it's not ok to run out of memory, then quantize the widths
+      // so that num_nodes is always enough nodes.
+      //
+      // I.e. num_nodes * align >= width
+      //                  align >= width / num_nodes
+      //                  align = ceil(width/num_nodes)
+
+      context->align = (context->width + context->num_nodes-1) / context->num_nodes;
+   }
+}
+
+STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
+{
+   int i;
+#ifndef STBRP_LARGE_RECTS
+   STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
+#endif
+
+   for (i=0; i < num_nodes-1; ++i)
+      nodes[i].next = &nodes[i+1];
+   nodes[i].next = NULL;
+   context->init_mode = STBRP__INIT_skyline;
+   context->heuristic = STBRP_HEURISTIC_Skyline_default;
+   context->free_head = &nodes[0];
+   context->active_head = &context->extra[0];
+   context->width = width;
+   context->height = height;
+   context->num_nodes = num_nodes;
+   stbrp_setup_allow_out_of_mem(context, 0);
+
+   // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
+   context->extra[0].x = 0;
+   context->extra[0].y = 0;
+   context->extra[0].next = &context->extra[1];
+   context->extra[1].x = (stbrp_coord) width;
+#ifdef STBRP_LARGE_RECTS
+   context->extra[1].y = (1<<30);
+#else
+   context->extra[1].y = 65535;
+#endif
+   context->extra[1].next = NULL;
+}
+
+// find minimum y position if it starts at x1
+static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
+{
+   stbrp_node *node = first;
+   int x1 = x0 + width;
+   int min_y, visited_width, waste_area;
+
+   STBRP__NOTUSED(c);
+
+   STBRP_ASSERT(first->x <= x0);
+
+   #if 0
+   // skip in case we're past the node
+   while (node->next->x <= x0)
+      ++node;
+   #else
+   STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
+   #endif
+
+   STBRP_ASSERT(node->x <= x0);
+
+   min_y = 0;
+   waste_area = 0;
+   visited_width = 0;
+   while (node->x < x1) {
+      if (node->y > min_y) {
+         // raise min_y higher.
+         // we've accounted for all waste up to min_y,
+         // but we'll now add more waste for everything we've visted
+         waste_area += visited_width * (node->y - min_y);
+         min_y = node->y;
+         // the first time through, visited_width might be reduced
+         if (node->x < x0)
+            visited_width += node->next->x - x0;
+         else
+            visited_width += node->next->x - node->x;
+      } else {
+         // add waste area
+         int under_width = node->next->x - node->x;
+         if (under_width + visited_width > width)
+            under_width = width - visited_width;
+         waste_area += under_width * (min_y - node->y);
+         visited_width += under_width;
+      }
+      node = node->next;
+   }
+
+   *pwaste = waste_area;
+   return min_y;
+}
+
+typedef struct
+{
+   int x,y;
+   stbrp_node **prev_link;
+} stbrp__findresult;
+
+static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
+{
+   int best_waste = (1<<30), best_x, best_y = (1 << 30);
+   stbrp__findresult fr;
+   stbrp_node **prev, *node, *tail, **best = NULL;
+
+   // align to multiple of c->align
+   width = (width + c->align - 1);
+   width -= width % c->align;
+   STBRP_ASSERT(width % c->align == 0);
+
+   // if it can't possibly fit, bail immediately
+   if (width > c->width || height > c->height) {
+      fr.prev_link = NULL;
+      fr.x = fr.y = 0;
+      return fr;
+   }
+
+   node = c->active_head;
+   prev = &c->active_head;
+   while (node->x + width <= c->width) {
+      int y,waste;
+      y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
+      if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
+         // bottom left
+         if (y < best_y) {
+            best_y = y;
+            best = prev;
+         }
+      } else {
+         // best-fit
+         if (y + height <= c->height) {
+            // can only use it if it first vertically
+            if (y < best_y || (y == best_y && waste < best_waste)) {
+               best_y = y;
+               best_waste = waste;
+               best = prev;
+            }
+         }
+      }
+      prev = &node->next;
+      node = node->next;
+   }
+
+   best_x = (best == NULL) ? 0 : (*best)->x;
+
+   // if doing best-fit (BF), we also have to try aligning right edge to each node position
+   //
+   // e.g, if fitting
+   //
+   //     ____________________
+   //    |____________________|
+   //
+   //            into
+   //
+   //   |                         |
+   //   |             ____________|
+   //   |____________|
+   //
+   // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
+   //
+   // This makes BF take about 2x the time
+
+   if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
+      tail = c->active_head;
+      node = c->active_head;
+      prev = &c->active_head;
+      // find first node that's admissible
+      while (tail->x < width)
+         tail = tail->next;
+      while (tail) {
+         int xpos = tail->x - width;
+         int y,waste;
+         STBRP_ASSERT(xpos >= 0);
+         // find the left position that matches this
+         while (node->next->x <= xpos) {
+            prev = &node->next;
+            node = node->next;
+         }
+         STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
+         y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
+         if (y + height <= c->height) {
+            if (y <= best_y) {
+               if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
+                  best_x = xpos;
+                  STBRP_ASSERT(y <= best_y);
+                  best_y = y;
+                  best_waste = waste;
+                  best = prev;
+               }
+            }
+         }
+         tail = tail->next;
+      }         
+   }
+
+   fr.prev_link = best;
+   fr.x = best_x;
+   fr.y = best_y;
+   return fr;
+}
+
+static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
+{
+   // find best position according to heuristic
+   stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
+   stbrp_node *node, *cur;
+
+   // bail if:
+   //    1. it failed
+   //    2. the best node doesn't fit (we don't always check this)
+   //    3. we're out of memory
+   if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
+      res.prev_link = NULL;
+      return res;
+   }
+
+   // on success, create new node
+   node = context->free_head;
+   node->x = (stbrp_coord) res.x;
+   node->y = (stbrp_coord) (res.y + height);
+
+   context->free_head = node->next;
+
+   // insert the new node into the right starting point, and
+   // let 'cur' point to the remaining nodes needing to be
+   // stiched back in
+
+   cur = *res.prev_link;
+   if (cur->x < res.x) {
+      // preserve the existing one, so start testing with the next one
+      stbrp_node *next = cur->next;
+      cur->next = node;
+      cur = next;
+   } else {
+      *res.prev_link = node;
+   }
+
+   // from here, traverse cur and free the nodes, until we get to one
+   // that shouldn't be freed
+   while (cur->next && cur->next->x <= res.x + width) {
+      stbrp_node *next = cur->next;
+      // move the current node to the free list
+      cur->next = context->free_head;
+      context->free_head = cur;
+      cur = next;
+   }
+
+   // stitch the list back in
+   node->next = cur;
+
+   if (cur->x < res.x + width)
+      cur->x = (stbrp_coord) (res.x + width);
+
+#ifdef _DEBUG
+   cur = context->active_head;
+   while (cur->x < context->width) {
+      STBRP_ASSERT(cur->x < cur->next->x);
+      cur = cur->next;
+   }
+   STBRP_ASSERT(cur->next == NULL);
+
+   {
+      int count=0;
+      cur = context->active_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      cur = context->free_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      STBRP_ASSERT(count == context->num_nodes+2);
+   }
+#endif
+
+   return res;
+}
+
+// [DEAR IMGUI] Added STBRP__CDECL
+static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   if (p->h > q->h)
+      return -1;
+   if (p->h < q->h)
+      return  1;
+   return (p->w > q->w) ? -1 : (p->w < q->w);
+}
+
+// [DEAR IMGUI] Added STBRP__CDECL
+static int STBRP__CDECL rect_original_order(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
+}
+
+#ifdef STBRP_LARGE_RECTS
+#define STBRP__MAXVAL  0xffffffff
+#else
+#define STBRP__MAXVAL  0xffff
+#endif
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
+{
+   int i, all_rects_packed = 1;
+
+   // we use the 'was_packed' field internally to allow sorting/unsorting
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = i;
+   }
+
+   // sort according to heuristic
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
+
+   for (i=0; i < num_rects; ++i) {
+      if (rects[i].w == 0 || rects[i].h == 0) {
+         rects[i].x = rects[i].y = 0;  // empty rect needs no space
+      } else {
+         stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
+         if (fr.prev_link) {
+            rects[i].x = (stbrp_coord) fr.x;
+            rects[i].y = (stbrp_coord) fr.y;
+         } else {
+            rects[i].x = rects[i].y = STBRP__MAXVAL;
+         }
+      }
+   }
+
+   // unsort
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
+
+   // set was_packed flags and all_rects_packed status
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
+      if (!rects[i].was_packed)
+         all_rects_packed = 0;
+   }
+
+   // return the all_rects_packed status
+   return all_rects_packed;
+}
+#endif
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do 
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this 
+software, either in source code form or as a compiled binary, for any purpose, 
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this 
+software dedicate any and all copyright interest in the software to the public 
+domain. We make this dedication for the benefit of the public at large and to 
+the detriment of our heirs and successors. We intend this dedication to be an 
+overt act of relinquishment in perpetuity of all present and future rights to 
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/

core/src/imgui/imutils.h

@@ -0,0 +1,2 @@
+#pragma once
+#define IS_IN_AREA(pos, min, max)   (pos.x >= min.x && pos.x < max.x && pos.y >= min.y && pos.y < max.y)

core/src/io/audio.h

@@ -0,0 +1,349 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <fstream>
+#include <portaudio.h>
+#include <spdlog/spdlog.h>
+
+namespace io {
+    class AudioSink {
+    public:
+        enum {
+            MONO,
+            STEREO,
+            _TYPE_COUNT
+        };
+
+        struct AudioDevice_t {
+            std::string name;
+            int index;
+            int channels;
+            std::vector<float> sampleRates;
+            std::string txtSampleRates;
+        };
+
+        AudioSink() {
+            
+        }
+
+        AudioSink(int bufferSize) {
+            _bufferSize = bufferSize;
+            monoBuffer = new float[_bufferSize];
+            stereoBuffer = new dsp::StereoFloat_t[_bufferSize];
+            _volume = 1.0f;
+            Pa_Initialize();
+
+            devTxtList = "";
+            int devCount = Pa_GetDeviceCount();
+            devIndex = Pa_GetDefaultOutputDevice();
+            const PaDeviceInfo *deviceInfo;
+            PaStreamParameters outputParams;
+            outputParams.sampleFormat = paFloat32;
+            outputParams.hostApiSpecificStreamInfo = NULL;
+            for(int i = 0; i < devCount; i++) {
+                deviceInfo = Pa_GetDeviceInfo(i);
+                if (deviceInfo->maxOutputChannels < 1) {
+                    continue;
+                }
+                AudioDevice_t dev;
+                dev.name = deviceInfo->name;
+                dev.index = i;
+                dev.channels = std::min<int>(deviceInfo->maxOutputChannels, 2);
+                dev.sampleRates.clear();
+                dev.txtSampleRates = "";
+                for (int j = 0; j < 6; j++) {
+                    outputParams.channelCount = dev.channels;
+                    outputParams.device = dev.index;
+                    outputParams.suggestedLatency = deviceInfo->defaultLowOutputLatency;
+                    PaError err = Pa_IsFormatSupported(NULL, &outputParams, POSSIBLE_SAMP_RATE[j]);
+                    if (err != paFormatIsSupported) {
+                        continue;
+                    }
+                    dev.sampleRates.push_back(POSSIBLE_SAMP_RATE[j]);
+                    dev.txtSampleRates += std::to_string((int)POSSIBLE_SAMP_RATE[j]);
+                    dev.txtSampleRates += '\0';
+                }
+                if (dev.sampleRates.size() == 0) {
+                    continue;
+                }
+                if (i == devIndex) {
+                    devListIndex = devices.size();
+                    defaultDev = devListIndex;
+                }
+                devices.push_back(dev);
+                deviceNames.push_back(deviceInfo->name);
+                devTxtList += deviceInfo->name;
+                devTxtList += '\0';
+            }
+        }
+
+        void init(int bufferSize) {
+            _bufferSize = bufferSize;
+            monoBuffer = new float[_bufferSize];
+            stereoBuffer = new dsp::StereoFloat_t[_bufferSize];
+            _volume = 1.0f;
+            Pa_Initialize();
+
+            devTxtList = "";
+            int devCount = Pa_GetDeviceCount();
+            devIndex = Pa_GetDefaultOutputDevice();
+            const PaDeviceInfo *deviceInfo;
+            PaStreamParameters outputParams;
+            outputParams.sampleFormat = paFloat32;
+            outputParams.hostApiSpecificStreamInfo = NULL;
+            for(int i = 0; i < devCount; i++) {
+                deviceInfo = Pa_GetDeviceInfo(i);
+                if (deviceInfo->maxOutputChannels < 1) {
+                    continue;
+                }
+                AudioDevice_t dev;
+                dev.name = deviceInfo->name;
+                dev.index = i;
+                dev.channels = std::min<int>(deviceInfo->maxOutputChannels, 2);
+                dev.sampleRates.clear();
+                dev.txtSampleRates = "";
+                for (int j = 0; j < 6; j++) {
+                    outputParams.channelCount = dev.channels;
+                    outputParams.device = dev.index;
+                    outputParams.suggestedLatency = deviceInfo->defaultLowOutputLatency;
+                    PaError err = Pa_IsFormatSupported(NULL, &outputParams, POSSIBLE_SAMP_RATE[j]);
+                    if (err != paFormatIsSupported) {
+                        continue;
+                    }
+                    dev.sampleRates.push_back(POSSIBLE_SAMP_RATE[j]);
+                    dev.txtSampleRates += std::to_string((int)POSSIBLE_SAMP_RATE[j]);
+                    dev.txtSampleRates += '\0';
+                }
+                if (dev.sampleRates.size() == 0) {
+                    continue;
+                }
+                if (i == devIndex) {
+                    devListIndex = devices.size();
+                    defaultDev = devListIndex;
+                }
+                devices.push_back(dev);
+                deviceNames.push_back(deviceInfo->name);
+                devTxtList += deviceInfo->name;
+                devTxtList += '\0';
+            }
+        }
+
+        void setMonoInput(dsp::stream<float>* input) {
+            _monoInput = input;
+        }
+
+        void setStereoInput(dsp::stream<dsp::StereoFloat_t>* input) {
+            _stereoInput = input;
+        }
+
+        void setVolume(float volume) {
+            _volume = volume;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            const PaDeviceInfo *deviceInfo;
+            AudioDevice_t dev = devices[devListIndex];
+            PaStreamParameters outputParams;
+            deviceInfo = Pa_GetDeviceInfo(dev.index);
+            outputParams.channelCount = 2;
+            outputParams.sampleFormat = paFloat32;
+            outputParams.hostApiSpecificStreamInfo = NULL;
+            outputParams.device = dev.index;
+            outputParams.suggestedLatency = Pa_GetDeviceInfo(outputParams.device)->defaultLowOutputLatency;
+            PaError err;
+            if (streamType == MONO) {
+                err = Pa_OpenStream(&stream, NULL, &outputParams, _sampleRate, _bufferSize, 0,
+                                (dev.channels == 2) ? _mono_to_stereo_callback : _mono_to_mono_callback, this);
+            }
+            else {
+                err = Pa_OpenStream(&stream, NULL, &outputParams, _sampleRate, _bufferSize, 0,
+                                (dev.channels == 2) ? _stereo_to_stereo_callback : _stereo_to_mono_callback, this);
+            }
+            
+            if (err != 0) {
+                spdlog::error("Error while opening audio stream: ({0}) => {1}", err, Pa_GetErrorText(err));
+                return;
+            }
+            err = Pa_StartStream(stream);
+            if (err != 0) {
+                spdlog::error("Error while starting audio stream: ({0}) => {1}", err, Pa_GetErrorText(err));
+                return;
+            }
+            spdlog::info("Audio device open.");
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            if (streamType == MONO) {
+                _monoInput->stopReader();
+            }
+            else {
+                _stereoInput->stopReader();
+            }
+            Pa_StopStream(stream);
+            Pa_CloseStream(stream);
+            if (streamType == MONO) {
+                _monoInput->clearReadStop();
+            }
+            else {
+                _stereoInput->clearReadStop();
+            }
+            running = false;
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _bufferSize = blockSize;
+            delete[] monoBuffer;
+            delete[] stereoBuffer;
+            monoBuffer = new float[_bufferSize];
+            stereoBuffer = new dsp::StereoFloat_t[_bufferSize];
+        }
+
+        void setSampleRate(float sampleRate) {
+            _sampleRate = sampleRate;
+        }
+
+        void setDevice(int id) {
+            if (devListIndex == id) {
+                return;
+            }
+            if (running) {
+                return;
+            }
+            devListIndex = id;
+            devIndex = devices[id].index;
+        }
+
+        void setToDefault() {
+            setDevice(defaultDev);
+        }
+
+        int getDeviceId() {
+            return devListIndex;
+        }
+
+        void setStreamType(int type) {
+            streamType = type;
+        }
+
+        std::string devTxtList;
+        std::vector<AudioDevice_t> devices;
+        std::vector<std::string> deviceNames;
+
+    private:
+        static int _mono_to_mono_callback(const void *input,
+                                      void *output,
+                                      unsigned long frameCount,
+                                      const PaStreamCallbackTimeInfo* timeInfo, 
+                                      PaStreamCallbackFlags statusFlags, void *userData ) {
+            AudioSink* _this = (AudioSink*)userData;
+            float* outbuf = (float*)output;
+            if (_this->_monoInput->read(_this->monoBuffer, frameCount) < 0) {
+                memset(outbuf, 0, sizeof(float) * frameCount);
+                return 0;
+            }
+            
+            float vol = powf(_this->_volume, 2);
+            for (int i = 0; i < frameCount; i++) {
+                outbuf[i] = _this->monoBuffer[i] * vol;
+            }
+            return 0;
+        }
+
+        static int _stereo_to_stereo_callback(const void *input,
+                                      void *output,
+                                      unsigned long frameCount,
+                                      const PaStreamCallbackTimeInfo* timeInfo, 
+                                      PaStreamCallbackFlags statusFlags, void *userData ) {
+            AudioSink* _this = (AudioSink*)userData;
+            dsp::StereoFloat_t* outbuf = (dsp::StereoFloat_t*)output;
+            if (_this->_stereoInput->read(_this->stereoBuffer, frameCount) < 0) {
+                memset(outbuf, 0, sizeof(dsp::StereoFloat_t) * frameCount);
+                return 0;
+            }
+
+            // Note: Calculate the power in the UI instead of here
+            
+            float vol = powf(_this->_volume, 2);
+            for (int i = 0; i < frameCount; i++) {
+                outbuf[i].l = _this->stereoBuffer[i].l * vol;
+                outbuf[i].r = _this->stereoBuffer[i].r * vol;
+            }
+            return 0;
+        }
+
+        static int _mono_to_stereo_callback(const void *input,
+                                      void *output,
+                                      unsigned long frameCount,
+                                      const PaStreamCallbackTimeInfo* timeInfo, 
+                                      PaStreamCallbackFlags statusFlags, void *userData ) {
+            AudioSink* _this = (AudioSink*)userData;
+            dsp::StereoFloat_t* outbuf = (dsp::StereoFloat_t*)output;
+            if (_this->_monoInput->read(_this->monoBuffer, frameCount) < 0) {
+                memset(outbuf, 0, sizeof(dsp::StereoFloat_t) * frameCount);
+                return 0;
+            }
+            
+            float vol = powf(_this->_volume, 2);
+            for (int i = 0; i < frameCount; i++) {
+                outbuf[i].l = _this->monoBuffer[i] * vol;
+                outbuf[i].r = _this->monoBuffer[i] * vol;
+            }
+            return 0;
+        }
+
+        static int _stereo_to_mono_callback(const void *input,
+                                      void *output,
+                                      unsigned long frameCount,
+                                      const PaStreamCallbackTimeInfo* timeInfo, 
+                                      PaStreamCallbackFlags statusFlags, void *userData ) {
+            AudioSink* _this = (AudioSink*)userData;
+            float* outbuf = (float*)output;
+            if (_this->_stereoInput->read(_this->stereoBuffer, frameCount) < 0) {
+                memset(outbuf, 0, sizeof(float) * frameCount);
+                return 0;
+            }
+
+            // Note: Calculate the power in the UI instead of here
+            
+            float vol = powf(_this->_volume, 2);
+            for (int i = 0; i < frameCount; i++) {
+                outbuf[i] = ((_this->stereoBuffer[i].l + _this->stereoBuffer[i].r) / 2.0f) * vol;
+            }
+            return 0;
+        }
+
+        float POSSIBLE_SAMP_RATE[6] = {
+            48000.0f,
+            44100.0f,
+            24000.0f,
+            22050.0f,
+            12000.0f,
+            11025.0f
+        };
+
+        int streamType;
+        int devIndex;
+        int devListIndex;
+        int defaultDev;
+        float _sampleRate;
+        int _bufferSize;
+        dsp::stream<float>* _monoInput;
+        dsp::stream<dsp::StereoFloat_t>* _stereoInput;
+        float* monoBuffer;
+        dsp::StereoFloat_t* stereoBuffer;
+        float _volume = 1.0f;
+        PaStream *stream;
+        bool running = false;
+    };
+};

core/src/io/soapy.h

@@ -0,0 +1,184 @@
+#include <string>
+#include <SoapySDR/Device.hpp>
+#include <SoapySDR/Modules.hpp>
+#include <SoapySDR/Logger.hpp>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <spdlog/spdlog.h>
+
+namespace io {
+    class SoapyWrapper {
+    public:
+        SoapyWrapper() {
+            
+        }
+
+        void init() {
+            SoapySDR::registerLogHandler(_logHandler);
+            //SoapySDR::Device::make("");
+            
+            output.init(64000);
+            currentGains = new float[1];
+            refresh();
+            if (devList.size() == 0) {
+                dev = NULL;
+                return;
+            }
+            setDevice(devList[0]);
+        }
+
+        void start() {
+            if (devList.size() == 0) {
+                return;
+            }
+            if (running) {
+                return;
+            }
+            dev = SoapySDR::Device::make(args);
+            _stream = dev->setupStream(SOAPY_SDR_RX, "CF32");
+            dev->activateStream(_stream);
+            running = true;
+            _workerThread = std::thread(_worker, this);
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            running = false;
+            dev->deactivateStream(_stream);
+            dev->closeStream(_stream);
+            _workerThread.join();
+            SoapySDR::Device::unmake(dev);
+        }
+
+        void refresh() {
+            if (running) {
+                return;
+            }
+            devList = SoapySDR::Device::enumerate();
+            txtDevList = "";
+            devNameList.clear();
+            if (devList.size() == 0) {
+                txtDevList += '\0';
+                return;
+            }
+            for (int i = 0; i < devList.size(); i++) {
+                txtDevList += devList[i]["label"];
+                txtDevList += '\0';
+                devNameList.push_back(devList[i]["label"]);
+            }
+        }
+
+        void setDevice(SoapySDR::Kwargs devArgs) {
+            if (running) {
+                return;
+            }
+            args = devArgs;
+            dev = SoapySDR::Device::make(devArgs);
+            txtSampleRateList = "";
+            sampleRates = dev->listSampleRates(SOAPY_SDR_RX, 0);
+            for (int i = 0; i < sampleRates.size(); i++) {
+                txtSampleRateList += std::to_string((int)sampleRates[i]);
+                txtSampleRateList += '\0';
+            }
+            _sampleRate = sampleRates[0];
+
+            gainList = dev->listGains(SOAPY_SDR_RX, 0);
+            gainRanges.clear();
+            if (gainList.size() == 0) {
+                return;
+            }
+            delete[] currentGains;
+            currentGains = new float[gainList.size()];
+            for (int i = 0; i < gainList.size(); i++) {
+                gainRanges.push_back(dev->getGainRange(SOAPY_SDR_RX, 0, gainList[i]));
+                SoapySDR::Range rng = dev->getGainRange(SOAPY_SDR_RX, 0, gainList[i]);
+
+                spdlog::info("{0}: {1} -> {2} (Step: {3})", gainList[i], rng.minimum(), rng.maximum(), rng.step());
+
+                currentGains[i] = rng.minimum();
+            }
+        }
+
+        void setSampleRate(float sampleRate) {
+            if (running || dev == NULL) {
+                return;
+            }
+            _sampleRate = sampleRate;
+            dev->setSampleRate(SOAPY_SDR_RX, 0, sampleRate);
+        }
+
+        void setFrequency(float freq) {
+            if (dev == NULL) {
+                return;
+            }
+            dev->setFrequency(SOAPY_SDR_RX, 0, freq);
+        }
+
+        void setGain(int gainId, float gain) {
+            if (dev == NULL) {
+                return;
+            }
+            currentGains[gainId] = gain;
+            dev->setGain(SOAPY_SDR_RX, 0, gainList[gainId], gain);
+        }
+
+        bool isRunning() {
+            return running;
+        }
+
+        float getSampleRate() {
+            return _sampleRate;
+        }
+
+        SoapySDR::KwargsList devList;
+        std::vector<std::string> devNameList;
+        std::string txtDevList;
+
+        std::vector<double> sampleRates;
+        std::string txtSampleRateList;
+
+        std::vector<std::string> gainList;
+        std::vector<SoapySDR::Range> gainRanges;
+        float* currentGains;
+
+        dsp::stream<dsp::complex_t> output;
+
+    private:
+        static void _worker(SoapyWrapper* _this) {
+            int blockSize = _this->_sampleRate / 200.0f;
+            dsp::complex_t* buf = new dsp::complex_t[blockSize];
+            int flags = 0;
+            long long timeMs = 0;
+            
+            while (_this->running) {
+                int res = _this->dev->readStream(_this->_stream, (void**)&buf, blockSize, flags, timeMs);
+                if (res < 1) {
+                    continue;
+                } 
+                _this->output.write(buf, res);
+            }
+            delete[] buf;
+        }
+
+        static void _logHandler(const SoapySDRLogLevel lvl, const char* message) {
+            if (lvl == SOAPY_SDR_FATAL || lvl == SOAPY_SDR_CRITICAL || lvl == SOAPY_SDR_ERROR) {
+                spdlog::error(message);
+            }
+            else if (lvl == SOAPY_SDR_WARNING) {
+                spdlog::warn(message);
+            }
+            else if (lvl == SOAPY_SDR_NOTICE | SOAPY_SDR_INFO) {
+                spdlog::info(message);
+            }
+        }
+
+        SoapySDR::Kwargs args;
+        SoapySDR::Device* dev;
+        SoapySDR::Stream* _stream;
+        std::thread _workerThread;
+        bool running = false;
+        float _sampleRate = 0;
+    };
+};

core/src/main_window.cpp

@@ -0,0 +1,874 @@
+#include <main_window.h>
+
+std::thread worker;
+std::mutex fft_mtx;
+ImGui::WaterFall wtf;
+FrequencySelect fSel;
+fftwf_complex *fft_in, *fft_out;
+fftwf_plan p;
+float* tempData;
+float* uiGains;
+char buf[1024];
+ImFont* bigFont;
+
+int fftSize = 8192 * 8;
+
+io::SoapyWrapper soapy;
+
+SignalPath sigPath;
+std::vector<float> _data;
+std::vector<float> fftTaps;
+void fftHandler(dsp::complex_t* samples) {
+    fftwf_execute(p);
+    int half = fftSize / 2;
+
+    for (int i = 0; i < half; i++) {
+        _data.push_back(log10(std::abs(std::complex<float>(fft_out[half + i][0], fft_out[half + i][1])) / (float)fftSize) * 10.0f);
+    }
+    for (int i = 0; i < half; i++) {
+        _data.push_back(log10(std::abs(std::complex<float>(fft_out[i][0], fft_out[i][1])) / (float)fftSize) * 10.0f);
+    }
+
+    for (int i = 5; i < fftSize; i++) {
+        _data[i] = (_data[i - 4]  + _data[i - 3] + _data[i - 2] + _data[i - 1] + _data[i]) / 5.0f;
+    }
+
+    wtf.pushFFT(_data, fftSize);
+    _data.clear();
+}
+
+dsp::NullSink sink;
+int devId = 0;
+int srId = 0;
+watcher<int> bandplanId(0, true);
+watcher<uint64_t> freq((uint64_t)90500000);
+int demod = 1;
+watcher<float> vfoFreq(92000000.0f);
+float dummyVolume = 1.0f;
+float* volume = &dummyVolume;
+float fftMin = -70.0f;
+float fftMax = 0.0f;
+watcher<float> offset(0.0f, true);
+watcher<float> bw(8000000.0f, true);
+int sampleRate = 8000000;
+bool playing = false;
+watcher<bool> dcbias(false, false);
+watcher<bool> bandPlanEnabled(true, false);
+bool showCredits = false;
+std::string audioStreamName = "";
+std::string sourceName = "";
+int menuWidth = 300;
+bool grabbingMenu = false;
+int newWidth = 300;
+bool showWaterfall = true;
+int fftHeight = 300;
+bool showMenu = true;
+
+void saveCurrentSource() {
+    int i = 0;
+    for (std::string gainName : soapy.gainList) {
+        config::config["sourceSettings"][sourceName]["gains"][gainName] = uiGains[i];
+        i++;
+    }
+    config::config["sourceSettings"][sourceName]["sampleRate"] = soapy.sampleRates[srId];
+}
+
+void loadSourceConfig(std::string name) {
+    json sourceSettings = config::config["sourceSettings"][name];
+
+    sampleRate = sourceSettings["sampleRate"];
+    
+    auto _srIt = std::find(soapy.sampleRates.begin(), soapy.sampleRates.end(), sampleRate);
+    // If the sample rate isn't valid, set to minimum
+    if (_srIt == soapy.sampleRates.end()) {
+        srId = 0;
+        sampleRate = soapy.sampleRates[0];
+    }
+    else {
+        srId = std::distance(soapy.sampleRates.begin(), _srIt);
+    }
+    sigPath.setSampleRate(sampleRate);
+    soapy.setSampleRate(sampleRate);
+
+    // Set gains
+    delete[] uiGains;
+    uiGains = new float[soapy.gainList.size()];
+    int i = 0;
+    for (std::string gainName : soapy.gainList) {
+        // If gain doesn't exist in config, set it to the minimum value
+        if (!sourceSettings["gains"].contains(gainName)) {
+            uiGains[i] = soapy.gainRanges[i].minimum();
+            soapy.setGain(i, uiGains[i]);
+            continue;
+        }
+        uiGains[i] = sourceSettings["gains"][gainName];
+        soapy.setGain(i, uiGains[i]);
+        i++;
+    }
+
+    // Update GUI
+    wtf.setBandwidth(sampleRate);
+    wtf.setViewBandwidth(sampleRate);
+    bw.val = sampleRate;
+}
+
+void loadAudioConfig(std::string name) {
+    json audioSettings = config::config["audio"][name];
+    std::string devName = audioSettings["device"];
+    auto _devIt = std::find(audio::streams[name]->audio->deviceNames.begin(), audio::streams[name]->audio->deviceNames.end(), devName);
+
+    // If audio device doesn't exist anymore
+    if (_devIt == audio::streams[name]->audio->deviceNames.end()) {
+        audio::streams[name]->audio->setToDefault();
+        int deviceId = audio::streams[name]->audio->getDeviceId();
+        audio::setAudioDevice(name, deviceId, audio::streams[name]->audio->devices[deviceId].sampleRates[0]);
+        audio::streams[name]->sampleRateId = 0;
+        audio::streams[name]->volume = audioSettings["volume"];
+        audio::streams[name]->audio->setVolume(audio::streams[name]->volume);
+        return;
+    }
+    int deviceId = std::distance(audio::streams[name]->audio->deviceNames.begin(), _devIt);
+    float sr = audioSettings["sampleRate"];
+    auto _srIt = std::find(audio::streams[name]->audio->devices[deviceId].sampleRates.begin(), audio::streams[name]->audio->devices[deviceId].sampleRates.end(), sr);
+
+    // If sample rate doesn't exist anymore
+    if (_srIt == audio::streams[name]->audio->devices[deviceId].sampleRates.end()) {
+        audio::streams[name]->sampleRateId = 0;
+        audio::setAudioDevice(name, deviceId, audio::streams[name]->audio->devices[deviceId].sampleRates[0]);
+        audio::streams[name]->volume = audioSettings["volume"];
+        audio::streams[name]->audio->setVolume(audio::streams[name]->volume);
+        return;
+    }
+
+    int samplerateId = std::distance(audio::streams[name]->audio->devices[deviceId].sampleRates.begin(), _srIt);
+    audio::streams[name]->sampleRateId = samplerateId;
+    audio::setAudioDevice(name, deviceId, audio::streams[name]->audio->devices[deviceId].sampleRates[samplerateId]);
+    audio::streams[name]->deviceId = deviceId;
+    audio::streams[name]->volume = audioSettings["volume"];
+    audio::streams[name]->audio->setVolume(audio::streams[name]->volume);
+}
+
+void saveAudioConfig(std::string name) {
+    config::config["audio"][name]["device"] = audio::streams[name]->audio->deviceNames[audio::streams[name]->deviceId];
+    config::config["audio"][name]["volume"] = audio::streams[name]->volume;
+    config::config["audio"][name]["sampleRate"] = audio::streams[name]->sampleRate;
+}
+
+void windowInit() {
+    spdlog::info("Initializing SoapySDR");
+    soapy.init();
+    
+    fSel.init();
+    
+    fft_in = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * fftSize);
+    fft_out = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * fftSize);
+    p = fftwf_plan_dft_1d(fftSize, fft_in, fft_out, FFTW_FORWARD, FFTW_ESTIMATE);
+
+    sigPath.init(sampleRate, 20, fftSize, &soapy.output, (dsp::complex_t*)fft_in, fftHandler);
+    sigPath.start();
+
+    vfoman::init(&wtf, &sigPath);
+
+    uiGains = new float[soapy.gainList.size()];
+
+    spdlog::info("Loading modules");
+    mod::initAPI(&wtf);
+    mod::loadFromList(config::getRootDirectory() + "/module_list.json");
+
+    bigFont = ImGui::GetIO().Fonts->AddFontFromFileTTF((config::getRootDirectory() + "/res/fonts/Roboto-Medium.ttf").c_str(), 128.0f);
+
+    // Load last source configuration
+    uint64_t frequency = config::config["frequency"];
+    sourceName = config::config["source"];
+    auto _sourceIt = std::find(soapy.devNameList.begin(), soapy.devNameList.end(), sourceName);
+    if (_sourceIt != soapy.devNameList.end() && config::config["sourceSettings"].contains(sourceName)) {
+        json sourceSettings = config::config["sourceSettings"][sourceName];
+        devId = std::distance(soapy.devNameList.begin(), _sourceIt);
+        soapy.setDevice(soapy.devList[devId]);
+        loadSourceConfig(sourceName);
+    }
+    else {
+        int i = 0;
+        bool settingsFound = false;
+        for (std::string devName : soapy.devNameList) {
+            if (config::config["sourceSettings"].contains(devName)) {
+                sourceName = devName;
+                settingsFound = true;
+                devId = i;
+                soapy.setDevice(soapy.devList[i]);
+                loadSourceConfig(sourceName);
+                break;
+            }
+            i++;
+        }
+        if (!settingsFound) {
+            if (soapy.devNameList.size() > 0) {
+                sourceName = soapy.devNameList[0];
+            }
+            sampleRate = soapy.getSampleRate();
+            sigPath.setSampleRate(sampleRate);
+        }
+        // Search for the first source in the list to have a config
+        // If no pre-defined source, selected default device
+    }
+
+    // Also add a loading screen
+    // Adjustable "snap to grid" for each VFO
+    // Finish the recorder module
+    // Add squelsh
+    // Bandwidth ajustment
+    // CW and RAW modes;
+    // Bring VFO to a visible place when changing sample rate if it's smaller
+    // Add save config for modules
+    // Do VFO in two steps: First sample rate conversion, then filtering
+
+    // And a module add/remove/change order menu
+    // get rid of watchers and use if() instead
+    // Switch to double for all frequecies and bandwidth
+
+    // Update UI settings
+    fftMin = config::config["min"];
+    fftMax = config::config["max"];
+    wtf.setFFTMin(fftMin);
+    wtf.setWaterfallMin(fftMin);
+    wtf.setFFTMax(fftMax);
+    wtf.setWaterfallMax(fftMax);
+
+    bandPlanEnabled.val = config::config["bandPlanEnabled"];
+    bandPlanEnabled.markAsChanged();
+
+    std::string bandPlanName = config::config["bandPlan"];
+    auto _bandplanIt = bandplan::bandplans.find(bandPlanName);
+    if (_bandplanIt != bandplan::bandplans.end()) {
+        bandplanId.val = std::distance(bandplan::bandplans.begin(), bandplan::bandplans.find(bandPlanName));
+        
+        if (bandPlanEnabled.val) {
+            wtf.bandplan = &bandplan::bandplans[bandPlanName];
+        }
+        else {
+            wtf.bandplan = NULL;
+        }
+    }
+    else {
+        bandplanId.val = 0;
+    }
+    bandplanId.markAsChanged();
+    
+
+    fSel.setFrequency(frequency);
+    fSel.frequencyChanged = false;
+    soapy.setFrequency(frequency);
+    wtf.setCenterFrequency(frequency);
+    wtf.setBandwidth(sampleRate);
+    wtf.setViewBandwidth(sampleRate);
+    bw.val = sampleRate;
+    wtf.vfoFreqChanged = false;
+    wtf.centerFreqMoved = false;
+    wtf.selectFirstVFO();
+
+    for (auto [name, stream] : audio::streams) {
+        if (config::config["audio"].contains(name)) {
+            bool running = audio::streams[name]->running;
+            audio::stopStream(name);
+            loadAudioConfig(name);
+            if (running) {
+                audio::startStream(name);
+            }
+        }
+    }
+
+    audioStreamName = audio::getNameFromVFO(wtf.selectedVFO);
+    if (audioStreamName != "") {
+        volume = &audio::streams[audioStreamName]->volume;
+    }
+
+    menuWidth = config::config["menuWidth"];
+    newWidth = menuWidth;
+
+    showWaterfall = config::config["showWaterfall"];
+    if (!showWaterfall) {
+        wtf.hideWaterfall();
+    }
+
+    fftHeight = config::config["fftHeight"];
+    wtf.setFFTHeight(fftHeight);
+}
+
+void setVFO(float freq) {
+    ImGui::WaterfallVFO* vfo = wtf.vfos[wtf.selectedVFO];
+
+    float currentOff =  vfo->centerOffset;
+    float currentTune = wtf.getCenterFrequency() + vfo->generalOffset;
+    float delta = freq - currentTune;
+
+    float newVFO = currentOff + delta;
+    float vfoBW = vfo->bandwidth;
+    float vfoBottom = newVFO - (vfoBW / 2.0f);
+    float vfoTop = newVFO + (vfoBW / 2.0f);
+
+    float view = wtf.getViewOffset();
+    float viewBW = wtf.getViewBandwidth();
+    float viewBottom = view - (viewBW / 2.0f);
+    float viewTop = view + (viewBW / 2.0f);
+
+    float wholeFreq = wtf.getCenterFrequency();
+    float BW = wtf.getBandwidth();
+    float bottom = -(BW / 2.0f);
+    float top = (BW / 2.0f);
+
+    // VFO still fints in the view
+    if (vfoBottom > viewBottom && vfoTop < viewTop) {
+        vfoman::setCenterOffset(wtf.selectedVFO, newVFO);
+        return;
+    }
+
+    // VFO too low for current SDR tuning
+    if (vfoBottom < bottom) {
+        wtf.setViewOffset((BW / 2.0f) - (viewBW / 2.0f));
+        float newVFOOffset = (BW / 2.0f) - (vfoBW / 2.0f) - (viewBW / 10.0f);
+        vfoman::setCenterOffset(wtf.selectedVFO, newVFOOffset);
+        wtf.setCenterFrequency(freq - newVFOOffset);
+        soapy.setFrequency(freq - newVFOOffset);
+        return;
+    }
+
+    // VFO too high for current SDR tuning
+    if (vfoTop > top) {
+        wtf.setViewOffset((viewBW / 2.0f) - (BW / 2.0f));
+        float newVFOOffset = (vfoBW / 2.0f) - (BW / 2.0f) + (viewBW / 10.0f);
+        vfoman::setCenterOffset(wtf.selectedVFO, newVFOOffset);
+        wtf.setCenterFrequency(freq - newVFOOffset);
+        soapy.setFrequency(freq - newVFOOffset);
+        return;
+    }
+
+    // VFO is still without the SDR's bandwidth
+    if (delta < 0) {
+        float newViewOff = vfoTop - (viewBW / 2.0f) + (viewBW / 10.0f);
+        float newViewBottom = newViewOff - (viewBW / 2.0f);
+        float newViewTop = newViewOff + (viewBW / 2.0f);
+
+        if (newViewBottom > bottom) {
+            wtf.setViewOffset(newViewOff);
+            vfoman::setCenterOffset(wtf.selectedVFO, newVFO);
+            return;
+        }
+
+        wtf.setViewOffset((BW / 2.0f) - (viewBW / 2.0f));
+        float newVFOOffset = (BW / 2.0f) - (vfoBW / 2.0f) - (viewBW / 10.0f);
+        vfoman::setCenterOffset(wtf.selectedVFO, newVFOOffset);
+        wtf.setCenterFrequency(freq - newVFOOffset);
+        soapy.setFrequency(freq - newVFOOffset);
+    }
+    else {
+        float newViewOff = vfoBottom + (viewBW / 2.0f) - (viewBW / 10.0f);
+        float newViewBottom = newViewOff - (viewBW / 2.0f);
+        float newViewTop = newViewOff + (viewBW / 2.0f);
+
+        if (newViewTop < top) {
+            wtf.setViewOffset(newViewOff);
+            vfoman::setCenterOffset(wtf.selectedVFO, newVFO);
+            return;
+        }
+
+        wtf.setViewOffset((viewBW / 2.0f) - (BW / 2.0f));
+        float newVFOOffset = (vfoBW / 2.0f) - (BW / 2.0f) + (viewBW / 10.0f);
+        vfoman::setCenterOffset(wtf.selectedVFO, newVFOOffset);
+        wtf.setCenterFrequency(freq - newVFOOffset);
+        soapy.setFrequency(freq - newVFOOffset);
+    }
+}
+
+void drawWindow() {
+    ImGui::Begin("Main", NULL, WINDOW_FLAGS);
+
+    ImGui::WaterfallVFO* vfo = wtf.vfos[wtf.selectedVFO];
+
+    if (vfo->centerOffsetChanged) {
+        fSel.setFrequency(wtf.getCenterFrequency() + vfo->generalOffset);
+        fSel.frequencyChanged = false;
+        config::config["frequency"] = fSel.frequency;
+        config::configModified = true;
+    }
+
+    vfoman::updateFromWaterfall();
+
+    if (wtf.selectedVFOChanged) {
+        wtf.selectedVFOChanged = false;
+        fSel.setFrequency(vfo->generalOffset + wtf.getCenterFrequency());
+        fSel.frequencyChanged = false;
+        mod::broadcastEvent(mod::EVENT_SELECTED_VFO_CHANGED);
+        audioStreamName = audio::getNameFromVFO(wtf.selectedVFO);
+        if (audioStreamName != "") {
+            volume = &audio::streams[audioStreamName]->volume;
+        }
+        config::config["frequency"] = fSel.frequency;
+        config::configModified = true;
+    }
+
+    if (fSel.frequencyChanged) {
+        fSel.frequencyChanged = false;
+        setVFO(fSel.frequency);
+        vfo->centerOffsetChanged = false;
+        vfo->lowerOffsetChanged = false;
+        vfo->upperOffsetChanged = false;
+        config::config["frequency"] = fSel.frequency;
+        config::configModified = true;
+    }
+
+    if (wtf.centerFreqMoved) {
+        wtf.centerFreqMoved = false;
+        soapy.setFrequency(wtf.getCenterFrequency());
+        fSel.setFrequency(wtf.getCenterFrequency() + vfo->generalOffset);
+        config::config["frequency"] = fSel.frequency;
+        config::configModified = true;
+    }
+
+    if (dcbias.changed()) {
+        sigPath.setDCBiasCorrection(dcbias.val);
+    }
+
+    if (bandplanId.changed() && bandPlanEnabled.val) {
+        wtf.bandplan = &bandplan::bandplans[bandplan::bandplanNames[bandplanId.val]];
+    }
+
+    if (bandPlanEnabled.changed()) {
+        wtf.bandplan = bandPlanEnabled.val ? &bandplan::bandplans[bandplan::bandplanNames[bandplanId.val]] : NULL;
+    }
+
+    int _fftHeight = wtf.getFFTHeight();
+    if (fftHeight != _fftHeight) {
+        fftHeight = _fftHeight;
+        config::config["fftHeight"] = fftHeight;
+        config::configModified = true;
+    }
+
+    ImVec2 vMin = ImGui::GetWindowContentRegionMin();
+    ImVec2 vMax = ImGui::GetWindowContentRegionMax();
+
+    int width = vMax.x - vMin.x;
+    int height = vMax.y - vMin.y;
+
+    int modCount = mod::moduleNames.size();
+    mod::Module_t mod;
+    for (int i = 0; i < modCount; i++) {
+        mod = mod::modules[mod::moduleNames[i]];
+        mod._NEW_FRAME_(mod.ctx);
+    }
+
+    // To Bar
+    if (ImGui::ImageButton(icons::MENU, ImVec2(40, 40), ImVec2(0, 0), ImVec2(1, 1), 0)) {
+        showMenu = !showMenu;
+    }
+
+    ImGui::SameLine();
+
+    if (playing) {
+        if (ImGui::ImageButton(icons::STOP, ImVec2(40, 40), ImVec2(0, 0), ImVec2(1, 1), 0)) {
+            soapy.stop();
+            playing = false;
+        }
+    }
+    else {
+        if (ImGui::ImageButton(icons::PLAY, ImVec2(40, 40), ImVec2(0, 0), ImVec2(1, 1), 0) && soapy.devList.size() > 0) {
+            soapy.start();
+            soapy.setFrequency(wtf.getCenterFrequency());
+            playing = true;
+        }
+    }
+
+    ImGui::SameLine();
+
+    ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 8);
+    ImGui::SetNextItemWidth(200);
+    if (ImGui::SliderFloat("##_2_", volume, 0.0f, 1.0f, "")) {
+        if (audioStreamName != "") {
+            if (!config::config["audio"].contains(audioStreamName)) {
+                saveAudioConfig(audioStreamName);
+            }
+            audio::streams[audioStreamName]->audio->setVolume(*volume);
+            config::config["audio"][audioStreamName]["volume"] = *volume;
+            config::configModified = true;
+        }
+    }
+
+    ImGui::SameLine();
+
+    fSel.draw();
+
+    ImGui::SameLine();
+
+    // Logo button
+    ImGui::SetCursorPosX(ImGui::GetWindowSize().x - 48);
+    ImGui::SetCursorPosY(10);
+    if (ImGui::ImageButton(icons::LOGO, ImVec2(32, 32), ImVec2(0, 0), ImVec2(1, 1), 0)) {
+        showCredits = true;
+    }
+    if (ImGui::IsMouseDown(ImGuiMouseButton_Left)) {
+        showCredits = false;
+    }
+    if (ImGui::IsKeyPressed(GLFW_KEY_ESCAPE)) {
+        showCredits = false;
+    }
+
+    // Handle menu resize
+    float curY = ImGui::GetCursorPosY();
+    ImVec2 winSize = ImGui::GetWindowSize();
+    ImVec2 mousePos = ImGui::GetMousePos();
+    bool click = ImGui::IsMouseClicked(ImGuiMouseButton_Left);
+    bool down = ImGui::IsMouseDown(ImGuiMouseButton_Left);
+    if (grabbingMenu) {
+        newWidth = mousePos.x;
+        newWidth = std::clamp<float>(newWidth, 250, winSize.x - 250);
+        ImGui::GetForegroundDrawList()->AddLine(ImVec2(newWidth, curY), ImVec2(newWidth, winSize.y - 10), ImGui::GetColorU32(ImGuiCol_SeparatorActive));
+    }
+    if (mousePos.x >= newWidth - 2 && mousePos.x <= newWidth + 2 && mousePos.y > curY) {
+        ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
+        if (click) {
+            grabbingMenu = true;
+        }
+    }
+    else {
+        ImGui::SetMouseCursor(ImGuiMouseCursor_Arrow);
+    }
+    if(!down && grabbingMenu) {
+        grabbingMenu = false;
+        menuWidth = newWidth;
+        config::config["menuWidth"] = menuWidth;
+        config::configModified = true;
+    }
+
+    // Left Column
+
+    if (showMenu) {
+        ImGui::Columns(3, "WindowColumns", false);
+        ImGui::SetColumnWidth(0, menuWidth);
+        ImGui::SetColumnWidth(1, winSize.x - menuWidth - 60);
+        ImGui::SetColumnWidth(2, 60);
+        ImGui::BeginChild("Left Column");
+        float menuColumnWidth = ImGui::GetContentRegionAvailWidth();
+
+        if (ImGui::CollapsingHeader("Source", ImGuiTreeNodeFlags_DefaultOpen)) {
+            if (playing) { style::beginDisabled(); };
+
+            ImGui::PushItemWidth(menuColumnWidth);
+            if (ImGui::Combo("##_0_", &devId, soapy.txtDevList.c_str())) {
+                spdlog::info("Changed input device: {0}", devId);
+                sourceName = soapy.devNameList[devId];
+                soapy.setDevice(soapy.devList[devId]);
+
+                if (config::config["sourceSettings"].contains(sourceName)) {
+                    loadSourceConfig(sourceName);
+                }
+                else {
+                    srId = 0;
+                    sampleRate = soapy.getSampleRate();
+                    bw.val = sampleRate;
+                    wtf.setBandwidth(sampleRate);
+                    wtf.setViewBandwidth(sampleRate);
+                    sigPath.setSampleRate(sampleRate);
+
+                    if (soapy.gainList.size() >= 0) {
+                        delete[] uiGains;
+                        uiGains = new float[soapy.gainList.size()];
+                        for (int i = 0; i < soapy.gainList.size(); i++) {
+                            uiGains[i] = soapy.currentGains[i];
+                        }
+                    }
+                }
+                setVFO(fSel.frequency);
+                config::config["source"] = sourceName;
+                config::configModified = true;
+            }
+            ImGui::PopItemWidth();
+
+            if (ImGui::Combo("##_1_", &srId, soapy.txtSampleRateList.c_str())) {
+                spdlog::info("Changed sample rate: {0}", srId);
+                sampleRate = soapy.sampleRates[srId];
+                soapy.setSampleRate(sampleRate);
+                wtf.setBandwidth(sampleRate);
+                wtf.setViewBandwidth(sampleRate);
+                sigPath.setSampleRate(sampleRate);
+                bw.val = sampleRate;
+
+                if (!config::config["sourceSettings"].contains(sourceName)) {
+                    saveCurrentSource();
+                }
+                config::config["sourceSettings"][sourceName]["sampleRate"] = sampleRate;
+                config::configModified = true;
+            }
+
+            ImGui::SameLine();
+            bool noDevice = (soapy.devList.size() == 0);
+            if (ImGui::Button("Refresh", ImVec2(menuColumnWidth - ImGui::GetCursorPosX(), 0.0f))) {
+                soapy.refresh();
+                if (noDevice && soapy.devList.size() > 0) {
+                    sourceName = soapy.devNameList[0];
+                    soapy.setDevice(soapy.devList[0]);
+                    if (config::config["sourceSettings"][sourceName]) {
+                        loadSourceConfig(sourceName);
+                    }
+                }
+            }
+
+            if (playing) { style::endDisabled(); };
+
+            float maxTextLength = 0;
+            float txtLen = 0;
+            char buf[100];
+
+            // Calculate the spacing
+            for (int i = 0; i < soapy.gainList.size(); i++) {
+                sprintf(buf, "%s gain", soapy.gainList[i].c_str());
+                txtLen = ImGui::CalcTextSize(buf).x;
+                if (txtLen > maxTextLength) {
+                    maxTextLength = txtLen;
+                }
+            }
+
+            for (int i = 0; i < soapy.gainList.size(); i++) {
+                ImGui::Text("%s gain", soapy.gainList[i].c_str());
+                ImGui::SameLine();
+                sprintf(buf, "##_gain_slide_%d_", i);
+
+                ImGui::SetCursorPosX(maxTextLength + 5);
+                ImGui::PushItemWidth(menuColumnWidth - (maxTextLength + 5));
+                if (ImGui::SliderFloat(buf, &uiGains[i], soapy.gainRanges[i].minimum(), soapy.gainRanges[i].maximum())) {
+                    soapy.setGain(i, uiGains[i]);
+                    if (!config::config["sourceSettings"].contains(sourceName)) {
+                        saveCurrentSource();
+                    }
+                    config::config["sourceSettings"][sourceName]["gains"][soapy.gainList[i]] = uiGains[i];
+                    config::configModified = true;
+                }
+                ImGui::PopItemWidth();
+            }
+
+            ImGui::Spacing();
+        }
+
+        for (int i = 0; i < modCount; i++) {
+            if (ImGui::CollapsingHeader(mod::moduleNames[i].c_str(), ImGuiTreeNodeFlags_DefaultOpen)) {
+                mod = mod::modules[mod::moduleNames[i]];
+                mod._DRAW_MENU_(mod.ctx);
+                ImGui::Spacing();
+            }
+        }
+
+
+        if (ImGui::CollapsingHeader("Audio", ImGuiTreeNodeFlags_DefaultOpen)) {
+            int count = 0;
+            int maxCount = audio::streams.size();
+            for (auto const& [name, stream] : audio::streams) {
+                int deviceId;
+                float vol = 1.0f;
+                deviceId = stream->audio->getDeviceId();
+
+                ImGui::SetCursorPosX((menuColumnWidth / 2.0f) - (ImGui::CalcTextSize(name.c_str()).x / 2.0f));
+                ImGui::Text(name.c_str());
+
+                ImGui::PushItemWidth(menuColumnWidth);
+                bool running = stream->running;
+                if (ImGui::Combo(("##_audio_dev_0_"+ name).c_str(), &stream->deviceId, stream->audio->devTxtList.c_str())) {
+                    audio::stopStream(name);
+                    audio::setAudioDevice(name, stream->deviceId, stream->audio->devices[deviceId].sampleRates[0]);
+                    if (running) {
+                        audio::startStream(name);
+                    }
+                    stream->sampleRateId = 0;
+
+                    // Create config if it doesn't exist
+                    if (!config::config["audio"].contains(name)) {
+                        saveAudioConfig(name);
+                    }
+                    config::config["audio"][name]["device"] = stream->audio->deviceNames[stream->deviceId];
+                    config::config["audio"][name]["sampleRate"] = stream->audio->devices[stream->deviceId].sampleRates[0];
+                    config::configModified = true;
+                }
+                if (ImGui::Combo(("##_audio_sr_0_" + name).c_str(), &stream->sampleRateId, stream->audio->devices[deviceId].txtSampleRates.c_str())) {
+                    audio::stopStream(name);
+                    audio::setSampleRate(name, stream->audio->devices[deviceId].sampleRates[stream->sampleRateId]);
+                    if (running) {
+                        audio::startStream(name);
+                    }
+
+                    // Create config if it doesn't exist
+                    if (!config::config["audio"].contains(name)) {
+                        saveAudioConfig(name);
+                    }
+                    config::config["audio"][name]["sampleRate"] = stream->audio->devices[deviceId].sampleRates[stream->sampleRateId];
+                    config::configModified = true;
+                }
+                if (ImGui::SliderFloat(("##_audio_vol_0_" + name).c_str(), &stream->volume, 0.0f, 1.0f, "")) {
+                    stream->audio->setVolume(stream->volume);
+
+                    // Create config if it doesn't exist
+                    if (!config::config["audio"].contains(name)) {
+                        saveAudioConfig(name);
+                    }
+                    config::config["audio"][name]["volume"] = stream->volume;
+                    config::configModified = true;
+                }
+                ImGui::PopItemWidth();
+                count++;
+                if (count < maxCount) {
+                    ImGui::Spacing();
+                    ImGui::Separator();
+                }
+                ImGui::Spacing();
+            }
+            ImGui::Spacing();
+        }
+
+        if (ImGui::CollapsingHeader("Band Plan", ImGuiTreeNodeFlags_DefaultOpen)) {
+            ImGui::PushItemWidth(menuColumnWidth);
+            if (ImGui::Combo("##_4_", &bandplanId.val, bandplan::bandplanNameTxt.c_str())) {
+                config::config["bandPlan"] = bandplan::bandplanNames[bandplanId.val];
+                config::configModified = true;
+            }
+            ImGui::PopItemWidth();
+            if (ImGui::Checkbox("Enabled", &bandPlanEnabled.val)) {
+                config::config["bandPlanEnabled"] = bandPlanEnabled.val;
+                config::configModified = true;
+            }
+            bandplan::BandPlan_t plan = bandplan::bandplans[bandplan::bandplanNames[bandplanId.val]];
+            ImGui::Text("Country: %s (%s)", plan.countryName.c_str(), plan.countryCode.c_str());
+            ImGui::Text("Author: %s", plan.authorName.c_str());
+            ImGui::Spacing();
+        } 
+
+        if (ImGui::CollapsingHeader("Display", ImGuiTreeNodeFlags_DefaultOpen)) {
+            if (ImGui::Checkbox("Show waterfall", &showWaterfall)) {
+                showWaterfall ? wtf.showWaterfall() : wtf.hideWaterfall();
+            }
+            ImGui::Spacing();
+        }
+
+        if(ImGui::CollapsingHeader("Debug")) {
+            ImGui::Text("Frame time: %.3f ms/frame", 1000.0f / ImGui::GetIO().Framerate);
+            ImGui::Text("Framerate: %.1f FPS", ImGui::GetIO().Framerate);
+            ImGui::Text("Center Frequency: %.0f Hz", wtf.getCenterFrequency());
+            ImGui::Text("Source name: %s", sourceName.c_str());
+            ImGui::Spacing();
+        }
+
+        ImGui::EndChild();
+    }
+    else {
+        // When hiding the menu bar
+        ImGui::Columns(3, "WindowColumns", false);
+        ImGui::SetColumnWidth(0, 8);
+        ImGui::SetColumnWidth(1, winSize.x - 8 - 60);
+        ImGui::SetColumnWidth(2, 60);
+    }
+
+    // Right Column
+    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
+    ImGui::NextColumn();
+    ImGui::PopStyleVar();
+
+    ImGui::BeginChild("Waterfall");
+
+    wtf.draw();    
+
+    ImGui::EndChild();
+
+    
+    ImGui::NextColumn();
+    ImGui::BeginChild("WaterfallControls");
+
+    ImGui::SetCursorPosX((ImGui::GetWindowSize().x / 2.0f) - (ImGui::CalcTextSize("Zoom").x / 2.0f));
+    ImGui::Text("Zoom");
+    ImGui::SetCursorPosX((ImGui::GetWindowSize().x / 2.0f) - 10);
+    ImGui::VSliderFloat("##_7_", ImVec2(20.0f, 150.0f), &bw.val, sampleRate, 1000.0f, "");
+
+    ImGui::NewLine();
+
+    ImGui::SetCursorPosX((ImGui::GetWindowSize().x / 2.0f) - (ImGui::CalcTextSize("Max").x / 2.0f));
+    ImGui::Text("Max");
+    ImGui::SetCursorPosX((ImGui::GetWindowSize().x / 2.0f) - 10);
+    if (ImGui::VSliderFloat("##_8_", ImVec2(20.0f, 150.0f), &fftMax, 0.0f, -100.0f, "")) {
+        fftMax = std::max<float>(fftMax, fftMin + 10);
+        config::config["max"] = fftMax;
+        config::configModified = true;
+    }
+
+    ImGui::NewLine();
+
+    ImGui::SetCursorPosX((ImGui::GetWindowSize().x / 2.0f) - (ImGui::CalcTextSize("Min").x / 2.0f));
+    ImGui::Text("Min");
+    ImGui::SetCursorPosX((ImGui::GetWindowSize().x / 2.0f) - 10);
+    if (ImGui::VSliderFloat("##_9_", ImVec2(20.0f, 150.0f), &fftMin, 0.0f, -100.0f, "")) {
+        fftMin = std::min<float>(fftMax - 10, fftMin);
+        config::config["min"] = fftMin;
+        config::configModified = true;
+    }
+
+    ImGui::EndChild();
+
+    if (bw.changed()) {
+        wtf.setViewBandwidth(bw.val);
+        wtf.setViewOffset(vfo->centerOffset);
+    }
+
+    wtf.setFFTMin(fftMin);
+    wtf.setFFTMax(fftMax);
+    wtf.setWaterfallMin(fftMin);
+    wtf.setWaterfallMax(fftMax);
+
+
+    ImGui::End();
+
+    if (showCredits) {
+        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(20.0f, 20.0f));
+        ImGui::OpenPopup("Credits");
+        ImGui::BeginPopupModal("Credits", NULL, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove);
+
+        ImGui::PushFont(bigFont);
+        ImGui::Text("SDR++    ");
+        ImGui::PopFont();
+        ImGui::SameLine();
+        ImGui::Image(icons::LOGO, ImVec2(128, 128));
+        ImGui::Spacing();
+        ImGui::Spacing();
+        ImGui::Spacing();
+
+        ImGui::Text("This software is brought to you by\n\n");
+
+        ImGui::Columns(3, "CreditColumns", true);
+
+        // Contributors
+        ImGui::Text("Contributors");
+        ImGui::BulletText("Ryzerth (Creator)");
+        ImGui::BulletText("aosync");
+        ImGui::BulletText("Benjamin Kyd");
+        ImGui::BulletText("Tobias Mädel");
+        ImGui::BulletText("Raov");
+        ImGui::BulletText("Howard0su");
+
+        // Libraries
+        ImGui::NextColumn();
+        ImGui::Text("Libraries");
+        ImGui::BulletText("SoapySDR (PothosWare)");
+        ImGui::BulletText("Dear ImGui (ocornut)");
+        ImGui::BulletText("spdlog (gabime)");
+        ImGui::BulletText("json (nlohmann)");
+        ImGui::BulletText("portaudio (PA Comm.)");
+
+        // Patrons
+        ImGui::NextColumn();
+        ImGui::Text("Patrons");
+        ImGui::BulletText("SignalsEverywhere");
+
+        ImGui::EndPopup();
+        ImGui::PopStyleVar(1);
+    }
+}
+
+void bindVolumeVariable(float* vol) {
+    volume = vol;
+}
+
+void unbindVolumeVariable() {
+    volume = &dummyVolume;
+}

core/src/main_window.h

@@ -0,0 +1,35 @@
+#pragma once
+#include "imgui.h"
+#include "imgui_impl_glfw.h"
+#include "imgui_impl_opengl3.h"
+#include <stdio.h>
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include <imgui_plot.h>
+#include <dsp/resampling.h>
+#include <dsp/demodulator.h>
+#include <dsp/filter.h>
+#include <thread>
+#include <complex>
+#include <dsp/source.h>
+#include <dsp/math.h>
+#include <waterfall.h>
+#include <frequency_select.h>
+#include <fftw3.h>
+#include <signal_path.h>
+#include <io/soapy.h>
+#include <icons.h>
+#include <bandplan.h>
+#include <watcher.h>
+#include <module.h>
+#include <vfo_manager.h>
+#include <audio.h>
+#include <style.h>
+#include <config.h>
+
+#define WINDOW_FLAGS    ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoBackground
+
+void windowInit();
+void drawWindow();
+void bindVolumeVariable(float* vol);
+void unbindVolumeVariable();

core/src/module.cpp

@@ -0,0 +1,139 @@
+#include <module.h>
+#include <vfo_manager.h>
+#include <main_window.h>
+#include <audio.h>
+
+namespace mod {
+    API_t API;
+    std::map<std::string, Module_t> modules;
+    std::vector<std::string> moduleNames;
+    ImGui::WaterFall* _wtf;
+
+    std::string api_getSelectedVFOName() {
+        return _wtf->selectedVFO;
+    }
+
+    void initAPI(ImGui::WaterFall* wtf) {
+        _wtf = wtf;
+
+        // VFO Manager
+        API.registerVFO = vfoman::create;
+        API.setVFOOffset = vfoman::setOffset;
+        API.setVFOCenterOffset = vfoman::setCenterOffset;
+        API.setVFOBandwidth = vfoman::setBandwidth;
+        API.setVFOSampleRate = vfoman::setSampleRate;
+        API.getVFOOutputBlockSize = vfoman::getOutputBlockSize;
+        API.setVFOReference = vfoman::setReference;
+        API.removeVFO = vfoman::remove;
+
+        // GUI
+        API.getSelectedVFOName = api_getSelectedVFOName;
+        API.bindVolumeVariable = bindVolumeVariable;
+        API.unbindVolumeVariable = unbindVolumeVariable;
+
+        // Audio
+        API.registerMonoStream = audio::registerMonoStream;
+        API.registerStereoStream = audio::registerStereoStream;
+        API.startStream = audio::startStream;
+        API.stopStream = audio::stopStream;
+        API.removeStream = audio::removeStream;
+        API.bindToStreamMono = audio::bindToStreamMono;
+        API.bindToStreamStereo = audio::bindToStreamStereo;
+        API.setBlockSize = audio::setBlockSize;
+        API.unbindFromStreamMono = audio::unbindFromStreamMono;
+        API.unbindFromStreamStereo = audio::unbindFromStreamStereo;
+        API.getStreamNameList = audio::getStreamNameList;
+    }
+
+    void loadModule(std::string path, std::string name) {
+        if (!std::filesystem::exists(path)) {
+            spdlog::error("{0} does not exist", path);
+            return;
+        }
+        if (!std::filesystem::is_regular_file(path)) {
+            spdlog::error("{0} isn't a loadable module", path);
+            return;
+        }
+        Module_t mod;
+#ifdef _WIN32
+        mod.inst = LoadLibraryA(path.c_str());
+        if (mod.inst == NULL) {
+            spdlog::error("Couldn't load {0}.", name);
+            return;
+        }
+        mod._INIT_ = (void*(*)(mod::API_t*,ImGuiContext*,std::string))GetProcAddress(mod.inst, "_INIT_");
+        mod._NEW_FRAME_ = (void(*)(void*))GetProcAddress(mod.inst, "_NEW_FRAME_");
+        mod._DRAW_MENU_ = (void(*)(void*))GetProcAddress(mod.inst, "_DRAW_MENU_");
+        mod._HANDLE_EVENT_ = (void(*)(void*, int))GetProcAddress(mod.inst, "_HANDLE_EVENT_");
+        mod._STOP_ = (void(*)(void*))GetProcAddress(mod.inst, "_STOP_");
+#else
+        mod.inst = dlopen(path.c_str(), RTLD_LAZY);
+        if (mod.inst == NULL) {
+            spdlog::error("Couldn't load {0}.", name);
+            return;
+        }
+        mod._INIT_ = (void*(*)(mod::API_t*,ImGuiContext*,std::string))dlsym(mod.inst, "_INIT_");
+        mod._NEW_FRAME_ = (void(*)(void*))dlsym(mod.inst, "_NEW_FRAME_");
+        mod._DRAW_MENU_ = (void(*)(void*))dlsym(mod.inst, "_DRAW_MENU_");
+        mod._HANDLE_EVENT_ = (void(*)(void*, int))dlsym(mod.inst, "_HANDLE_EVENT_");
+        mod._STOP_ = (void(*)(void*))dlsym(mod.inst, "_STOP_");
+#endif
+        if (mod._INIT_ == NULL) {
+            spdlog::error("Couldn't load {0} because it's missing _INIT_.", name);
+            return;
+        }
+        if (mod._NEW_FRAME_ == NULL) {
+            spdlog::error("Couldn't load {0} because it's missing _NEW_FRAME_.", name);
+            return;
+        }
+        if (mod._DRAW_MENU_ == NULL) {
+            spdlog::error("Couldn't load {0} because it's missing _DRAW_MENU_.", name);
+            return;
+        }
+        if (mod._HANDLE_EVENT_ == NULL) {
+            spdlog::error("Couldn't load {0} because it's missing _HANDLE_EVENT_.", name);
+            return;
+        }
+        if (mod._STOP_ == NULL) {
+            spdlog::error("Couldn't load {0} because it's missing _STOP_.", name);
+            return;
+        }
+        mod.ctx = mod._INIT_(&API, ImGui::GetCurrentContext(), name);
+        if (mod.ctx == NULL) {
+            spdlog::error("{0} Failed to initialize.", name);
+        }
+        modules[name] = mod;
+        moduleNames.push_back(name);
+    }
+
+    void broadcastEvent(int eventId) {
+        if (eventId < 0 || eventId >= _EVENT_COUNT) {
+            return;
+        }
+        for (auto const& [name, mod] : modules) {
+            mod._HANDLE_EVENT_(mod.ctx, eventId);
+        }
+    }
+
+    void loadFromList(std::string path) {
+        if (!std::filesystem::exists(path)) {
+            spdlog::error("Module list file does not exist");
+            return;
+        }
+        if (!std::filesystem::is_regular_file(path)) {
+            spdlog::error("Module list file isn't a file...");
+            return;
+        }
+        std::ifstream file(path.c_str());
+        json data;
+        data << file;
+        file.close();
+
+        std::map<std::string, std::string> list = data.get<std::map<std::string, std::string>>();
+        for (auto const& [name, file] : list) {
+            spdlog::info("Loading {0} ({1})", name, file);
+            loadModule(file, name);
+        }
+    }
+};
+

core/src/module.h

@@ -0,0 +1,86 @@
+#pragma once
+#include <string>
+#include <map>
+#include <filesystem>
+#include <stdint.h>
+#include <imgui.h>
+#include <spdlog/spdlog.h>
+#include <dsp/types.h>
+#include <dsp/stream.h>
+#include <waterfall.h>
+#include <json.hpp>
+
+#ifdef _WIN32
+#include <Windows.h>
+#define MOD_EXPORT  extern "C" \
+                    __declspec(dllexport)
+#else
+#include <dlfcn.h>
+#define MOD_EXPORT  extern "C"
+#endif
+
+namespace mod {
+    struct API_t {
+        dsp::stream<dsp::complex_t>* (*registerVFO)(std::string name, int reference, float offset, float bandwidth, float sampleRate, int blockSize);
+        void (*setVFOOffset)(std::string name, float offset);
+        void (*setVFOCenterOffset)(std::string name, float offset);
+        void (*setVFOBandwidth)(std::string name, float bandwidth);
+        void (*setVFOSampleRate)(std::string name, float sampleRate, float bandwidth);
+        int (*getVFOOutputBlockSize)(std::string name);
+        void (*setVFOReference)(std::string name, int ref);
+        void (*removeVFO)(std::string name);
+        
+        std::string (*getSelectedVFOName)(void);
+        void (*bindVolumeVariable)(float* vol);
+        void (*unbindVolumeVariable)(void);
+
+        float (*registerMonoStream)(dsp::stream<float>* stream, std::string name, std::string vfoName, int (*sampleRateChangeHandler)(void* ctx, float sampleRate), void* ctx);
+        float (*registerStereoStream)(dsp::stream<dsp::StereoFloat_t>* stream, std::string name, std::string vfoName, int (*sampleRateChangeHandler)(void* ctx, float sampleRate), void* ctx);
+        void (*startStream)(std::string name);
+        void (*stopStream)(std::string name);
+        void (*removeStream)(std::string name);
+        dsp::stream<float>* (*bindToStreamMono)(std::string name, void (*streamRemovedHandler)(void* ctx), void (*sampleRateChangeHandler)(void* ctx, float sampleRate, int blockSize), void* ctx);
+        dsp::stream<dsp::StereoFloat_t>* (*bindToStreamStereo)(std::string name, void (*streamRemovedHandler)(void* ctx), void (*sampleRateChangeHandler)(void* ctx, float sampleRate, int blockSize), void* ctx);
+        void (*setBlockSize)(std::string name, int blockSize);
+        void (*unbindFromStreamMono)(std::string name, dsp::stream<float>* stream);
+        void (*unbindFromStreamStereo)(std::string name, dsp::stream<dsp::StereoFloat_t>* stream);
+        std::vector<std::string> (*getStreamNameList)(void);
+
+        enum {
+            REF_LOWER,
+            REF_CENTER,
+            REF_UPPER,
+            _REF_COUNT
+        };
+    };
+
+    enum {
+        EVENT_STREAM_PARAM_CHANGED,
+        EVENT_SELECTED_VFO_CHANGED,
+        _EVENT_COUNT
+    };
+
+    struct Module_t {
+#ifdef _WIN32
+        HINSTANCE inst;
+#else
+        void* inst;
+#endif
+        void* (*_INIT_)(API_t*, ImGuiContext*, std::string);
+        void (*_DRAW_MENU_)(void*);
+        void (*_NEW_FRAME_)(void*);
+        void (*_HANDLE_EVENT_)(void*, int);
+        void (*_STOP_)(void*);
+        void* ctx;
+    };
+
+    void initAPI(ImGui::WaterFall* wtf);
+    void loadModule(std::string path, std::string name);
+    void broadcastEvent(int eventId);
+    void loadFromList(std::string path);
+    
+    extern std::map<std::string, Module_t> modules;
+    extern std::vector<std::string> moduleNames;
+};
+
+extern mod::API_t* API;

core/src/signal_path.cpp

@@ -0,0 +1,99 @@
+#include <signal_path.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*)) {
+    this->sampleRate = sampleRate;
+    this->fftRate = fftRate;
+    this->fftSize = fftSize;
+    inputBlockSize = sampleRate / 200.0f;
+
+    dcBiasRemover.init(input, 32000);
+    dcBiasRemover.bypass = true;
+    split.init(&dcBiasRemover.output, 32000);
+
+    fftBlockDec.init(&split.output_a, (sampleRate / fftRate) - fftSize, fftSize);
+    fftHandlerSink.init(&fftBlockDec.output, fftBuffer, fftSize, fftHandler);
+
+    dynSplit.init(&split.output_b, 32000);
+}
+
+void SignalPath::setSampleRate(float sampleRate) {
+    this->sampleRate = sampleRate;
+    inputBlockSize = sampleRate / 200.0f;
+
+    dcBiasRemover.stop();
+    split.stop();
+    fftBlockDec.stop();
+    fftHandlerSink.stop();
+    dynSplit.stop();
+
+    for (auto const& [name, vfo] : vfos) {
+        vfo.vfo->stop();
+    }
+
+    dcBiasRemover.setBlockSize(inputBlockSize);
+    split.setBlockSize(inputBlockSize);
+    int skip = (sampleRate / fftRate) - fftSize;
+    fftBlockDec.setSkip(skip);
+    dynSplit.setBlockSize(inputBlockSize);
+
+    mod::broadcastEvent(mod::EVENT_STREAM_PARAM_CHANGED);
+
+    for (auto const& [name, vfo] : vfos) {
+        vfo.vfo->setInputSampleRate(sampleRate, inputBlockSize);
+        vfo.vfo->start();
+    }
+
+    fftHandlerSink.start();
+    fftBlockDec.start();
+    split.start();
+    dcBiasRemover.start();
+    dynSplit.start();
+}
+
+void SignalPath::start() {
+    dcBiasRemover.start();
+    split.start();
+
+    fftBlockDec.start();
+    fftHandlerSink.start();
+
+    dynSplit.start();
+}
+
+void SignalPath::setDCBiasCorrection(bool enabled) {
+    dcBiasRemover.bypass = !enabled;
+}
+
+dsp::VFO* SignalPath::addVFO(std::string name, float outSampleRate, float bandwidth, float offset) {
+    if (vfos.find(name) != vfos.end()) {
+        return NULL;
+    }
+    dynSplit.stop();
+    VFO_t vfo;
+    vfo.inputStream = new dsp::stream<dsp::complex_t>(inputBlockSize * 2);
+    dynSplit.bind(vfo.inputStream);
+    vfo.vfo = new dsp::VFO();
+    vfo.vfo->init(vfo.inputStream, sampleRate, outSampleRate, bandwidth, offset, inputBlockSize);
+    vfo.vfo->start();
+    vfos[name] = vfo;
+    dynSplit.start();
+    return vfo.vfo;
+}
+
+void SignalPath::removeVFO(std::string name) {
+    if (vfos.find(name) == vfos.end()) {
+        return;
+    }
+    dynSplit.stop();
+    VFO_t vfo = vfos[name];
+    vfo.vfo->stop();
+    dynSplit.unbind(vfo.inputStream);
+    delete vfo.vfo;
+    delete vfo.inputStream;
+    dynSplit.start();
+    vfos.erase(name);
+}

core/src/signal_path.h

@@ -0,0 +1,47 @@
+#pragma once
+#include <dsp/filter.h>
+#include <dsp/resampling.h>
+#include <dsp/source.h>
+#include <dsp/math.h>
+#include <dsp/demodulator.h>
+#include <dsp/routing.h>
+#include <dsp/sink.h>
+#include <dsp/correction.h>
+#include <dsp/vfo.h>
+#include <io/audio.h>
+#include <map>
+#include <module.h>
+
+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*));
+    void start();
+    void setSampleRate(float sampleRate);
+    void setDCBiasCorrection(bool enabled);
+    void setFFTRate(float rate);
+    dsp::VFO* addVFO(std::string name, float outSampleRate, float bandwidth, float offset);
+    void removeVFO(std::string name);
+
+private:
+    struct VFO_t {
+        dsp::stream<dsp::complex_t>* inputStream;
+        dsp::VFO* vfo;
+    };
+
+    dsp::DCBiasRemover dcBiasRemover;
+    dsp::Splitter split;
+
+    // FFT
+    dsp::BlockDecimator fftBlockDec;
+    dsp::HandlerSink fftHandlerSink;
+
+    // VFO
+    dsp::DynamicSplitter<dsp::complex_t> dynSplit;
+    std::map<std::string, VFO_t> vfos;
+
+    float sampleRate;
+    float fftRate;
+    int fftSize;
+    int inputBlockSize;
+};

core/src/spdlog/async.h

@@ -0,0 +1,93 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+//
+// Async logging using global thread pool
+// All loggers created here share same global thread pool.
+// Each log message is pushed to a queue along with a shared pointer to the
+// logger.
+// If a logger deleted while having pending messages in the queue, it's actual
+// destruction will defer
+// until all its messages are processed by the thread pool.
+// This is because each message in the queue holds a shared_ptr to the
+// originating logger.
+
+#include <spdlog/async_logger.h>
+#include <spdlog/details/registry.h>
+#include <spdlog/details/thread_pool.h>
+
+#include <memory>
+#include <mutex>
+#include <functional>
+
+namespace spdlog {
+
+namespace details {
+static const size_t default_async_q_size = 8192;
+}
+
+// async logger factory - creates async loggers backed with thread pool.
+// if a global thread pool doesn't already exist, create it with default queue
+// size of 8192 items and single thread.
+template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>
+struct async_factory_impl
+{
+    template<typename Sink, typename... SinkArgs>
+    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args)
+    {
+        auto &registry_inst = details::registry::instance();
+
+        // create global thread pool if not already exists..
+
+        auto &mutex = registry_inst.tp_mutex();
+        std::lock_guard<std::recursive_mutex> tp_lock(mutex);
+        auto tp = registry_inst.get_tp();
+        if (tp == nullptr)
+        {
+            tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1);
+            registry_inst.set_tp(tp);
+        }
+
+        auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
+        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
+        registry_inst.initialize_logger(new_logger);
+        return new_logger;
+    }
+};
+
+using async_factory = async_factory_impl<async_overflow_policy::block>;
+using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
+
+template<typename Sink, typename... SinkArgs>
+inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args)
+{
+    return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+}
+
+template<typename Sink, typename... SinkArgs>
+inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args)
+{
+    return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+}
+
+// set global thread pool.
+inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start)
+{
+    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start);
+    details::registry::instance().set_tp(std::move(tp));
+}
+
+// set global thread pool.
+inline void init_thread_pool(size_t q_size, size_t thread_count)
+{
+    init_thread_pool(q_size, thread_count, [] {});
+}
+
+// get the global thread pool.
+inline std::shared_ptr<spdlog::details::thread_pool> thread_pool()
+{
+    return details::registry::instance().get_tp();
+}
+} // namespace spdlog

core/src/spdlog/async_logger-inl.h

@@ -0,0 +1,92 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/async_logger.h>
+#endif
+
+#include <spdlog/sinks/sink.h>
+#include <spdlog/details/thread_pool.h>
+
+#include <memory>
+#include <string>
+
+SPDLOG_INLINE spdlog::async_logger::async_logger(
+    std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
+    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy)
+{}
+
+SPDLOG_INLINE spdlog::async_logger::async_logger(
+    std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
+    : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy)
+{}
+
+// send the log message to the thread pool
+SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg)
+{
+    if (auto pool_ptr = thread_pool_.lock())
+    {
+        pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
+    }
+    else
+    {
+        throw_spdlog_ex("async log: thread pool doesn't exist anymore");
+    }
+}
+
+// send flush request to the thread pool
+SPDLOG_INLINE void spdlog::async_logger::flush_()
+{
+    if (auto pool_ptr = thread_pool_.lock())
+    {
+        pool_ptr->post_flush(shared_from_this(), overflow_policy_);
+    }
+    else
+    {
+        throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
+    }
+}
+
+//
+// backend functions - called from the thread pool to do the actual job
+//
+SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg)
+{
+    for (auto &sink : sinks_)
+    {
+        if (sink->should_log(msg.level))
+        {
+            SPDLOG_TRY
+            {
+                sink->log(msg);
+            }
+            SPDLOG_LOGGER_CATCH()
+        }
+    }
+
+    if (should_flush_(msg))
+    {
+        backend_flush_();
+    }
+}
+
+SPDLOG_INLINE void spdlog::async_logger::backend_flush_()
+{
+    for (auto &sink : sinks_)
+    {
+        SPDLOG_TRY
+        {
+            sink->flush();
+        }
+        SPDLOG_LOGGER_CATCH()
+    }
+}
+
+SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
+{
+    auto cloned = std::make_shared<spdlog::async_logger>(*this);
+    cloned->name_ = std::move(new_name);
+    return cloned;
+}

core/src/spdlog/async_logger.h

@@ -0,0 +1,68 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Fast asynchronous logger.
+// Uses pre allocated queue.
+// Creates a single back thread to pop messages from the queue and log them.
+//
+// Upon each log write the logger:
+//    1. Checks if its log level is enough to log the message
+//    2. Push a new copy of the message to a queue (or block the caller until
+//    space is available in the queue)
+// Upon destruction, logs all remaining messages in the queue before
+// destructing..
+
+#include <spdlog/logger.h>
+
+namespace spdlog {
+
+// Async overflow policy - block by default.
+enum class async_overflow_policy
+{
+    block,         // Block until message can be enqueued
+    overrun_oldest // Discard oldest message in the queue if full when trying to
+                   // add new item.
+};
+
+namespace details {
+class thread_pool;
+}
+
+class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>, public logger
+{
+    friend class details::thread_pool;
+
+public:
+    template<typename It>
+    async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp,
+        async_overflow_policy overflow_policy = async_overflow_policy::block)
+        : logger(std::move(logger_name), begin, end)
+        , thread_pool_(std::move(tp))
+        , overflow_policy_(overflow_policy)
+    {}
+
+    async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp,
+        async_overflow_policy overflow_policy = async_overflow_policy::block);
+
+    async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
+        async_overflow_policy overflow_policy = async_overflow_policy::block);
+
+    std::shared_ptr<logger> clone(std::string new_name) override;
+
+protected:
+    void sink_it_(const details::log_msg &msg) override;
+    void flush_() override;
+    void backend_sink_it_(const details::log_msg &incoming_log_msg);
+    void backend_flush_();
+
+private:
+    std::weak_ptr<details::thread_pool> thread_pool_;
+    async_overflow_policy overflow_policy_;
+};
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "async_logger-inl.h"
+#endif

core/src/spdlog/cfg/argv.h

@@ -0,0 +1,45 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+#include <spdlog/cfg/helpers.h>
+#include <spdlog/details/registry.h>
+
+//
+// Init log levels using each argv entry that starts with "SPDLOG_LEVEL="
+//
+// set all loggers to debug level:
+// example.exe "SPDLOG_LEVEL=debug"
+
+// set logger1 to trace level
+// example.exe "SPDLOG_LEVEL=logger1=trace"
+
+// turn off all logging except for logger1 and logger2:
+// example.exe "SPDLOG_LEVEL=off,logger1=debug,logger2=info"
+
+namespace spdlog {
+namespace cfg {
+
+// search for SPDLOG_LEVEL= in the args and use it to init the levels
+void load_argv_levels(int argc, const char **argv)
+{
+    const std::string spdlog_level_prefix = "SPDLOG_LEVEL=";
+    for (int i = 1; i < argc; i++)
+    {
+        std::string arg = argv[i];
+        if (arg.find(spdlog_level_prefix) == 0)
+        {
+            auto levels_string = arg.substr(spdlog_level_prefix.size());
+            auto levels = helpers::extract_levels(levels_string);
+            details::registry::instance().update_levels(std::move(levels));
+        }
+    }
+}
+
+void load_argv_levels(int argc, char **argv)
+{
+    load_argv_levels(argc, const_cast<const char **>(argv));
+}
+
+} // namespace cfg
+} // namespace spdlog

core/src/spdlog/cfg/env.h

@@ -0,0 +1,36 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+#include <spdlog/cfg/helpers.h>
+#include <spdlog/details/registry.h>
+#include <spdlog/details/os.h>
+
+//
+// Init levels and patterns from env variables SPDLOG_LEVEL
+// Inspired from Rust's "env_logger" crate (https://crates.io/crates/env_logger).
+// Note - fallback to "info" level on unrecognized levels
+//
+// Examples:
+//
+// set global level to debug:
+// export SPDLOG_LEVEL=debug
+//
+// turn off all logging except for logger1:
+// export SPDLOG_LEVEL="off,logger1=debug"
+//
+
+// turn off all logging except for logger1 and logger2:
+// export SPDLOG_LEVEL="off,logger1=debug,logger2=info"
+
+namespace spdlog {
+namespace cfg {
+void load_env_levels()
+{
+    auto env_val = details::os::getenv("SPDLOG_LEVEL");
+    auto levels = helpers::extract_levels(env_val);
+    details::registry::instance().update_levels(std::move(levels));
+}
+
+} // namespace cfg
+} // namespace spdlog

core/src/spdlog/cfg/helpers-inl.h

@@ -0,0 +1,103 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/cfg/helpers.h>
+#endif
+
+#include <spdlog/spdlog.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/registry.h>
+
+#include <string>
+#include <utility>
+#include <sstream>
+
+namespace spdlog {
+namespace cfg {
+namespace helpers {
+
+// inplace convert to lowercase
+inline std::string &to_lower_(std::string &str)
+{
+    std::transform(
+        str.begin(), str.end(), str.begin(), [](char ch) { return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); });
+    return str;
+}
+
+// inplace trim spaces
+inline std::string &trim_(std::string &str)
+{
+    const char *spaces = " \n\r\t";
+    str.erase(str.find_last_not_of(spaces) + 1);
+    str.erase(0, str.find_first_not_of(spaces));
+    return str;
+}
+
+// return (name,value) trimmed pair from given "name=value" string.
+// return empty string on missing parts
+// "key=val" => ("key", "val")
+// " key  =  val " => ("key", "val")
+// "key=" => ("key", "")
+// "val" => ("", "val")
+
+inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str)
+{
+    auto n = str.find(sep);
+    std::string k, v;
+    if (n == std::string::npos)
+    {
+        v = str;
+    }
+    else
+    {
+        k = str.substr(0, n);
+        v = str.substr(n + 1);
+    }
+    return std::make_pair(trim_(k), trim_(v));
+}
+
+// return vector of key/value pairs from sequence of "K1=V1,K2=V2,.."
+// "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...}
+inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str)
+{
+    std::string token;
+    std::istringstream token_stream(str);
+    std::unordered_map<std::string, std::string> rv{};
+    while (std::getline(token_stream, token, ','))
+    {
+        if (token.empty())
+        {
+            continue;
+        }
+        auto kv = extract_kv_('=', token);
+        rv[kv.first] = kv.second;
+    }
+    return rv;
+}
+
+SPDLOG_INLINE log_levels extract_levels(const std::string &input)
+{
+    auto key_vals = extract_key_vals_(input);
+    log_levels rv;
+
+    for (auto &name_level : key_vals)
+    {
+        auto &logger_name = name_level.first;
+        auto level_name = to_lower_(name_level.second);
+        auto level = level::from_str(level_name);
+        // fallback to "info" if unrecognized level name
+        if (level == level::off && level_name != "off")
+        {
+            level = level::info;
+        }
+        rv.set(logger_name, level);
+    }
+    return rv;
+}
+
+} // namespace helpers
+} // namespace cfg
+} // namespace spdlog

core/src/spdlog/cfg/helpers.h

@@ -0,0 +1,28 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/cfg/log_levels.h>
+
+namespace spdlog {
+namespace cfg {
+namespace helpers {
+//
+// Init levels from given string
+//
+// Examples:
+//
+// set global level to debug: "debug"
+// turn off all logging except for logger1: "off,logger1=debug"
+// turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info"
+//
+SPDLOG_API log_levels extract_levels(const std::string &txt);
+} // namespace helpers
+
+} // namespace cfg
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "helpers-inl.h"
+#endif // SPDLOG_HEADER_ONLY

core/src/spdlog/cfg/log_levels.h

@@ -0,0 +1,47 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <string>
+#include <unordered_map>
+
+namespace spdlog {
+namespace cfg {
+class log_levels
+{
+    std::unordered_map<std::string, spdlog::level::level_enum> levels_;
+    spdlog::level::level_enum default_level_ = level::info;
+
+public:
+    void set(const std::string &logger_name, level::level_enum lvl)
+    {
+        if (logger_name.empty())
+        {
+            default_level_ = lvl;
+        }
+        else
+        {
+            levels_[logger_name] = lvl;
+        }
+    }
+
+    void set_default(level::level_enum lvl)
+    {
+        default_level_ = lvl;
+    }
+
+    level::level_enum get(const std::string &logger_name)
+    {
+        auto it = levels_.find(logger_name);
+        return it != levels_.end() ? it->second : default_level_;
+    }
+
+    level::level_enum default_level()
+    {
+        return default_level_;
+    }
+};
+} // namespace cfg
+} // namespace spdlog

core/src/spdlog/common-inl.h

@@ -0,0 +1,76 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/common.h>
+#endif
+
+namespace spdlog {
+namespace level {
+static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES;
+
+static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES;
+
+SPDLOG_INLINE string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
+{
+    return level_string_views[l];
+}
+
+SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
+{
+    return short_level_names[l];
+}
+
+SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT
+{
+    int level = 0;
+    for (const auto &level_str : level_string_views)
+    {
+        if (level_str == name)
+        {
+            return static_cast<level::level_enum>(level);
+        }
+        level++;
+    }
+    // check also for "warn" and "err" before giving up..
+    if (name == "warn")
+    {
+        return level::warn;
+    }
+    if (name == "err")
+    {
+        return level::err;
+    }
+    return level::off;
+}
+} // namespace level
+
+SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg)
+    : msg_(std::move(msg))
+{}
+
+SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno)
+{
+    memory_buf_t outbuf;
+    fmt::format_system_error(outbuf, last_errno, msg);
+    msg_ = fmt::to_string(outbuf);
+}
+
+SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT
+{
+    return msg_.c_str();
+}
+
+SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno)
+{
+    SPDLOG_THROW(spdlog_ex(msg, last_errno));
+}
+
+SPDLOG_INLINE void throw_spdlog_ex(std::string msg)
+{
+    SPDLOG_THROW(spdlog_ex(std::move(msg)));
+}
+
+} // namespace spdlog

core/src/spdlog/common.h

@@ -0,0 +1,246 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/tweakme.h>
+#include <spdlog/details/null_mutex.h>
+
+#include <atomic>
+#include <chrono>
+#include <initializer_list>
+#include <memory>
+#include <exception>
+#include <string>
+#include <type_traits>
+#include <functional>
+
+#ifdef SPDLOG_COMPILED_LIB
+#undef SPDLOG_HEADER_ONLY
+#if defined(_WIN32) && defined(SPDLOG_SHARED_LIB)
+#ifdef spdlog_EXPORTS
+#define SPDLOG_API __declspec(dllexport)
+#else
+#define SPDLOG_API __declspec(dllimport)
+#endif
+#else // !defined(_WIN32) || !defined(SPDLOG_SHARED_LIB)
+#define SPDLOG_API
+#endif
+#define SPDLOG_INLINE
+#else // !defined(SPDLOG_COMPILED_LIB)
+#define SPDLOG_API
+#define SPDLOG_HEADER_ONLY
+#define SPDLOG_INLINE inline
+#endif // #ifdef SPDLOG_COMPILED_LIB
+
+#include <spdlog/fmt/fmt.h>
+
+// visual studio upto 2013 does not support noexcept nor constexpr
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+#define SPDLOG_NOEXCEPT _NOEXCEPT
+#define SPDLOG_CONSTEXPR
+#else
+#define SPDLOG_NOEXCEPT noexcept
+#define SPDLOG_CONSTEXPR constexpr
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#define SPDLOG_DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define SPDLOG_DEPRECATED __declspec(deprecated)
+#else
+#define SPDLOG_DEPRECATED
+#endif
+
+// disable thread local on msvc 2013
+#ifndef SPDLOG_NO_TLS
+#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)
+#define SPDLOG_NO_TLS 1
+#endif
+#endif
+
+#ifndef SPDLOG_FUNCTION
+#define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__)
+#endif
+
+#ifdef SPDLOG_NO_EXCEPTIONS
+#define SPDLOG_TRY
+#define SPDLOG_THROW(ex)                                                                                                                   \
+    do                                                                                                                                     \
+    {                                                                                                                                      \
+        printf("spdlog fatal error: %s\n", ex.what());                                                                                     \
+        std::abort();                                                                                                                      \
+    } while (0)
+#define SPDLOG_CATCH_ALL()
+#else
+#define SPDLOG_TRY try
+#define SPDLOG_THROW(ex) throw(ex)
+#define SPDLOG_CATCH_ALL() catch (...)
+#endif
+
+namespace spdlog {
+
+class formatter;
+
+namespace sinks {
+class sink;
+}
+
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+using filename_t = std::wstring;
+#define SPDLOG_FILENAME_T(s) L##s
+#else
+using filename_t = std::string;
+#define SPDLOG_FILENAME_T(s) s
+#endif
+
+using log_clock = std::chrono::system_clock;
+using sink_ptr = std::shared_ptr<sinks::sink>;
+using sinks_init_list = std::initializer_list<sink_ptr>;
+using err_handler = std::function<void(const std::string &err_msg)>;
+using string_view_t = fmt::basic_string_view<char>;
+using wstring_view_t = fmt::basic_string_view<wchar_t>;
+using memory_buf_t = fmt::basic_memory_buffer<char, 250>;
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+#ifndef _WIN32
+#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
+#else
+template<typename T>
+struct is_convertible_to_wstring_view : std::is_convertible<T, wstring_view_t>
+{};
+#endif // _WIN32
+#else
+template<typename>
+struct is_convertible_to_wstring_view : std::false_type
+{};
+#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
+
+#if defined(SPDLOG_NO_ATOMIC_LEVELS)
+using level_t = details::null_atomic_int;
+#else
+using level_t = std::atomic<int>;
+#endif
+
+#define SPDLOG_LEVEL_TRACE 0
+#define SPDLOG_LEVEL_DEBUG 1
+#define SPDLOG_LEVEL_INFO 2
+#define SPDLOG_LEVEL_WARN 3
+#define SPDLOG_LEVEL_ERROR 4
+#define SPDLOG_LEVEL_CRITICAL 5
+#define SPDLOG_LEVEL_OFF 6
+
+#if !defined(SPDLOG_ACTIVE_LEVEL)
+#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
+#endif
+
+// Log level enum
+namespace level {
+enum level_enum
+{
+    trace = SPDLOG_LEVEL_TRACE,
+    debug = SPDLOG_LEVEL_DEBUG,
+    info = SPDLOG_LEVEL_INFO,
+    warn = SPDLOG_LEVEL_WARN,
+    err = SPDLOG_LEVEL_ERROR,
+    critical = SPDLOG_LEVEL_CRITICAL,
+    off = SPDLOG_LEVEL_OFF,
+    n_levels
+};
+
+#if !defined(SPDLOG_LEVEL_NAMES)
+#define SPDLOG_LEVEL_NAMES                                                                                                                 \
+    {                                                                                                                                      \
+        "trace", "debug", "info", "warning", "error", "critical", "off"                                                                    \
+    }
+#endif
+
+#if !defined(SPDLOG_SHORT_LEVEL_NAMES)
+
+#define SPDLOG_SHORT_LEVEL_NAMES                                                                                                           \
+    {                                                                                                                                      \
+        "T", "D", "I", "W", "E", "C", "O"                                                                                                  \
+    }
+#endif
+
+SPDLOG_API string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
+SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
+SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT;
+
+using level_hasher = std::hash<int>;
+} // namespace level
+
+//
+// Color mode used by sinks with color support.
+//
+enum class color_mode
+{
+    always,
+    automatic,
+    never
+};
+
+//
+// Pattern time - specific time getting to use for pattern_formatter.
+// local time by default
+//
+enum class pattern_time_type
+{
+    local, // log localtime
+    utc    // log utc
+};
+
+//
+// Log exception
+//
+class SPDLOG_API spdlog_ex : public std::exception
+{
+public:
+    explicit spdlog_ex(std::string msg);
+    spdlog_ex(const std::string &msg, int last_errno);
+    const char *what() const SPDLOG_NOEXCEPT override;
+
+private:
+    std::string msg_;
+};
+
+SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno);
+SPDLOG_API void throw_spdlog_ex(std::string msg);
+
+struct source_loc
+{
+    SPDLOG_CONSTEXPR source_loc() = default;
+    SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in)
+        : filename{filename_in}
+        , line{line_in}
+        , funcname{funcname_in}
+    {}
+
+    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT
+    {
+        return line == 0;
+    }
+    const char *filename{nullptr};
+    int line{0};
+    const char *funcname{nullptr};
+};
+
+namespace details {
+// make_unique support for pre c++14
+
+#if __cplusplus >= 201402L // C++14 and beyond
+using std::make_unique;
+#else
+template<typename T, typename... Args>
+std::unique_ptr<T> make_unique(Args &&... args)
+{
+    static_assert(!std::is_array<T>::value, "arrays not supported");
+    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+#endif
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "common-inl.h"
+#endif

core/src/spdlog/details/backtracer-inl.h

@@ -0,0 +1,69 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/backtracer.h>
+#endif
+namespace spdlog {
+namespace details {
+SPDLOG_INLINE backtracer::backtracer(const backtracer &other)
+{
+    std::lock_guard<std::mutex> lock(other.mutex_);
+    enabled_ = other.enabled();
+    messages_ = other.messages_;
+}
+
+SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT
+{
+    std::lock_guard<std::mutex> lock(other.mutex_);
+    enabled_ = other.enabled();
+    messages_ = std::move(other.messages_);
+}
+
+SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other)
+{
+    std::lock_guard<std::mutex> lock(mutex_);
+    enabled_ = other.enabled();
+    messages_ = std::move(other.messages_);
+    return *this;
+}
+
+SPDLOG_INLINE void backtracer::enable(size_t size)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    enabled_.store(true, std::memory_order_relaxed);
+    messages_ = circular_q<log_msg_buffer>{size};
+}
+
+SPDLOG_INLINE void backtracer::disable()
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    enabled_.store(false, std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE bool backtracer::enabled() const
+{
+    return enabled_.load(std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE void backtracer::push_back(const log_msg &msg)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    messages_.push_back(log_msg_buffer{msg});
+}
+
+// pop all items in the q and apply the given fun on each of them.
+SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    while (!messages_.empty())
+    {
+        auto &front_msg = messages_.front();
+        fun(front_msg);
+        messages_.pop_front();
+    }
+}
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/backtracer.h

@@ -0,0 +1,45 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg_buffer.h>
+#include <spdlog/details/circular_q.h>
+
+#include <atomic>
+#include <mutex>
+#include <functional>
+
+// Store log messages in circular buffer.
+// Useful for storing debug data in case of error/warning happens.
+
+namespace spdlog {
+namespace details {
+class SPDLOG_API backtracer
+{
+    mutable std::mutex mutex_;
+    std::atomic<bool> enabled_{false};
+    circular_q<log_msg_buffer> messages_;
+
+public:
+    backtracer() = default;
+    backtracer(const backtracer &other);
+
+    backtracer(backtracer &&other) SPDLOG_NOEXCEPT;
+    backtracer &operator=(backtracer other);
+
+    void enable(size_t size);
+    void disable();
+    bool enabled() const;
+    void push_back(const log_msg &msg);
+
+    // pop all items in the q and apply the given fun on each of them.
+    void foreach_pop(std::function<void(const details::log_msg &)> fun);
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "backtracer-inl.h"
+#endif

core/src/spdlog/details/circular_q.h

@@ -0,0 +1,141 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+// circular q view of std::vector.
+#pragma once
+
+#include <vector>
+#include <cassert>
+
+namespace spdlog {
+namespace details {
+template<typename T>
+class circular_q
+{
+    size_t max_items_ = 0;
+    typename std::vector<T>::size_type head_ = 0;
+    typename std::vector<T>::size_type tail_ = 0;
+    size_t overrun_counter_ = 0;
+    std::vector<T> v_;
+
+public:
+    using value_type = T;
+
+    // empty ctor - create a disabled queue with no elements allocated at all
+    circular_q() = default;
+
+    explicit circular_q(size_t max_items)
+        : max_items_(max_items + 1) // one item is reserved as marker for full q
+        , v_(max_items_)
+    {}
+
+    circular_q(const circular_q &) = default;
+    circular_q &operator=(const circular_q &) = default;
+
+    // move cannot be default,
+    // since we need to reset head_, tail_, etc to zero in the moved object
+    circular_q(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        copy_moveable(std::move(other));
+    }
+
+    circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        copy_moveable(std::move(other));
+        return *this;
+    }
+
+    // push back, overrun (oldest) item if no room left
+    void push_back(T &&item)
+    {
+        if (max_items_ > 0)
+        {
+            v_[tail_] = std::move(item);
+            tail_ = (tail_ + 1) % max_items_;
+
+            if (tail_ == head_) // overrun last item if full
+            {
+                head_ = (head_ + 1) % max_items_;
+                ++overrun_counter_;
+            }
+        }
+    }
+
+    // Return reference to the front item.
+    // If there are no elements in the container, the behavior is undefined.
+    const T &front() const
+    {
+        return v_[head_];
+    }
+
+    T &front()
+    {
+        return v_[head_];
+    }
+
+    // Return number of elements actually stored
+    size_t size() const
+    {
+        if (tail_ >= head_)
+        {
+            return tail_ - head_;
+        }
+        else
+        {
+            return max_items_ - (head_ - tail_);
+        }
+    }
+
+    // Return const reference to item by index.
+    // If index is out of range 0…size()-1, the behavior is undefined.
+    const T &at(size_t i) const
+    {
+        assert(i < size());
+        return v_[(head_ + i) % max_items_];
+    }
+
+    // Pop item from front.
+    // If there are no elements in the container, the behavior is undefined.
+    void pop_front()
+    {
+        head_ = (head_ + 1) % max_items_;
+    }
+
+    bool empty() const
+    {
+        return tail_ == head_;
+    }
+
+    bool full() const
+    {
+        // head is ahead of the tail by 1
+        if (max_items_ > 0)
+        {
+            return ((tail_ + 1) % max_items_) == head_;
+        }
+        return false;
+    }
+
+    size_t overrun_counter() const
+    {
+        return overrun_counter_;
+    }
+
+private:
+    // copy from other&& and reset it to disabled state
+    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        max_items_ = other.max_items_;
+        head_ = other.head_;
+        tail_ = other.tail_;
+        overrun_counter_ = other.overrun_counter_;
+        v_ = std::move(other.v_);
+
+        // put &&other in disabled, but valid state
+        other.max_items_ = 0;
+        other.head_ = other.tail_ = 0;
+        other.overrun_counter_ = 0;
+    }
+};
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/console_globals.h

@@ -0,0 +1,32 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <mutex>
+
+namespace spdlog {
+namespace details {
+
+struct console_mutex
+{
+    using mutex_t = std::mutex;
+    static mutex_t &mutex()
+    {
+        static mutex_t s_mutex;
+        return s_mutex;
+    }
+};
+
+struct console_nullmutex
+{
+    using mutex_t = null_mutex;
+    static mutex_t &mutex()
+    {
+        static mutex_t s_mutex;
+        return s_mutex;
+    }
+};
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/file_helper-inl.h

@@ -0,0 +1,132 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/file_helper.h>
+#endif
+
+#include <spdlog/details/os.h>
+#include <spdlog/common.h>
+
+#include <cerrno>
+#include <chrono>
+#include <cstdio>
+#include <string>
+#include <thread>
+#include <tuple>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE file_helper::~file_helper()
+{
+    close();
+}
+
+SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)
+{
+    close();
+    filename_ = fname;
+    auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab");
+
+    for (int tries = 0; tries < open_tries_; ++tries)
+    {
+        // create containing folder if not exists already.
+        os::create_dir(os::dir_name(fname));
+        if (!os::fopen_s(&fd_, fname, mode))
+        {
+            return;
+        }
+
+        details::os::sleep_for_millis(open_interval_);
+    }
+
+    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno);
+}
+
+SPDLOG_INLINE void file_helper::reopen(bool truncate)
+{
+    if (filename_.empty())
+    {
+        throw_spdlog_ex("Failed re opening file - was not opened before");
+    }
+    this->open(filename_, truncate);
+}
+
+SPDLOG_INLINE void file_helper::flush()
+{
+    std::fflush(fd_);
+}
+
+SPDLOG_INLINE void file_helper::close()
+{
+    if (fd_ != nullptr)
+    {
+        std::fclose(fd_);
+        fd_ = nullptr;
+    }
+}
+
+SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf)
+{
+    size_t msg_size = buf.size();
+    auto data = buf.data();
+    if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
+    {
+        throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno);
+    }
+}
+
+SPDLOG_INLINE size_t file_helper::size() const
+{
+    if (fd_ == nullptr)
+    {
+        throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_));
+    }
+    return os::filesize(fd_);
+}
+
+SPDLOG_INLINE const filename_t &file_helper::filename() const
+{
+    return filename_;
+}
+
+//
+// return file path and its extension:
+//
+// "mylog.txt" => ("mylog", ".txt")
+// "mylog" => ("mylog", "")
+// "mylog." => ("mylog.", "")
+// "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
+//
+// the starting dot in filenames is ignored (hidden files):
+//
+// ".mylog" => (".mylog". "")
+// "my_folder/.mylog" => ("my_folder/.mylog", "")
+// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
+SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)
+{
+    auto ext_index = fname.rfind('.');
+
+    // no valid extension found - return whole path and empty string as
+    // extension
+    if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)
+    {
+        return std::make_tuple(fname, filename_t());
+    }
+
+    // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
+    auto folder_index = fname.rfind(details::os::folder_sep);
+    if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
+    {
+        return std::make_tuple(fname, filename_t());
+    }
+
+    // finally - return a valid base and extension tuple
+    return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
+}
+
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/file_helper.h

@@ -0,0 +1,59 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <tuple>
+
+namespace spdlog {
+namespace details {
+
+// Helper class for file sinks.
+// When failing to open a file, retry several times(5) with a delay interval(10 ms).
+// Throw spdlog_ex exception on errors.
+
+class SPDLOG_API file_helper
+{
+public:
+    explicit file_helper() = default;
+
+    file_helper(const file_helper &) = delete;
+    file_helper &operator=(const file_helper &) = delete;
+    ~file_helper();
+
+    void open(const filename_t &fname, bool truncate = false);
+    void reopen(bool truncate);
+    void flush();
+    void close();
+    void write(const memory_buf_t &buf);
+    size_t size() const;
+    const filename_t &filename() const;
+
+    //
+    // return file path and its extension:
+    //
+    // "mylog.txt" => ("mylog", ".txt")
+    // "mylog" => ("mylog", "")
+    // "mylog." => ("mylog.", "")
+    // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
+    //
+    // the starting dot in filenames is ignored (hidden files):
+    //
+    // ".mylog" => (".mylog". "")
+    // "my_folder/.mylog" => ("my_folder/.mylog", "")
+    // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
+    static std::tuple<filename_t, filename_t> split_by_extension(const filename_t &fname);
+
+private:
+    const int open_tries_ = 5;
+    const int open_interval_ = 10;
+    std::FILE *fd_{nullptr};
+    filename_t filename_;
+};
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "file_helper-inl.h"
+#endif

core/src/spdlog/details/fmt_helper.h

@@ -0,0 +1,116 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+#pragma once
+
+#include <chrono>
+#include <type_traits>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/common.h>
+
+// Some fmt helpers to efficiently format and pad ints and strings
+namespace spdlog {
+namespace details {
+namespace fmt_helper {
+
+inline spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT
+{
+    return spdlog::string_view_t{buf.data(), buf.size()};
+}
+
+inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest)
+{
+    auto *buf_ptr = view.data();
+    dest.append(buf_ptr, buf_ptr + view.size());
+}
+
+template<typename T>
+inline void append_int(T n, memory_buf_t &dest)
+{
+    fmt::format_int i(n);
+    dest.append(i.data(), i.data() + i.size());
+}
+
+template<typename T>
+inline unsigned int count_digits(T n)
+{
+    using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
+    return static_cast<unsigned int>(fmt::
+// fmt 7.0.0 renamed the internal namespace to detail.
+// See: https://github.com/fmtlib/fmt/issues/1538
+#if FMT_VERSION < 70000
+internal
+#else
+detail
+#endif
+::count_digits(static_cast<count_type>(n)));
+}
+
+inline void pad2(int n, memory_buf_t &dest)
+{
+    if (n >= 0 && n < 100) // 0-99
+    {
+        dest.push_back(static_cast<char>('0' + n / 10));
+        dest.push_back(static_cast<char>('0' + n % 10));
+    }
+    else // unlikely, but just in case, let fmt deal with it
+    {
+        fmt::format_to(dest, "{:02}", n);
+    }
+}
+
+template<typename T>
+inline void pad_uint(T n, unsigned int width, memory_buf_t &dest)
+{
+    static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
+    for (auto digits = count_digits(n); digits < width; digits++)
+    {
+        dest.push_back('0');
+    }
+    append_int(n, dest);
+}
+
+template<typename T>
+inline void pad3(T n, memory_buf_t &dest)
+{
+    static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T");
+    if (n < 1000)
+    {
+        dest.push_back(static_cast<char>(n / 100 + '0'));
+        n = n % 100;
+        dest.push_back(static_cast<char>((n / 10) + '0'));
+        dest.push_back(static_cast<char>((n % 10) + '0'));
+    }
+    else
+    {
+        append_int(n, dest);
+    }
+}
+
+template<typename T>
+inline void pad6(T n, memory_buf_t &dest)
+{
+    pad_uint(n, 6, dest);
+}
+
+template<typename T>
+inline void pad9(T n, memory_buf_t &dest)
+{
+    pad_uint(n, 9, dest);
+}
+
+// return fraction of a second of the given time_point.
+// e.g.
+// fraction<std::milliseconds>(tp) -> will return the millis part of the second
+template<typename ToDuration>
+inline ToDuration time_fraction(log_clock::time_point tp)
+{
+    using std::chrono::duration_cast;
+    using std::chrono::seconds;
+    auto duration = tp.time_since_epoch();
+    auto secs = duration_cast<seconds>(duration);
+    return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
+}
+
+} // namespace fmt_helper
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/log_msg-inl.h

@@ -0,0 +1,37 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/log_msg.h>
+#endif
+
+#include <spdlog/details/os.h>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name,
+    spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : logger_name(a_logger_name)
+    , level(lvl)
+    , time(log_time)
+#ifndef SPDLOG_NO_THREAD_ID
+    , thread_id(os::thread_id())
+#endif
+    , source(loc)
+    , payload(msg)
+{}
+
+SPDLOG_INLINE log_msg::log_msg(
+    spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : log_msg(os::now(), loc, a_logger_name, lvl, msg)
+{}
+
+SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg)
+{}
+
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/log_msg.h

@@ -0,0 +1,36 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <string>
+
+namespace spdlog {
+namespace details {
+struct SPDLOG_API log_msg
+{
+    log_msg() = default;
+    log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(const log_msg &other) = default;
+
+    string_view_t logger_name;
+    level::level_enum level{level::off};
+    log_clock::time_point time;
+    size_t thread_id{0};
+
+    // wrapping the formatted text with color (updated by pattern_formatter).
+    mutable size_t color_range_start{0};
+    mutable size_t color_range_end{0};
+
+    source_loc source;
+    string_view_t payload;
+};
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "log_msg-inl.h"
+#endif

core/src/spdlog/details/log_msg_buffer-inl.h

@@ -0,0 +1,58 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/log_msg_buffer.h>
+#endif
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)
+    : log_msg{orig_msg}
+{
+    buffer.append(logger_name.begin(), logger_name.end());
+    buffer.append(payload.begin(), payload.end());
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
+    : log_msg{other}
+{
+    buffer.append(logger_name.begin(), logger_name.end());
+    buffer.append(payload.begin(), payload.end());
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT : log_msg{other}, buffer{std::move(other.buffer)}
+{
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other)
+{
+    log_msg::operator=(other);
+    buffer.clear();
+    buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size());
+    update_string_views();
+    return *this;
+}
+
+SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT
+{
+    log_msg::operator=(other);
+    buffer = std::move(other.buffer);
+    update_string_views();
+    return *this;
+}
+
+SPDLOG_INLINE void log_msg_buffer::update_string_views()
+{
+    logger_name = string_view_t{buffer.data(), logger_name.size()};
+    payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};
+}
+
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/log_msg_buffer.h

@@ -0,0 +1,33 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg.h>
+
+namespace spdlog {
+namespace details {
+
+// Extend log_msg with internal buffer to store its payload.
+// This is needed since log_msg holds string_views that points to stack data.
+
+class SPDLOG_API log_msg_buffer : public log_msg
+{
+    memory_buf_t buffer;
+    void update_string_views();
+
+public:
+    log_msg_buffer() = default;
+    explicit log_msg_buffer(const log_msg &orig_msg);
+    log_msg_buffer(const log_msg_buffer &other);
+    log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
+    log_msg_buffer &operator=(const log_msg_buffer &other);
+    log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "log_msg_buffer-inl.h"
+#endif

core/src/spdlog/details/mpmc_blocking_q.h

@@ -0,0 +1,120 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// multi producer-multi consumer blocking queue.
+// enqueue(..) - will block until room found to put the new message.
+// enqueue_nowait(..) - will return immediately with false if no room left in
+// the queue.
+// dequeue_for(..) - will block until the queue is not empty or timeout have
+// passed.
+
+#include <spdlog/details/circular_q.h>
+
+#include <condition_variable>
+#include <mutex>
+
+namespace spdlog {
+namespace details {
+
+template<typename T>
+class mpmc_blocking_queue
+{
+public:
+    using item_type = T;
+    explicit mpmc_blocking_queue(size_t max_items)
+        : q_(max_items)
+    {}
+
+#ifndef __MINGW32__
+    // try to enqueue and block if no room left
+    void enqueue(T &&item)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            pop_cv_.wait(lock, [this] { return !this->q_.full(); });
+            q_.push_back(std::move(item));
+        }
+        push_cv_.notify_one();
+    }
+
+    // enqueue immediately. overrun oldest message in the queue if no room left.
+    void enqueue_nowait(T &&item)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            q_.push_back(std::move(item));
+        }
+        push_cv_.notify_one();
+    }
+
+    // try to dequeue item. if no item found. wait upto timeout and try again
+    // Return true, if succeeded dequeue item, false otherwise
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
+            {
+                return false;
+            }
+            popped_item = std::move(q_.front());
+            q_.pop_front();
+        }
+        pop_cv_.notify_one();
+        return true;
+    }
+
+#else
+    // apparently mingw deadlocks if the mutex is released before cv.notify_one(),
+    // so release the mutex at the very end each function.
+
+    // try to enqueue and block if no room left
+    void enqueue(T &&item)
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        pop_cv_.wait(lock, [this] { return !this->q_.full(); });
+        q_.push_back(std::move(item));
+        push_cv_.notify_one();
+    }
+
+    // enqueue immediately. overrun oldest message in the queue if no room left.
+    void enqueue_nowait(T &&item)
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        q_.push_back(std::move(item));
+        push_cv_.notify_one();
+    }
+
+    // try to dequeue item. if no item found. wait upto timeout and try again
+    // Return true, if succeeded dequeue item, false otherwise
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
+        {
+            return false;
+        }
+        popped_item = std::move(q_.front());
+        q_.pop_front();
+        pop_cv_.notify_one();
+        return true;
+    }
+
+#endif
+
+    size_t overrun_counter()
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        return q_.overrun_counter();
+    }
+
+private:
+    std::mutex queue_mutex_;
+    std::condition_variable push_cv_;
+    std::condition_variable pop_cv_;
+    spdlog::details::circular_q<T> q_;
+};
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/null_mutex.h

@@ -0,0 +1,49 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <atomic>
+#include <utility>
+// null, no cost dummy "mutex" and dummy "atomic" int
+
+namespace spdlog {
+namespace details {
+struct null_mutex
+{
+    void lock() const {}
+    void unlock() const {}
+    bool try_lock() const
+    {
+        return true;
+    }
+};
+
+struct null_atomic_int
+{
+    int value;
+    null_atomic_int() = default;
+
+    explicit null_atomic_int(int new_value)
+        : value(new_value)
+    {}
+
+    int load(std::memory_order = std::memory_order_relaxed) const
+    {
+        return value;
+    }
+
+    void store(int new_value, std::memory_order = std::memory_order_relaxed)
+    {
+        value = new_value;
+    }
+
+    int exchange(int new_value, std::memory_order = std::memory_order_relaxed)
+    {
+        std::swap(new_value, value);
+        return new_value; // return value before the call
+    }
+};
+
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/os-inl.h

@@ -0,0 +1,554 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/os.h>
+#endif
+
+#include <spdlog/common.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <string>
+#include <thread>
+#include <array>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef _WIN32
+
+#include <io.h>      // _get_osfhandle and _isatty support
+#include <process.h> //  _get_pid support
+#include <spdlog/details/windows_include.h>
+
+#ifdef __MINGW32__
+#include <share.h>
+#endif
+
+#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
+#include <limits>
+#endif
+
+#include <direct.h> // for _mkdir/_wmkdir
+
+#else // unix
+
+#include <fcntl.h>
+#include <unistd.h>
+
+#ifdef __linux__
+#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
+
+#elif defined(_AIX)
+#include <pthread.h> // for pthread_getthreadid_np
+
+#elif defined(__DragonFly__) || defined(__FreeBSD__)
+#include <pthread_np.h> // for pthread_getthreadid_np
+
+#elif defined(__NetBSD__)
+#include <lwp.h> // for _lwp_self
+
+#elif defined(__sun)
+#include <thread.h> // for thr_self
+#endif
+
+#endif // unix
+
+#ifndef __has_feature      // Clang - feature checking macros.
+#define __has_feature(x) 0 // Compatibility with non-clang compilers.
+#endif
+
+namespace spdlog {
+namespace details {
+namespace os {
+
+SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT
+{
+
+#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
+    timespec ts;
+    ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
+    return std::chrono::time_point<log_clock, typename log_clock::duration>(
+        std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
+
+#else
+    return log_clock::now();
+#endif
+}
+SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    std::tm tm;
+    ::localtime_s(&tm, &time_tt);
+#else
+    std::tm tm;
+    ::localtime_r(&time_tt, &tm);
+#endif
+    return tm;
+}
+
+SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT
+{
+    std::time_t now_t = ::time(nullptr);
+    return localtime(now_t);
+}
+
+SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    std::tm tm;
+    ::gmtime_s(&tm, &time_tt);
+#else
+    std::tm tm;
+    ::gmtime_r(&time_tt, &tm);
+#endif
+    return tm;
+}
+
+SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT
+{
+    std::time_t now_t = ::time(nullptr);
+    return gmtime(now_t);
+}
+
+// fopen_s on non windows for writing
+SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
+{
+#ifdef _WIN32
+#ifdef SPDLOG_WCHAR_FILENAMES
+    *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
+#else
+    *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
+#endif
+#if defined(SPDLOG_PREVENT_CHILD_FD)
+    if (*fp != nullptr)
+    {
+        auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));
+        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
+        {
+            ::fclose(*fp);
+            *fp = nullptr;
+        }
+    }
+#endif
+#else // unix
+#if defined(SPDLOG_PREVENT_CHILD_FD)
+    const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
+    const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
+    if (fd == -1)
+    {
+        return false;
+    }
+    *fp = ::fdopen(fd, mode.c_str());
+    if (*fp == nullptr)
+    {
+        ::close(fd);
+    }
+#else
+    *fp = ::fopen((filename.c_str()), mode.c_str());
+#endif
+#endif
+
+    return *fp == nullptr;
+}
+
+SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+    return ::_wremove(filename.c_str());
+#else
+    return std::remove(filename.c_str());
+#endif
+}
+
+SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+    return path_exists(filename) ? remove(filename) : 0;
+}
+
+SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+    return ::_wrename(filename1.c_str(), filename2.c_str());
+#else
+    return std::rename(filename1.c_str(), filename2.c_str());
+#endif
+}
+
+// Return true if path exists (file or directory)
+SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+#ifdef SPDLOG_WCHAR_FILENAMES
+    auto attribs = ::GetFileAttributesW(filename.c_str());
+#else
+    auto attribs = ::GetFileAttributesA(filename.c_str());
+#endif
+    return attribs != INVALID_FILE_ATTRIBUTES;
+#else // common linux/unix all have the stat system call
+    struct stat buffer;
+    return (::stat(filename.c_str(), &buffer) == 0);
+#endif
+}
+
+// Return file size according to open FILE* object
+SPDLOG_INLINE size_t filesize(FILE *f)
+{
+    if (f == nullptr)
+    {
+        throw_spdlog_ex("Failed getting file size. fd is null");
+    }
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    int fd = ::_fileno(f);
+#if _WIN64 // 64 bits
+    __int64 ret = ::_filelengthi64(fd);
+    if (ret >= 0)
+    {
+        return static_cast<size_t>(ret);
+    }
+
+#else // windows 32 bits
+    long ret = ::_filelength(fd);
+    if (ret >= 0)
+    {
+        return static_cast<size_t>(ret);
+    }
+#endif
+
+#else // unix
+// OpenBSD doesn't compile with :: before the fileno(..)
+#if defined(__OpenBSD__)
+    int fd = fileno(f);
+#else
+    int fd = ::fileno(f);
+#endif
+// 64 bits(but not in osx or cygwin, where fstat64 is deprecated)
+#if (defined(__linux__) || defined(__sun) || defined(_AIX)) && (defined(__LP64__) || defined(_LP64))
+    struct stat64 st;
+    if (::fstat64(fd, &st) == 0)
+    {
+        return static_cast<size_t>(st.st_size);
+    }
+#else // other unix or linux 32 bits or cygwin
+    struct stat st;
+    if (::fstat(fd, &st) == 0)
+    {
+        return static_cast<size_t>(st.st_size);
+    }
+#endif
+#endif
+    throw_spdlog_ex("Failed getting file size from fd", errno);
+    return 0; // will not be reached.
+}
+
+// Return utc offset in minutes or throw spdlog_ex on failure
+SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
+{
+
+#ifdef _WIN32
+#if _WIN32_WINNT < _WIN32_WINNT_WS08
+    TIME_ZONE_INFORMATION tzinfo;
+    auto rv = ::GetTimeZoneInformation(&tzinfo);
+#else
+    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
+    auto rv = ::GetDynamicTimeZoneInformation(&tzinfo);
+#endif
+    if (rv == TIME_ZONE_ID_INVALID)
+        throw_spdlog_ex("Failed getting timezone info. ", errno);
+
+    int offset = -tzinfo.Bias;
+    if (tm.tm_isdst)
+    {
+        offset -= tzinfo.DaylightBias;
+    }
+    else
+    {
+        offset -= tzinfo.StandardBias;
+    }
+    return offset;
+#else
+
+#if defined(sun) || defined(__sun) || defined(_AIX) || (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))
+    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
+    struct helper
+    {
+        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())
+        {
+            int local_year = localtm.tm_year + (1900 - 1);
+            int gmt_year = gmtm.tm_year + (1900 - 1);
+
+            long int days = (
+                // difference in day of year
+                localtm.tm_yday -
+                gmtm.tm_yday
+
+                // + intervening leap days
+                + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) +
+                ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
+
+                // + difference in years * 365 */
+                + (long int)(local_year - gmt_year) * 365);
+
+            long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
+            long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
+            long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
+
+            return secs;
+        }
+    };
+
+    auto offset_seconds = helper::calculate_gmt_offset(tm);
+#else
+    auto offset_seconds = tm.tm_gmtoff;
+#endif
+
+    return static_cast<int>(offset_seconds / 60);
+#endif
+}
+
+// Return current thread id as size_t
+// It exists because the std::this_thread::get_id() is much slower(especially
+// under VS 2013)
+SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+    return static_cast<size_t>(::GetCurrentThreadId());
+#elif defined(__linux__)
+#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
+#define SYS_gettid __NR_gettid
+#endif
+    return static_cast<size_t>(::syscall(SYS_gettid));
+#elif defined(_AIX) || defined(__DragonFly__) || defined(__FreeBSD__)
+    return static_cast<size_t>(::pthread_getthreadid_np());
+#elif defined(__NetBSD__)
+    return static_cast<size_t>(::_lwp_self());
+#elif defined(__OpenBSD__)
+    return static_cast<size_t>(::getthrid());
+#elif defined(__sun)
+    return static_cast<size_t>(::thr_self());
+#elif __APPLE__
+    uint64_t tid;
+    pthread_threadid_np(nullptr, &tid);
+    return static_cast<size_t>(tid);
+#else // Default to standard C++11 (other Unix)
+    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
+#endif
+}
+
+// Return current thread id as size_t (from thread local storage)
+SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT
+{
+#if defined(SPDLOG_NO_TLS)
+    return _thread_id();
+#else // cache thread id in tls
+    static thread_local const size_t tid = _thread_id();
+    return tid;
+#endif
+}
+
+// This is avoid msvc issue in sleep_for that happens if the clock changes.
+// See https://github.com/gabime/spdlog/issues/609
+SPDLOG_INLINE void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32)
+    ::Sleep(milliseconds);
+#else
+    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+#endif
+}
+
+// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
+{
+    memory_buf_t buf;
+    wstr_to_utf8buf(filename, buf);
+    return fmt::to_string(buf);
+}
+#else
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
+{
+    return filename;
+}
+#endif
+
+SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    return static_cast<int>(::GetCurrentProcessId());
+#else
+    return static_cast<int>(::getpid());
+#endif
+}
+
+// Determine if the terminal supports colors
+// Based on: https://github.com/agauniyal/rang/
+SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+    return true;
+#else
+    static constexpr std::array<const char *, 14> terms = {
+        {"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"}};
+
+    const char *env_p = std::getenv("TERM");
+    if (env_p == nullptr)
+    {
+        return false;
+    }
+
+    static const bool result =
+        std::any_of(terms.begin(), terms.end(), [&](const char *term) { return std::strstr(env_p, term) != nullptr; });
+    return result;
+#endif
+}
+
+// Determine if the terminal attached
+// Source: https://github.com/agauniyal/rang/
+SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    return ::_isatty(_fileno(file)) != 0;
+#else
+    return ::isatty(fileno(file)) != 0;
+#endif
+}
+
+#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target)
+{
+    if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()))
+    {
+        throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8");
+    }
+
+    int wstr_size = static_cast<int>(wstr.size());
+    if (wstr_size == 0)
+    {
+        target.resize(0);
+        return;
+    }
+
+    int result_size = static_cast<int>(target.capacity());
+    if ((wstr_size + 1) * 2 > result_size)
+    {
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
+    }
+
+    if (result_size > 0)
+    {
+        target.resize(result_size);
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL);
+
+        if (result_size > 0)
+        {
+            target.resize(result_size);
+            return;
+        }
+    }
+
+    throw_spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
+}
+#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+
+// return true on success
+static SPDLOG_INLINE bool mkdir_(const filename_t &path)
+{
+#ifdef _WIN32
+#ifdef SPDLOG_WCHAR_FILENAMES
+    return ::_wmkdir(path.c_str()) == 0;
+#else
+    return ::_mkdir(path.c_str()) == 0;
+#endif
+#else
+    return ::mkdir(path.c_str(), mode_t(0755)) == 0;
+#endif
+}
+
+// create the given directory - and all directories leading to it
+// return true on success or if the directory already exists
+SPDLOG_INLINE bool create_dir(filename_t path)
+{
+    if (path_exists(path))
+    {
+        return true;
+    }
+
+    if (path.empty())
+    {
+        return false;
+    }
+
+#ifdef _WIN32
+    // support forward slash in windows
+    std::replace(path.begin(), path.end(), '/', folder_sep);
+#endif
+
+    size_t search_offset = 0;
+    do
+    {
+        auto token_pos = path.find(folder_sep, search_offset);
+        // treat the entire path as a folder if no folder separator not found
+        if (token_pos == filename_t::npos)
+        {
+            token_pos = path.size();
+        }
+
+        auto subdir = path.substr(0, token_pos);
+
+        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir))
+        {
+            return false; // return error if failed creating dir
+        }
+        search_offset = token_pos + 1;
+    } while (search_offset < path.size());
+
+    return true;
+}
+
+// Return directory name from given path or empty string
+// "abc/file" => "abc"
+// "abc/" => "abc"
+// "abc" => ""
+// "abc///" => "abc//"
+SPDLOG_INLINE filename_t dir_name(filename_t path)
+{
+#ifdef _WIN32
+    // support forward slash in windows
+    std::replace(path.begin(), path.end(), '/', folder_sep);
+#endif
+    auto pos = path.find_last_of(folder_sep);
+    return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};
+}
+
+std::string SPDLOG_INLINE getenv(const char *field)
+{
+
+#if defined(_MSC_VER)
+#if defined(__cplusplus_winrt)
+    return std::string{}; // not supported under uwp
+#else
+    size_t len = 0;
+    char buf[128];
+    bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0;
+    return ok ? buf : std::string{};
+#endif
+#else // revert to getenv
+    char *buf = ::getenv(field);
+    return buf ? buf : std::string{};
+#endif
+}
+
+} // namespace os
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/os.h

@@ -0,0 +1,111 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <ctime> // std::time_t
+
+namespace spdlog {
+namespace details {
+namespace os {
+
+SPDLOG_API spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm localtime() SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT;
+
+// eol definition
+#if !defined(SPDLOG_EOL)
+#ifdef _WIN32
+#define SPDLOG_EOL "\r\n"
+#else
+#define SPDLOG_EOL "\n"
+#endif
+#endif
+
+SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;
+
+// folder separator
+#ifdef _WIN32
+static const char folder_sep = '\\';
+#else
+SPDLOG_CONSTEXPR static const char folder_sep = '/';
+#endif
+
+// fopen_s on non windows for writing
+SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode);
+
+// Remove filename. return 0 on success
+SPDLOG_API int remove(const filename_t &filename) SPDLOG_NOEXCEPT;
+
+// Remove file if exists. return 0 on success
+// Note: Non atomic (might return failure to delete if concurrently deleted by other process/thread)
+SPDLOG_API int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT;
+
+SPDLOG_API int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT;
+
+// Return if file exists.
+SPDLOG_API bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT;
+
+// Return file size according to open FILE* object
+SPDLOG_API size_t filesize(FILE *f);
+
+// Return utc offset in minutes or throw spdlog_ex on failure
+SPDLOG_API int utc_minutes_offset(const std::tm &tm = details::os::localtime());
+
+// Return current thread id as size_t
+// It exists because the std::this_thread::get_id() is much slower(especially
+// under VS 2013)
+SPDLOG_API size_t _thread_id() SPDLOG_NOEXCEPT;
+
+// Return current thread id as size_t (from thread local storage)
+SPDLOG_API size_t thread_id() SPDLOG_NOEXCEPT;
+
+// This is avoid msvc issue in sleep_for that happens if the clock changes.
+// See https://github.com/gabime/spdlog/issues/609
+SPDLOG_API void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::string filename_to_str(const filename_t &filename);
+
+SPDLOG_API int pid() SPDLOG_NOEXCEPT;
+
+// Determine if the terminal supports colors
+// Source: https://github.com/agauniyal/rang/
+SPDLOG_API bool is_color_terminal() SPDLOG_NOEXCEPT;
+
+// Determine if the terminal attached
+// Source: https://github.com/agauniyal/rang/
+SPDLOG_API bool in_terminal(FILE *file) SPDLOG_NOEXCEPT;
+
+#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+SPDLOG_API void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target);
+#endif
+
+// Return directory name from given path or empty string
+// "abc/file" => "abc"
+// "abc/" => "abc"
+// "abc" => ""
+// "abc///" => "abc//"
+SPDLOG_API filename_t dir_name(filename_t path);
+
+// Create a dir from the given path.
+// Return true if succeeded or if this dir already exists.
+SPDLOG_API bool create_dir(filename_t path);
+
+// non thread safe, cross platform getenv/getenv_s
+// return empty string if field not found
+SPDLOG_API std::string getenv(const char *field);
+
+} // namespace os
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "os-inl.h"
+#endif

core/src/spdlog/details/periodic_worker-inl.h

@@ -0,0 +1,49 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/periodic_worker.h>
+#endif
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE periodic_worker::periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
+{
+    active_ = (interval > std::chrono::seconds::zero());
+    if (!active_)
+    {
+        return;
+    }
+
+    worker_thread_ = std::thread([this, callback_fun, interval]() {
+        for (;;)
+        {
+            std::unique_lock<std::mutex> lock(this->mutex_);
+            if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
+            {
+                return; // active_ == false, so exit this thread
+            }
+            callback_fun();
+        }
+    });
+}
+
+// stop the worker thread and join it
+SPDLOG_INLINE periodic_worker::~periodic_worker()
+{
+    if (worker_thread_.joinable())
+    {
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            active_ = false;
+        }
+        cv_.notify_one();
+        worker_thread_.join();
+    }
+}
+
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/periodic_worker.h

@@ -0,0 +1,40 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// periodic worker thread - periodically executes the given callback function.
+//
+// RAII over the owned thread:
+//    creates the thread on construction.
+//    stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first).
+
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <thread>
+namespace spdlog {
+namespace details {
+
+class SPDLOG_API periodic_worker
+{
+public:
+    periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval);
+    periodic_worker(const periodic_worker &) = delete;
+    periodic_worker &operator=(const periodic_worker &) = delete;
+    // stop the worker thread and join it
+    ~periodic_worker();
+
+private:
+    bool active_;
+    std::thread worker_thread_;
+    std::mutex mutex_;
+    std::condition_variable cv_;
+};
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "periodic_worker-inl.h"
+#endif

core/src/spdlog/details/registry-inl.h

@@ -0,0 +1,299 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/registry.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/details/periodic_worker.h>
+#include <spdlog/logger.h>
+#include <spdlog/pattern_formatter.h>
+
+#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
+// support for the default stdout color logger
+#ifdef _WIN32
+#include <spdlog/sinks/wincolor_sink.h>
+#else
+#include <spdlog/sinks/ansicolor_sink.h>
+#endif
+#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE registry::registry()
+    : formatter_(new pattern_formatter())
+{
+
+#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
+    // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
+#ifdef _WIN32
+    auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
+#else
+    auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
+#endif
+
+    const char *default_logger_name = "";
+    default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
+    loggers_[default_logger_name] = default_logger_;
+
+#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+}
+
+SPDLOG_INLINE registry::~registry() = default;
+
+SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    register_logger_(std::move(new_logger));
+}
+
+SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    new_logger->set_formatter(formatter_->clone());
+
+    if (err_handler_)
+    {
+        new_logger->set_error_handler(err_handler_);
+    }
+
+    new_logger->set_level(levels_.get(new_logger->name()));
+    new_logger->flush_on(flush_level_);
+
+    if (backtrace_n_messages_ > 0)
+    {
+        new_logger->enable_backtrace(backtrace_n_messages_);
+    }
+
+    if (automatic_registration_)
+    {
+        register_logger_(std::move(new_logger));
+    }
+}
+
+SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    auto found = loggers_.find(logger_name);
+    return found == loggers_.end() ? nullptr : found->second;
+}
+
+SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    return default_logger_;
+}
+
+// Return raw ptr to the default logger.
+// To be used directly by the spdlog default api (e.g. spdlog::info)
+// This make the default API faster, but cannot be used concurrently with set_default_logger().
+// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+SPDLOG_INLINE logger *registry::get_default_raw()
+{
+    return default_logger_.get();
+}
+
+// set default logger.
+// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    // remove previous default logger from the map
+    if (default_logger_ != nullptr)
+    {
+        loggers_.erase(default_logger_->name());
+    }
+    if (new_default_logger != nullptr)
+    {
+        loggers_[new_default_logger->name()] = new_default_logger;
+    }
+    default_logger_ = std::move(new_default_logger);
+}
+
+SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp)
+{
+    std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+    tp_ = std::move(tp);
+}
+
+SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp()
+{
+    std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+    return tp_;
+}
+
+// Set global formatter. Each sink in each logger will get a clone of this object
+SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    formatter_ = std::move(formatter);
+    for (auto &l : loggers_)
+    {
+        l.second->set_formatter(formatter_->clone());
+    }
+}
+
+SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    backtrace_n_messages_ = n_messages;
+
+    for (auto &l : loggers_)
+    {
+        l.second->enable_backtrace(n_messages);
+    }
+}
+
+SPDLOG_INLINE void registry::disable_backtrace()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    backtrace_n_messages_ = 0;
+    for (auto &l : loggers_)
+    {
+        l.second->disable_backtrace();
+    }
+}
+
+SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->set_level(log_level);
+    }
+    levels_.set_default(log_level);
+}
+
+SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->flush_on(log_level);
+    }
+    flush_level_ = log_level;
+}
+
+SPDLOG_INLINE void registry::flush_every(std::chrono::seconds interval)
+{
+    std::lock_guard<std::mutex> lock(flusher_mutex_);
+    auto clbk = [this]() { this->flush_all(); };
+    periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
+}
+
+SPDLOG_INLINE void registry::set_error_handler(void (*handler)(const std::string &msg))
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->set_error_handler(handler);
+    }
+    err_handler_ = handler;
+}
+
+SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        fun(l.second);
+    }
+}
+
+SPDLOG_INLINE void registry::flush_all()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->flush();
+    }
+}
+
+SPDLOG_INLINE void registry::drop(const std::string &logger_name)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    loggers_.erase(logger_name);
+    if (default_logger_ && default_logger_->name() == logger_name)
+    {
+        default_logger_.reset();
+    }
+}
+
+SPDLOG_INLINE void registry::drop_all()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    loggers_.clear();
+    default_logger_.reset();
+}
+
+// clean all resources and threads started by the registry
+SPDLOG_INLINE void registry::shutdown()
+{
+    {
+        std::lock_guard<std::mutex> lock(flusher_mutex_);
+        periodic_flusher_.reset();
+    }
+
+    drop_all();
+
+    {
+        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+        tp_.reset();
+    }
+}
+
+SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex()
+{
+    return tp_mutex_;
+}
+
+SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    automatic_registration_ = automatic_registration;
+}
+
+SPDLOG_INLINE void registry::update_levels(cfg::log_levels levels)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    levels_ = std::move(levels);
+    for (auto &l : loggers_)
+    {
+        auto &logger = l.second;
+        logger->set_level(levels_.get(logger->name()));
+    }
+}
+
+SPDLOG_INLINE registry &registry::instance()
+{
+    static registry s_instance;
+    return s_instance;
+}
+
+SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
+{
+    if (loggers_.find(logger_name) != loggers_.end())
+    {
+        throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
+    }
+}
+
+SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger)
+{
+    auto logger_name = new_logger->name();
+    throw_if_exists_(logger_name);
+    loggers_[logger_name] = std::move(new_logger);
+}
+
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/registry.h

@@ -0,0 +1,112 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Loggers registry of unique name->logger pointer
+// An attempt to create a logger with an already existing name will result with spdlog_ex exception.
+// If user requests a non existing logger, nullptr will be returned
+// This class is thread safe
+
+#include <spdlog/common.h>
+#include <spdlog/cfg/log_levels.h>
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <mutex>
+
+namespace spdlog {
+class logger;
+
+namespace details {
+class thread_pool;
+class periodic_worker;
+
+class SPDLOG_API registry
+{
+public:
+    registry(const registry &) = delete;
+    registry &operator=(const registry &) = delete;
+
+    void register_logger(std::shared_ptr<logger> new_logger);
+    void initialize_logger(std::shared_ptr<logger> new_logger);
+    std::shared_ptr<logger> get(const std::string &logger_name);
+    std::shared_ptr<logger> default_logger();
+
+    // Return raw ptr to the default logger.
+    // To be used directly by the spdlog default api (e.g. spdlog::info)
+    // This make the default API faster, but cannot be used concurrently with set_default_logger().
+    // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+    logger *get_default_raw();
+
+    // set default logger.
+    // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+    void set_default_logger(std::shared_ptr<logger> new_default_logger);
+
+    void set_tp(std::shared_ptr<thread_pool> tp);
+
+    std::shared_ptr<thread_pool> get_tp();
+
+    // Set global formatter. Each sink in each logger will get a clone of this object
+    void set_formatter(std::unique_ptr<formatter> formatter);
+
+    void enable_backtrace(size_t n_messages);
+
+    void disable_backtrace();
+
+    void set_level(level::level_enum log_level);
+
+    void flush_on(level::level_enum log_level);
+
+    void flush_every(std::chrono::seconds interval);
+
+    void set_error_handler(void (*handler)(const std::string &msg));
+
+    void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
+
+    void flush_all();
+
+    void drop(const std::string &logger_name);
+
+    void drop_all();
+
+    // clean all resources and threads started by the registry
+    void shutdown();
+
+    std::recursive_mutex &tp_mutex();
+
+    void set_automatic_registration(bool automatic_registration);
+
+    void update_levels(cfg::log_levels levels);
+
+    static registry &instance();
+
+private:
+    registry();
+    ~registry();
+
+    void throw_if_exists_(const std::string &logger_name);
+    void register_logger_(std::shared_ptr<logger> new_logger);
+    std::mutex logger_map_mutex_, flusher_mutex_;
+    std::recursive_mutex tp_mutex_;
+    std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
+    cfg::log_levels levels_;
+    std::unique_ptr<formatter> formatter_;
+    level::level_enum flush_level_ = level::off;
+    void (*err_handler_)(const std::string &msg);
+    std::shared_ptr<thread_pool> tp_;
+    std::unique_ptr<periodic_worker> periodic_flusher_;
+    std::shared_ptr<logger> default_logger_;
+    bool automatic_registration_ = true;
+    size_t backtrace_n_messages_ = 0;
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "registry-inl.h"
+#endif

core/src/spdlog/details/synchronous_factory.h

@@ -0,0 +1,24 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include "registry.h"
+
+namespace spdlog {
+
+// Default logger factory-  creates synchronous loggers
+class logger;
+
+struct synchronous_factory
+{
+    template<typename Sink, typename... SinkArgs>
+    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
+    {
+        auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
+        auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
+        details::registry::instance().initialize_logger(new_logger);
+        return new_logger;
+    }
+};
+} // namespace spdlog

core/src/spdlog/details/tcp_client-windows.h

@@ -0,0 +1,175 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#define WIN32_LEAN_AND_MEAN
+// tcp client helper
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+#include <windows.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
+
+#pragma comment(lib, "Ws2_32.lib")
+#pragma comment(lib, "Mswsock.lib")
+#pragma comment(lib, "AdvApi32.lib")
+
+namespace spdlog {
+namespace details {
+class tcp_client
+{
+    SOCKET socket_ = INVALID_SOCKET;
+
+    static bool winsock_initialized_()
+    {
+        SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+        if (s == INVALID_SOCKET)
+        {
+            return false;
+        }
+        else
+        {
+            closesocket(s);
+            return true;
+        }
+    }
+
+    static void init_winsock_()
+    {
+        WSADATA wsaData;
+        auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData);
+        if (rv != 0)
+        {
+            throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
+        }
+    }
+
+    static void throw_winsock_error_(const std::string &msg, int last_error)
+    {
+        char buf[512];
+        ::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
+
+        throw_spdlog_ex(fmt::format("tcp_sink - {}: {}", msg, buf));
+    }
+
+public:
+    bool is_connected() const
+    {
+        return socket_ != INVALID_SOCKET;
+    }
+
+    void close()
+    {
+        ::closesocket(socket_);
+        socket_ = INVALID_SOCKET;
+        WSACleanup();
+    }
+
+    SOCKET fd() const
+    {
+        return socket_;
+    }
+
+    ~tcp_client()
+    {
+        close();
+    }
+
+    // try to connect or throw on failure
+    void connect(const std::string &host, int port)
+    {
+        // initialize winsock if needed
+        if (!winsock_initialized_())
+        {
+            init_winsock_();
+        }
+
+        if (is_connected())
+        {
+            close();
+        }
+        struct addrinfo hints
+        {};
+        ZeroMemory(&hints, sizeof(hints));
+
+        hints.ai_family = AF_INET;       // IPv4
+        hints.ai_socktype = SOCK_STREAM; // TCP
+        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_protocol = 0;
+
+        auto port_str = std::to_string(port);
+        struct addrinfo *addrinfo_result;
+        auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
+        int last_error = 0;
+        if (rv != 0)
+        {
+            last_error = ::WSAGetLastError();
+            WSACleanup();
+            throw_winsock_error_("getaddrinfo failed", last_error);
+        }
+
+        // Try each address until we successfully connect(2).
+
+        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
+        {
+            socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+            if (socket_ == INVALID_SOCKET)
+            {
+                last_error = ::WSAGetLastError();
+                WSACleanup();
+                continue;
+            }
+            if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0)
+            {
+                break;
+            }
+            else
+            {
+                last_error = ::WSAGetLastError();
+                close();
+            }
+        }
+        ::freeaddrinfo(addrinfo_result);
+        if (socket_ == INVALID_SOCKET)
+        {
+            WSACleanup();
+            throw_winsock_error_("connect failed", last_error);
+        }
+
+        // set TCP_NODELAY
+        int enable_flag = 1;
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, (char *)&enable_flag, sizeof(enable_flag));
+    }
+
+    // Send exactly n_bytes of the given data.
+    // On error close the connection and throw.
+    void send(const char *data, size_t n_bytes)
+    {
+        size_t bytes_sent = 0;
+        while (bytes_sent < n_bytes)
+        {
+            const int send_flags = 0;
+            auto write_result = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);
+            if (write_result == SOCKET_ERROR)
+            {
+                int last_error = ::WSAGetLastError();
+                close();
+                throw_winsock_error_("send failed", last_error);
+            }
+
+            if (write_result == 0) // (probably should not happen but in any case..)
+            {
+                break;
+            }
+            bytes_sent += static_cast<size_t>(write_result);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/tcp_client.h

@@ -0,0 +1,145 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifdef _WIN32
+#error include tcp_client-windows.h instead
+#endif
+
+// tcp client helper
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <netinet/tcp.h>
+
+#include <string>
+
+namespace spdlog {
+namespace details {
+class tcp_client
+{
+    int socket_ = -1;
+
+public:
+    bool is_connected() const
+    {
+        return socket_ != -1;
+    }
+
+    void close()
+    {
+        if (is_connected())
+        {
+            ::close(socket_);
+            socket_ = -1;
+        }
+    }
+
+    int fd() const
+    {
+        return socket_;
+    }
+
+    ~tcp_client()
+    {
+        close();
+    }
+
+    // try to connect or throw on failure
+    void connect(const std::string &host, int port)
+    {
+        close();
+        struct addrinfo hints
+        {};
+        memset(&hints, 0, sizeof(struct addrinfo));
+        hints.ai_family = AF_INET;       // IPv4
+        hints.ai_socktype = SOCK_STREAM; // TCP
+        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_protocol = 0;
+
+        auto port_str = std::to_string(port);
+        struct addrinfo *addrinfo_result;
+        auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
+        if (rv != 0)
+        {
+            auto msg = fmt::format("::getaddrinfo failed: {}", gai_strerror(rv));
+            throw_spdlog_ex(msg);
+        }
+
+        // Try each address until we successfully connect(2).
+        int last_errno = 0;
+        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
+        {
+            int const flags = SOCK_CLOEXEC;
+            socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol);
+            if (socket_ == -1)
+            {
+                last_errno = errno;
+                continue;
+            }
+            rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen);
+            if (rv == 0)
+            {
+                break;
+            }
+            else
+            {
+                last_errno = errno;
+                ::close(socket_);
+                socket_ = -1;
+            }
+        }
+        ::freeaddrinfo(addrinfo_result);
+        if (socket_ == -1)
+        {
+            throw_spdlog_ex("::connect failed", last_errno);
+        }
+
+        // set TCP_NODELAY
+        int enable_flag = 1;
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, (char *)&enable_flag, sizeof(enable_flag));
+
+        // prevent sigpipe on systems where MSG_NOSIGNAL is not available
+#if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
+        ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, (char *)&enable_flag, sizeof(enable_flag));
+#endif
+
+#if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
+#error "tcp_sink would raise SIGPIPE since niether SO_NOSIGPIPE nor MSG_NOSIGNAL are available"
+#endif
+    }
+
+    // Send exactly n_bytes of the given data.
+    // On error close the connection and throw.
+    void send(const char *data, size_t n_bytes)
+    {
+        size_t bytes_sent = 0;
+        while (bytes_sent < n_bytes)
+        {
+#if defined(MSG_NOSIGNAL)
+            const int send_flags = MSG_NOSIGNAL;
+#else
+            const int send_flags = 0;
+#endif
+            auto write_result = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);
+            if (write_result < 0)
+            {
+                close();
+                throw_spdlog_ex("write(2) failed", errno);
+            }
+
+            if (write_result == 0) // (probably should not happen but in any case..)
+            {
+                break;
+            }
+            bytes_sent += static_cast<size_t>(write_result);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/thread_pool-inl.h

@@ -0,0 +1,124 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/thread_pool.h>
+#endif
+
+#include <spdlog/common.h>
+#include <cassert>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
+    : q_(q_max_items)
+{
+    if (threads_n == 0 || threads_n > 1000)
+    {
+        throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
+                        "range is 1-1000)");
+    }
+    for (size_t i = 0; i < threads_n; i++)
+    {
+        threads_.emplace_back([this, on_thread_start] {
+            on_thread_start();
+            this->thread_pool::worker_loop_();
+        });
+    }
+}
+
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
+    : thread_pool(q_max_items, threads_n, [] {})
+{}
+
+// message all threads to terminate gracefully join them
+SPDLOG_INLINE thread_pool::~thread_pool()
+{
+    SPDLOG_TRY
+    {
+        for (size_t i = 0; i < threads_.size(); i++)
+        {
+            post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
+        }
+
+        for (auto &t : threads_)
+        {
+            t.join();
+        }
+    }
+    SPDLOG_CATCH_ALL() {}
+}
+
+void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy)
+{
+    async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
+    post_async_msg_(std::move(async_m), overflow_policy);
+}
+
+void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
+{
+    post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
+}
+
+size_t SPDLOG_INLINE thread_pool::overrun_counter()
+{
+    return q_.overrun_counter();
+}
+
+void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
+{
+    if (overflow_policy == async_overflow_policy::block)
+    {
+        q_.enqueue(std::move(new_msg));
+    }
+    else
+    {
+        q_.enqueue_nowait(std::move(new_msg));
+    }
+}
+
+void SPDLOG_INLINE thread_pool::worker_loop_()
+{
+    while (process_next_msg_()) {}
+}
+
+// process next message in the queue
+// return true if this thread should still be active (while no terminate msg
+// was received)
+bool SPDLOG_INLINE thread_pool::process_next_msg_()
+{
+    async_msg incoming_async_msg;
+    bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
+    if (!dequeued)
+    {
+        return true;
+    }
+
+    switch (incoming_async_msg.msg_type)
+    {
+    case async_msg_type::log: {
+        incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
+        return true;
+    }
+    case async_msg_type::flush: {
+        incoming_async_msg.worker_ptr->backend_flush_();
+        return true;
+    }
+
+    case async_msg_type::terminate: {
+        return false;
+    }
+
+    default: {
+        assert(false);
+    }
+    }
+
+    return true;
+}
+
+} // namespace details
+} // namespace spdlog

core/src/spdlog/details/thread_pool.h

@@ -0,0 +1,120 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg_buffer.h>
+#include <spdlog/details/mpmc_blocking_q.h>
+#include <spdlog/details/os.h>
+
+#include <chrono>
+#include <memory>
+#include <thread>
+#include <vector>
+#include <functional>
+
+namespace spdlog {
+class async_logger;
+
+namespace details {
+
+using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
+
+enum class async_msg_type
+{
+    log,
+    flush,
+    terminate
+};
+
+#include <spdlog/details/log_msg_buffer.h>
+// Async msg to move to/from the queue
+// Movable only. should never be copied
+struct async_msg : log_msg_buffer
+{
+    async_msg_type msg_type{async_msg_type::log};
+    async_logger_ptr worker_ptr;
+
+    async_msg() = default;
+    ~async_msg() = default;
+
+    // should only be moved in or out of the queue..
+    async_msg(const async_msg &) = delete;
+
+// support for vs2013 move
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+    async_msg(async_msg &&other)
+        : log_msg_buffer(std::move(other))
+        , msg_type(other.msg_type)
+        , worker_ptr(std::move(other.worker_ptr))
+    {}
+
+    async_msg &operator=(async_msg &&other)
+    {
+        *static_cast<log_msg_buffer *>(this) = std::move(other);
+        msg_type = other.msg_type;
+        worker_ptr = std::move(other.worker_ptr);
+        return *this;
+    }
+#else // (_MSC_VER) && _MSC_VER <= 1800
+    async_msg(async_msg &&) = default;
+    async_msg &operator=(async_msg &&) = default;
+#endif
+
+    // construct from log_msg with given type
+    async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)
+        : log_msg_buffer{m}
+        , msg_type{the_type}
+        , worker_ptr{std::move(worker)}
+    {}
+
+    async_msg(async_logger_ptr &&worker, async_msg_type the_type)
+        : log_msg_buffer{}
+        , msg_type{the_type}
+        , worker_ptr{std::move(worker)}
+    {}
+
+    explicit async_msg(async_msg_type the_type)
+        : async_msg{nullptr, the_type}
+    {}
+};
+
+class SPDLOG_API thread_pool
+{
+public:
+    using item_type = async_msg;
+    using q_type = details::mpmc_blocking_queue<item_type>;
+
+    thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start);
+    thread_pool(size_t q_max_items, size_t threads_n);
+
+    // message all threads to terminate gracefully join them
+    ~thread_pool();
+
+    thread_pool(const thread_pool &) = delete;
+    thread_pool &operator=(thread_pool &&) = delete;
+
+    void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);
+    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
+    size_t overrun_counter();
+
+private:
+    q_type q_;
+
+    std::vector<std::thread> threads_;
+
+    void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy);
+    void worker_loop_();
+
+    // process next message in the queue
+    // return true if this thread should still be active (while no terminate msg
+    // was received)
+    bool process_next_msg_();
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "thread_pool-inl.h"
+#endif

core/src/spdlog/details/windows_include.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#ifndef NOMINMAX
+#define NOMINMAX // prevent windows redefining min/max
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>

core/src/spdlog/fmt/bin_to_hex.h

@@ -0,0 +1,216 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#include <cctype>
+
+//
+// Support for logging binary data as hex
+// format flags:
+// {:X} - print in uppercase.
+// {:s} - don't separate each byte with space.
+// {:p} - don't print the position on each line start.
+// {:n} - don't split the output to lines.
+// {:a} - show ASCII if :n is not set
+
+//
+// Examples:
+//
+// std::vector<char> v(200, 0x0b);
+// logger->info("Some buffer {}", spdlog::to_hex(v));
+// char buf[128];
+// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf)));
+// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf), 16));
+
+namespace spdlog {
+namespace details {
+
+template<typename It>
+class dump_info
+{
+public:
+    dump_info(It range_begin, It range_end, size_t size_per_line)
+        : begin_(range_begin)
+        , end_(range_end)
+        , size_per_line_(size_per_line)
+    {}
+
+    It begin() const
+    {
+        return begin_;
+    }
+    It end() const
+    {
+        return end_;
+    }
+    size_t size_per_line() const
+    {
+        return size_per_line_;
+    }
+
+private:
+    It begin_, end_;
+    size_t size_per_line_;
+};
+} // namespace details
+
+// create a dump_info that wraps the given container
+template<typename Container>
+inline details::dump_info<typename Container::const_iterator> to_hex(const Container &container, size_t size_per_line = 32)
+{
+    static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1");
+    using Iter = typename Container::const_iterator;
+    return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
+}
+
+// create dump_info from ranges
+template<typename It>
+inline details::dump_info<It> to_hex(const It range_begin, const It range_end, size_t size_per_line = 32)
+{
+    return details::dump_info<It>(range_begin, range_end, size_per_line);
+}
+
+} // namespace spdlog
+
+namespace fmt {
+
+template<typename T>
+struct formatter<spdlog::details::dump_info<T>>
+{
+    const char delimiter = ' ';
+    bool put_newlines = true;
+    bool put_delimiters = true;
+    bool use_uppercase = false;
+    bool put_positions = true; // position on start of each line
+    bool show_ascii = false;
+
+    // parse the format string flags
+    template<typename ParseContext>
+    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        auto it = ctx.begin();
+        while (it != ctx.end() && *it != '}')
+        {
+            switch (*it)
+            {
+            case 'X':
+                use_uppercase = true;
+                break;
+            case 's':
+                put_delimiters = false;
+                break;
+            case 'p':
+                put_positions = false;
+                break;
+            case 'n':
+                put_newlines = false;
+                show_ascii = false;
+                break;
+            case 'a':
+                if (put_newlines)
+                {
+                    show_ascii = true;
+                }
+                break;
+            }
+
+            ++it;
+        }
+        return it;
+    }
+
+    // format the given bytes range as hex
+    template<typename FormatContext, typename Container>
+    auto format(const spdlog::details::dump_info<Container> &the_range, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF";
+        SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef";
+        const char *hex_chars = use_uppercase ? hex_upper : hex_lower;
+
+#if FMT_VERSION < 60000
+        auto inserter = ctx.begin();
+#else
+        auto inserter = ctx.out();
+#endif
+
+        int size_per_line = static_cast<int>(the_range.size_per_line());
+        auto start_of_line = the_range.begin();
+        for (auto i = the_range.begin(); i != the_range.end(); i++)
+        {
+            auto ch = static_cast<unsigned char>(*i);
+
+            if (put_newlines && (i == the_range.begin() || i - start_of_line >= size_per_line))
+            {
+                if (show_ascii && i != the_range.begin())
+                {
+                    *inserter++ = delimiter;
+                    *inserter++ = delimiter;
+                    for (auto j = start_of_line; j < i; j++)
+                    {
+                        auto pc = static_cast<unsigned char>(*j);
+                        *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
+                    }
+                }
+
+                put_newline(inserter, static_cast<size_t>(i - the_range.begin()));
+
+                // put first byte without delimiter in front of it
+                *inserter++ = hex_chars[(ch >> 4) & 0x0f];
+                *inserter++ = hex_chars[ch & 0x0f];
+                start_of_line = i;
+                continue;
+            }
+
+            if (put_delimiters)
+            {
+                *inserter++ = delimiter;
+            }
+
+            *inserter++ = hex_chars[(ch >> 4) & 0x0f];
+            *inserter++ = hex_chars[ch & 0x0f];
+        }
+        if (show_ascii) // add ascii to last line
+        {
+            if (the_range.end() - the_range.begin() > size_per_line)
+            {
+                auto blank_num = size_per_line - (the_range.end() - start_of_line);
+                while (blank_num-- > 0)
+                {
+                    *inserter++ = delimiter;
+                    *inserter++ = delimiter;
+                    if (put_delimiters)
+                    {
+                        *inserter++ = delimiter;
+                    }
+                }
+            }
+            *inserter++ = delimiter;
+            *inserter++ = delimiter;
+            for (auto j = start_of_line; j != the_range.end(); j++)
+            {
+                auto pc = static_cast<unsigned char>(*j);
+                *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
+            }
+        }
+        return inserter;
+    }
+
+    // put newline(and position header)
+    template<typename It>
+    void put_newline(It inserter, std::size_t pos)
+    {
+#ifdef _WIN32
+        *inserter++ = '\r';
+#endif
+        *inserter++ = '\n';
+
+        if (put_positions)
+        {
+            fmt::format_to(inserter, "{:<04X}: ", pos);
+        }
+    }
+};
+} // namespace fmt

core/src/spdlog/fmt/bundled/LICENSE.rst

@@ -0,0 +1,27 @@
+Copyright (c) 2012 - present, Victor Zverovich
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+--- Optional exception to the license ---
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into a machine-executable object form of such
+source code, you may redistribute such embedded portions in such object form
+without including the above copyright and permission notices.

core/src/spdlog/fmt/bundled/color.h

@@ -0,0 +1,568 @@
+// Formatting library for C++ - color support
+//
+// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COLOR_H_
+#define FMT_COLOR_H_
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+enum class color : uint32_t {
+  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
+  antique_white = 0xFAEBD7,            // rgb(250,235,215)
+  aqua = 0x00FFFF,                     // rgb(0,255,255)
+  aquamarine = 0x7FFFD4,               // rgb(127,255,212)
+  azure = 0xF0FFFF,                    // rgb(240,255,255)
+  beige = 0xF5F5DC,                    // rgb(245,245,220)
+  bisque = 0xFFE4C4,                   // rgb(255,228,196)
+  black = 0x000000,                    // rgb(0,0,0)
+  blanched_almond = 0xFFEBCD,          // rgb(255,235,205)
+  blue = 0x0000FF,                     // rgb(0,0,255)
+  blue_violet = 0x8A2BE2,              // rgb(138,43,226)
+  brown = 0xA52A2A,                    // rgb(165,42,42)
+  burly_wood = 0xDEB887,               // rgb(222,184,135)
+  cadet_blue = 0x5F9EA0,               // rgb(95,158,160)
+  chartreuse = 0x7FFF00,               // rgb(127,255,0)
+  chocolate = 0xD2691E,                // rgb(210,105,30)
+  coral = 0xFF7F50,                    // rgb(255,127,80)
+  cornflower_blue = 0x6495ED,          // rgb(100,149,237)
+  cornsilk = 0xFFF8DC,                 // rgb(255,248,220)
+  crimson = 0xDC143C,                  // rgb(220,20,60)
+  cyan = 0x00FFFF,                     // rgb(0,255,255)
+  dark_blue = 0x00008B,                // rgb(0,0,139)
+  dark_cyan = 0x008B8B,                // rgb(0,139,139)
+  dark_golden_rod = 0xB8860B,          // rgb(184,134,11)
+  dark_gray = 0xA9A9A9,                // rgb(169,169,169)
+  dark_green = 0x006400,               // rgb(0,100,0)
+  dark_khaki = 0xBDB76B,               // rgb(189,183,107)
+  dark_magenta = 0x8B008B,             // rgb(139,0,139)
+  dark_olive_green = 0x556B2F,         // rgb(85,107,47)
+  dark_orange = 0xFF8C00,              // rgb(255,140,0)
+  dark_orchid = 0x9932CC,              // rgb(153,50,204)
+  dark_red = 0x8B0000,                 // rgb(139,0,0)
+  dark_salmon = 0xE9967A,              // rgb(233,150,122)
+  dark_sea_green = 0x8FBC8F,           // rgb(143,188,143)
+  dark_slate_blue = 0x483D8B,          // rgb(72,61,139)
+  dark_slate_gray = 0x2F4F4F,          // rgb(47,79,79)
+  dark_turquoise = 0x00CED1,           // rgb(0,206,209)
+  dark_violet = 0x9400D3,              // rgb(148,0,211)
+  deep_pink = 0xFF1493,                // rgb(255,20,147)
+  deep_sky_blue = 0x00BFFF,            // rgb(0,191,255)
+  dim_gray = 0x696969,                 // rgb(105,105,105)
+  dodger_blue = 0x1E90FF,              // rgb(30,144,255)
+  fire_brick = 0xB22222,               // rgb(178,34,34)
+  floral_white = 0xFFFAF0,             // rgb(255,250,240)
+  forest_green = 0x228B22,             // rgb(34,139,34)
+  fuchsia = 0xFF00FF,                  // rgb(255,0,255)
+  gainsboro = 0xDCDCDC,                // rgb(220,220,220)
+  ghost_white = 0xF8F8FF,              // rgb(248,248,255)
+  gold = 0xFFD700,                     // rgb(255,215,0)
+  golden_rod = 0xDAA520,               // rgb(218,165,32)
+  gray = 0x808080,                     // rgb(128,128,128)
+  green = 0x008000,                    // rgb(0,128,0)
+  green_yellow = 0xADFF2F,             // rgb(173,255,47)
+  honey_dew = 0xF0FFF0,                // rgb(240,255,240)
+  hot_pink = 0xFF69B4,                 // rgb(255,105,180)
+  indian_red = 0xCD5C5C,               // rgb(205,92,92)
+  indigo = 0x4B0082,                   // rgb(75,0,130)
+  ivory = 0xFFFFF0,                    // rgb(255,255,240)
+  khaki = 0xF0E68C,                    // rgb(240,230,140)
+  lavender = 0xE6E6FA,                 // rgb(230,230,250)
+  lavender_blush = 0xFFF0F5,           // rgb(255,240,245)
+  lawn_green = 0x7CFC00,               // rgb(124,252,0)
+  lemon_chiffon = 0xFFFACD,            // rgb(255,250,205)
+  light_blue = 0xADD8E6,               // rgb(173,216,230)
+  light_coral = 0xF08080,              // rgb(240,128,128)
+  light_cyan = 0xE0FFFF,               // rgb(224,255,255)
+  light_golden_rod_yellow = 0xFAFAD2,  // rgb(250,250,210)
+  light_gray = 0xD3D3D3,               // rgb(211,211,211)
+  light_green = 0x90EE90,              // rgb(144,238,144)
+  light_pink = 0xFFB6C1,               // rgb(255,182,193)
+  light_salmon = 0xFFA07A,             // rgb(255,160,122)
+  light_sea_green = 0x20B2AA,          // rgb(32,178,170)
+  light_sky_blue = 0x87CEFA,           // rgb(135,206,250)
+  light_slate_gray = 0x778899,         // rgb(119,136,153)
+  light_steel_blue = 0xB0C4DE,         // rgb(176,196,222)
+  light_yellow = 0xFFFFE0,             // rgb(255,255,224)
+  lime = 0x00FF00,                     // rgb(0,255,0)
+  lime_green = 0x32CD32,               // rgb(50,205,50)
+  linen = 0xFAF0E6,                    // rgb(250,240,230)
+  magenta = 0xFF00FF,                  // rgb(255,0,255)
+  maroon = 0x800000,                   // rgb(128,0,0)
+  medium_aquamarine = 0x66CDAA,        // rgb(102,205,170)
+  medium_blue = 0x0000CD,              // rgb(0,0,205)
+  medium_orchid = 0xBA55D3,            // rgb(186,85,211)
+  medium_purple = 0x9370DB,            // rgb(147,112,219)
+  medium_sea_green = 0x3CB371,         // rgb(60,179,113)
+  medium_slate_blue = 0x7B68EE,        // rgb(123,104,238)
+  medium_spring_green = 0x00FA9A,      // rgb(0,250,154)
+  medium_turquoise = 0x48D1CC,         // rgb(72,209,204)
+  medium_violet_red = 0xC71585,        // rgb(199,21,133)
+  midnight_blue = 0x191970,            // rgb(25,25,112)
+  mint_cream = 0xF5FFFA,               // rgb(245,255,250)
+  misty_rose = 0xFFE4E1,               // rgb(255,228,225)
+  moccasin = 0xFFE4B5,                 // rgb(255,228,181)
+  navajo_white = 0xFFDEAD,             // rgb(255,222,173)
+  navy = 0x000080,                     // rgb(0,0,128)
+  old_lace = 0xFDF5E6,                 // rgb(253,245,230)
+  olive = 0x808000,                    // rgb(128,128,0)
+  olive_drab = 0x6B8E23,               // rgb(107,142,35)
+  orange = 0xFFA500,                   // rgb(255,165,0)
+  orange_red = 0xFF4500,               // rgb(255,69,0)
+  orchid = 0xDA70D6,                   // rgb(218,112,214)
+  pale_golden_rod = 0xEEE8AA,          // rgb(238,232,170)
+  pale_green = 0x98FB98,               // rgb(152,251,152)
+  pale_turquoise = 0xAFEEEE,           // rgb(175,238,238)
+  pale_violet_red = 0xDB7093,          // rgb(219,112,147)
+  papaya_whip = 0xFFEFD5,              // rgb(255,239,213)
+  peach_puff = 0xFFDAB9,               // rgb(255,218,185)
+  peru = 0xCD853F,                     // rgb(205,133,63)
+  pink = 0xFFC0CB,                     // rgb(255,192,203)
+  plum = 0xDDA0DD,                     // rgb(221,160,221)
+  powder_blue = 0xB0E0E6,              // rgb(176,224,230)
+  purple = 0x800080,                   // rgb(128,0,128)
+  rebecca_purple = 0x663399,           // rgb(102,51,153)
+  red = 0xFF0000,                      // rgb(255,0,0)
+  rosy_brown = 0xBC8F8F,               // rgb(188,143,143)
+  royal_blue = 0x4169E1,               // rgb(65,105,225)
+  saddle_brown = 0x8B4513,             // rgb(139,69,19)
+  salmon = 0xFA8072,                   // rgb(250,128,114)
+  sandy_brown = 0xF4A460,              // rgb(244,164,96)
+  sea_green = 0x2E8B57,                // rgb(46,139,87)
+  sea_shell = 0xFFF5EE,                // rgb(255,245,238)
+  sienna = 0xA0522D,                   // rgb(160,82,45)
+  silver = 0xC0C0C0,                   // rgb(192,192,192)
+  sky_blue = 0x87CEEB,                 // rgb(135,206,235)
+  slate_blue = 0x6A5ACD,               // rgb(106,90,205)
+  slate_gray = 0x708090,               // rgb(112,128,144)
+  snow = 0xFFFAFA,                     // rgb(255,250,250)
+  spring_green = 0x00FF7F,             // rgb(0,255,127)
+  steel_blue = 0x4682B4,               // rgb(70,130,180)
+  tan = 0xD2B48C,                      // rgb(210,180,140)
+  teal = 0x008080,                     // rgb(0,128,128)
+  thistle = 0xD8BFD8,                  // rgb(216,191,216)
+  tomato = 0xFF6347,                   // rgb(255,99,71)
+  turquoise = 0x40E0D0,                // rgb(64,224,208)
+  violet = 0xEE82EE,                   // rgb(238,130,238)
+  wheat = 0xF5DEB3,                    // rgb(245,222,179)
+  white = 0xFFFFFF,                    // rgb(255,255,255)
+  white_smoke = 0xF5F5F5,              // rgb(245,245,245)
+  yellow = 0xFFFF00,                   // rgb(255,255,0)
+  yellow_green = 0x9ACD32              // rgb(154,205,50)
+};                                     // enum class color
+
+enum class terminal_color : uint8_t {
+  black = 30,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  bright_black = 90,
+  bright_red,
+  bright_green,
+  bright_yellow,
+  bright_blue,
+  bright_magenta,
+  bright_cyan,
+  bright_white
+};
+
+enum class emphasis : uint8_t {
+  bold = 1,
+  italic = 1 << 1,
+  underline = 1 << 2,
+  strikethrough = 1 << 3
+};
+
+// rgb is a struct for red, green and blue colors.
+// Using the name "rgb" makes some editors show the color in a tooltip.
+struct rgb {
+  FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
+  FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
+  FMT_CONSTEXPR rgb(uint32_t hex)
+      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
+  FMT_CONSTEXPR rgb(color hex)
+      : r((uint32_t(hex) >> 16) & 0xFF),
+        g((uint32_t(hex) >> 8) & 0xFF),
+        b(uint32_t(hex) & 0xFF) {}
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+};
+
+namespace internal {
+
+// color is a struct of either a rgb color or a terminal color.
+struct color_type {
+  FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
+  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
+                                                           value{} {
+    value.rgb_color = static_cast<uint32_t>(rgb_color);
+  }
+  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
+    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
+                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
+  }
+  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
+                                                                     value{} {
+    value.term_color = static_cast<uint8_t>(term_color);
+  }
+  bool is_rgb;
+  union color_union {
+    uint8_t term_color;
+    uint32_t rgb_color;
+  } value;
+};
+}  // namespace internal
+
+// Experimental text formatting support.
+class text_style {
+ public:
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
+      : set_foreground_color(),
+        set_background_color(),
+        ems(em) {}
+
+  FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
+                                            const text_style& rhs) {
+    return lhs |= rhs;
+  }
+
+  FMT_CONSTEXPR text_style& operator&=(const text_style& rhs) {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't AND a terminal color"));
+      foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't AND a terminal color"));
+      background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR text_style operator&(text_style lhs,
+                                            const text_style& rhs) {
+    return lhs &= rhs;
+  }
+
+  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
+    return set_foreground_color;
+  }
+  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
+    return set_background_color;
+  }
+  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
+    return static_cast<uint8_t>(ems) != 0;
+  }
+  FMT_CONSTEXPR internal::color_type get_foreground() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
+    return foreground_color;
+  }
+  FMT_CONSTEXPR internal::color_type get_background() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_background(), "no background specified for this style");
+    return background_color;
+  }
+  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
+    return ems;
+  }
+
+ private:
+  FMT_CONSTEXPR text_style(bool is_foreground,
+                           internal::color_type text_color) FMT_NOEXCEPT
+      : set_foreground_color(),
+        set_background_color(),
+        ems() {
+    if (is_foreground) {
+      foreground_color = text_color;
+      set_foreground_color = true;
+    } else {
+      background_color = text_color;
+      set_background_color = true;
+    }
+  }
+
+  friend FMT_CONSTEXPR_DECL text_style fg(internal::color_type foreground)
+      FMT_NOEXCEPT;
+  friend FMT_CONSTEXPR_DECL text_style bg(internal::color_type background)
+      FMT_NOEXCEPT;
+
+  internal::color_type foreground_color;
+  internal::color_type background_color;
+  bool set_foreground_color;
+  bool set_background_color;
+  emphasis ems;
+};
+
+FMT_CONSTEXPR text_style fg(internal::color_type foreground) FMT_NOEXCEPT {
+  return text_style(/*is_foreground=*/true, foreground);
+}
+
+FMT_CONSTEXPR text_style bg(internal::color_type background) FMT_NOEXCEPT {
+  return text_style(/*is_foreground=*/false, background);
+}
+
+FMT_CONSTEXPR text_style operator|(emphasis lhs, emphasis rhs) FMT_NOEXCEPT {
+  return text_style(lhs) | rhs;
+}
+
+namespace internal {
+
+template <typename Char> struct ansi_color_escape {
+  FMT_CONSTEXPR ansi_color_escape(internal::color_type text_color,
+                                  const char* esc) FMT_NOEXCEPT {
+    // If we have a terminal color, we need to output another escape code
+    // sequence.
+    if (!text_color.is_rgb) {
+      bool is_background = esc == internal::data::background_color;
+      uint32_t value = text_color.value.term_color;
+      // Background ASCII codes are the same as the foreground ones but with
+      // 10 more.
+      if (is_background) value += 10u;
+
+      std::size_t index = 0;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+
+      if (value >= 100u) {
+        buffer[index++] = static_cast<Char>('1');
+        value %= 100u;
+      }
+      buffer[index++] = static_cast<Char>('0' + value / 10u);
+      buffer[index++] = static_cast<Char>('0' + value % 10u);
+
+      buffer[index++] = static_cast<Char>('m');
+      buffer[index++] = static_cast<Char>('\0');
+      return;
+    }
+
+    for (int i = 0; i < 7; i++) {
+      buffer[i] = static_cast<Char>(esc[i]);
+    }
+    rgb color(text_color.value.rgb_color);
+    to_esc(color.r, buffer + 7, ';');
+    to_esc(color.g, buffer + 11, ';');
+    to_esc(color.b, buffer + 15, 'm');
+    buffer[19] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
+    uint8_t em_codes[4] = {};
+    uint8_t em_bits = static_cast<uint8_t>(em);
+    if (em_bits & static_cast<uint8_t>(emphasis::bold)) em_codes[0] = 1;
+    if (em_bits & static_cast<uint8_t>(emphasis::italic)) em_codes[1] = 3;
+    if (em_bits & static_cast<uint8_t>(emphasis::underline)) em_codes[2] = 4;
+    if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
+      em_codes[3] = 9;
+
+    std::size_t index = 0;
+    for (int i = 0; i < 4; ++i) {
+      if (!em_codes[i]) continue;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
+      buffer[index++] = static_cast<Char>('m');
+    }
+    buffer[index++] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; }
+
+  FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; }
+  FMT_CONSTEXPR const Char* end() const FMT_NOEXCEPT {
+    return buffer + std::char_traits<Char>::length(buffer);
+  }
+
+ private:
+  Char buffer[7u + 3u * 4u + 1u];
+
+  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
+                                   char delimiter) FMT_NOEXCEPT {
+    out[0] = static_cast<Char>('0' + c / 100);
+    out[1] = static_cast<Char>('0' + c / 10 % 10);
+    out[2] = static_cast<Char>('0' + c % 10);
+    out[3] = static_cast<Char>(delimiter);
+  }
+};
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
+    internal::color_type foreground) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(foreground, internal::data::foreground_color);
+}
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
+    internal::color_type background) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(background, internal::data::background_color);
+}
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(em);
+}
+
+template <typename Char>
+inline void fputs(const Char* chars, FILE* stream) FMT_NOEXCEPT {
+  std::fputs(chars, stream);
+}
+
+template <>
+inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT {
+  std::fputws(chars, stream);
+}
+
+template <typename Char> inline void reset_color(FILE* stream) FMT_NOEXCEPT {
+  fputs(internal::data::reset_color, stream);
+}
+
+template <> inline void reset_color<wchar_t>(FILE* stream) FMT_NOEXCEPT {
+  fputs(internal::data::wreset_color, stream);
+}
+
+template <typename Char>
+inline void reset_color(basic_memory_buffer<Char>& buffer) FMT_NOEXCEPT {
+  const char* begin = data::reset_color;
+  const char* end = begin + sizeof(data::reset_color) - 1;
+  buffer.append(begin, end);
+}
+
+template <typename Char>
+void vformat_to(basic_memory_buffer<Char>& buf, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<Char>> args) {
+  bool has_style = false;
+  if (ts.has_emphasis()) {
+    has_style = true;
+    auto emphasis = internal::make_emphasis<Char>(ts.get_emphasis());
+    buf.append(emphasis.begin(), emphasis.end());
+  }
+  if (ts.has_foreground()) {
+    has_style = true;
+    auto foreground =
+        internal::make_foreground_color<Char>(ts.get_foreground());
+    buf.append(foreground.begin(), foreground.end());
+  }
+  if (ts.has_background()) {
+    has_style = true;
+    auto background =
+        internal::make_background_color<Char>(ts.get_background());
+    buf.append(background.begin(), background.end());
+  }
+  internal::vformat_to(buf, format_str, args);
+  if (has_style) internal::reset_color<Char>(buf);
+}
+}  // namespace internal
+
+template <typename S, typename Char = char_t<S>>
+void vprint(std::FILE* f, const text_style& ts, const S& format,
+            basic_format_args<buffer_context<Char>> args) {
+  basic_memory_buffer<Char> buf;
+  internal::vformat_to(buf, ts, to_string_view(format), args);
+  buf.push_back(Char(0));
+  internal::fputs(buf.data(), f);
+}
+
+/**
+  Formats a string and prints it to the specified file stream using ANSI
+  escape sequences to specify text formatting.
+  Example:
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_string<S>::value)>
+void print(std::FILE* f, const text_style& ts, const S& format_str,
+           const Args&... args) {
+  internal::check_format_string<Args...>(format_str);
+  using context = buffer_context<char_t<S>>;
+  format_arg_store<context, Args...> as{args...};
+  vprint(f, ts, format_str, basic_format_args<context>(as));
+}
+
+/**
+  Formats a string and prints it to stdout using ANSI escape sequences to
+  specify text formatting.
+  Example:
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_string<S>::value)>
+void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, format_str, args...);
+}
+
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vformat(
+    const text_style& ts, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buf;
+  internal::vformat_to(buf, ts, to_string_view(format_str), args);
+  return fmt::to_string(buf);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    #include <fmt/color.h>
+    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+                                      "The answer is {}", 42);
+  \endrst
+*/
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
+                                      const Args&... args) {
+  return vformat(ts, to_string_view(format_str),
+                 internal::make_args_checked<Args...>(format_str, args...));
+}
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_COLOR_H_

core/src/spdlog/fmt/bundled/compile.h

@@ -0,0 +1,595 @@
+// Formatting library for C++ - experimental format string compilation
+//
+// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COMPILE_H_
+#define FMT_COMPILE_H_
+
+#include <vector>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+
+// Part of a compiled format string. It can be either literal text or a
+// replacement field.
+template <typename Char> struct format_part {
+  enum class kind { arg_index, arg_name, text, replacement };
+
+  struct replacement {
+    arg_ref<Char> arg_id;
+    dynamic_format_specs<Char> specs;
+  };
+
+  kind part_kind;
+  union value {
+    int arg_index;
+    basic_string_view<Char> str;
+    replacement repl;
+
+    FMT_CONSTEXPR value(int index = 0) : arg_index(index) {}
+    FMT_CONSTEXPR value(basic_string_view<Char> s) : str(s) {}
+    FMT_CONSTEXPR value(replacement r) : repl(r) {}
+  } val;
+  // Position past the end of the argument id.
+  const Char* arg_id_end = nullptr;
+
+  FMT_CONSTEXPR format_part(kind k = kind::arg_index, value v = {})
+      : part_kind(k), val(v) {}
+
+  static FMT_CONSTEXPR format_part make_arg_index(int index) {
+    return format_part(kind::arg_index, index);
+  }
+  static FMT_CONSTEXPR format_part make_arg_name(basic_string_view<Char> name) {
+    return format_part(kind::arg_name, name);
+  }
+  static FMT_CONSTEXPR format_part make_text(basic_string_view<Char> text) {
+    return format_part(kind::text, text);
+  }
+  static FMT_CONSTEXPR format_part make_replacement(replacement repl) {
+    return format_part(kind::replacement, repl);
+  }
+};
+
+template <typename Char> struct part_counter {
+  unsigned num_parts = 0;
+
+  FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
+    if (begin != end) ++num_parts;
+  }
+
+  FMT_CONSTEXPR void on_arg_id() { ++num_parts; }
+  FMT_CONSTEXPR void on_arg_id(int) { ++num_parts; }
+  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) { ++num_parts; }
+
+  FMT_CONSTEXPR void on_replacement_field(const Char*) {}
+
+  FMT_CONSTEXPR const Char* on_format_specs(const Char* begin,
+                                            const Char* end) {
+    // Find the matching brace.
+    unsigned brace_counter = 0;
+    for (; begin != end; ++begin) {
+      if (*begin == '{') {
+        ++brace_counter;
+      } else if (*begin == '}') {
+        if (brace_counter == 0u) break;
+        --brace_counter;
+      }
+    }
+    return begin;
+  }
+
+  FMT_CONSTEXPR void on_error(const char*) {}
+};
+
+// Counts the number of parts in a format string.
+template <typename Char>
+FMT_CONSTEXPR unsigned count_parts(basic_string_view<Char> format_str) {
+  part_counter<Char> counter;
+  parse_format_string<true>(format_str, counter);
+  return counter.num_parts;
+}
+
+template <typename Char, typename PartHandler>
+class format_string_compiler : public error_handler {
+ private:
+  using part = format_part<Char>;
+
+  PartHandler handler_;
+  part part_;
+  basic_string_view<Char> format_str_;
+  basic_format_parse_context<Char> parse_context_;
+
+ public:
+  FMT_CONSTEXPR format_string_compiler(basic_string_view<Char> format_str,
+                                       PartHandler handler)
+      : handler_(handler),
+        format_str_(format_str),
+        parse_context_(format_str) {}
+
+  FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
+    if (begin != end)
+      handler_(part::make_text({begin, to_unsigned(end - begin)}));
+  }
+
+  FMT_CONSTEXPR void on_arg_id() {
+    part_ = part::make_arg_index(parse_context_.next_arg_id());
+  }
+
+  FMT_CONSTEXPR void on_arg_id(int id) {
+    parse_context_.check_arg_id(id);
+    part_ = part::make_arg_index(id);
+  }
+
+  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char> id) {
+    part_ = part::make_arg_name(id);
+  }
+
+  FMT_CONSTEXPR void on_replacement_field(const Char* ptr) {
+    part_.arg_id_end = ptr;
+    handler_(part_);
+  }
+
+  FMT_CONSTEXPR const Char* on_format_specs(const Char* begin,
+                                            const Char* end) {
+    auto repl = typename part::replacement();
+    dynamic_specs_handler<basic_format_parse_context<Char>> handler(
+        repl.specs, parse_context_);
+    auto it = parse_format_specs(begin, end, handler);
+    if (*it != '}') on_error("missing '}' in format string");
+    repl.arg_id = part_.part_kind == part::kind::arg_index
+                      ? arg_ref<Char>(part_.val.arg_index)
+                      : arg_ref<Char>(part_.val.str);
+    auto part = part::make_replacement(repl);
+    part.arg_id_end = begin;
+    handler_(part);
+    return it;
+  }
+};
+
+// Compiles a format string and invokes handler(part) for each parsed part.
+template <bool IS_CONSTEXPR, typename Char, typename PartHandler>
+FMT_CONSTEXPR void compile_format_string(basic_string_view<Char> format_str,
+                                         PartHandler handler) {
+  parse_format_string<IS_CONSTEXPR>(
+      format_str,
+      format_string_compiler<Char, PartHandler>(format_str, handler));
+}
+
+template <typename Range, typename Context, typename Id>
+void format_arg(
+    basic_format_parse_context<typename Range::value_type>& parse_ctx,
+    Context& ctx, Id arg_id) {
+  ctx.advance_to(
+      visit_format_arg(arg_formatter<Range>(ctx, &parse_ctx), ctx.arg(arg_id)));
+}
+
+// vformat_to is defined in a subnamespace to prevent ADL.
+namespace cf {
+template <typename Context, typename Range, typename CompiledFormat>
+auto vformat_to(Range out, CompiledFormat& cf, basic_format_args<Context> args)
+    -> typename Context::iterator {
+  using char_type = typename Context::char_type;
+  basic_format_parse_context<char_type> parse_ctx(
+      to_string_view(cf.format_str_));
+  Context ctx(out.begin(), args);
+
+  const auto& parts = cf.parts();
+  for (auto part_it = std::begin(parts); part_it != std::end(parts);
+       ++part_it) {
+    const auto& part = *part_it;
+    const auto& value = part.val;
+
+    using format_part_t = format_part<char_type>;
+    switch (part.part_kind) {
+    case format_part_t::kind::text: {
+      const auto text = value.str;
+      auto output = ctx.out();
+      auto&& it = reserve(output, text.size());
+      it = std::copy_n(text.begin(), text.size(), it);
+      ctx.advance_to(output);
+      break;
+    }
+
+    case format_part_t::kind::arg_index:
+      advance_to(parse_ctx, part.arg_id_end);
+      internal::format_arg<Range>(parse_ctx, ctx, value.arg_index);
+      break;
+
+    case format_part_t::kind::arg_name:
+      advance_to(parse_ctx, part.arg_id_end);
+      internal::format_arg<Range>(parse_ctx, ctx, value.str);
+      break;
+
+    case format_part_t::kind::replacement: {
+      const auto& arg_id_value = value.repl.arg_id.val;
+      const auto arg = value.repl.arg_id.kind == arg_id_kind::index
+                           ? ctx.arg(arg_id_value.index)
+                           : ctx.arg(arg_id_value.name);
+
+      auto specs = value.repl.specs;
+
+      handle_dynamic_spec<width_checker>(specs.width, specs.width_ref, ctx);
+      handle_dynamic_spec<precision_checker>(specs.precision,
+                                             specs.precision_ref, ctx);
+
+      error_handler h;
+      numeric_specs_checker<error_handler> checker(h, arg.type());
+      if (specs.align == align::numeric) checker.require_numeric_argument();
+      if (specs.sign != sign::none) checker.check_sign();
+      if (specs.alt) checker.require_numeric_argument();
+      if (specs.precision >= 0) checker.check_precision();
+
+      advance_to(parse_ctx, part.arg_id_end);
+      ctx.advance_to(
+          visit_format_arg(arg_formatter<Range>(ctx, nullptr, &specs), arg));
+      break;
+    }
+    }
+  }
+  return ctx.out();
+}
+}  // namespace cf
+
+struct basic_compiled_format {};
+
+template <typename S, typename = void>
+struct compiled_format_base : basic_compiled_format {
+  using char_type = char_t<S>;
+  using parts_container = std::vector<internal::format_part<char_type>>;
+
+  parts_container compiled_parts;
+
+  explicit compiled_format_base(basic_string_view<char_type> format_str) {
+    compile_format_string<false>(format_str,
+                                 [this](const format_part<char_type>& part) {
+                                   compiled_parts.push_back(part);
+                                 });
+  }
+
+  const parts_container& parts() const { return compiled_parts; }
+};
+
+template <typename Char, unsigned N> struct format_part_array {
+  format_part<Char> data[N] = {};
+  FMT_CONSTEXPR format_part_array() = default;
+};
+
+template <typename Char, unsigned N>
+FMT_CONSTEXPR format_part_array<Char, N> compile_to_parts(
+    basic_string_view<Char> format_str) {
+  format_part_array<Char, N> parts;
+  unsigned counter = 0;
+  // This is not a lambda for compatibility with older compilers.
+  struct {
+    format_part<Char>* parts;
+    unsigned* counter;
+    FMT_CONSTEXPR void operator()(const format_part<Char>& part) {
+      parts[(*counter)++] = part;
+    }
+  } collector{parts.data, &counter};
+  compile_format_string<true>(format_str, collector);
+  if (counter < N) {
+    parts.data[counter] =
+        format_part<Char>::make_text(basic_string_view<Char>());
+  }
+  return parts;
+}
+
+template <typename T> constexpr const T& constexpr_max(const T& a, const T& b) {
+  return (a < b) ? b : a;
+}
+
+template <typename S>
+struct compiled_format_base<S, enable_if_t<is_compile_string<S>::value>>
+    : basic_compiled_format {
+  using char_type = char_t<S>;
+
+  FMT_CONSTEXPR explicit compiled_format_base(basic_string_view<char_type>) {}
+
+// Workaround for old compilers. Format string compilation will not be
+// performed there anyway.
+#if FMT_USE_CONSTEXPR
+  static FMT_CONSTEXPR_DECL const unsigned num_format_parts =
+      constexpr_max(count_parts(to_string_view(S())), 1u);
+#else
+  static const unsigned num_format_parts = 1;
+#endif
+
+  using parts_container = format_part<char_type>[num_format_parts];
+
+  const parts_container& parts() const {
+    static FMT_CONSTEXPR_DECL const auto compiled_parts =
+        compile_to_parts<char_type, num_format_parts>(
+            internal::to_string_view(S()));
+    return compiled_parts.data;
+  }
+};
+
+template <typename S, typename... Args>
+class compiled_format : private compiled_format_base<S> {
+ public:
+  using typename compiled_format_base<S>::char_type;
+
+ private:
+  basic_string_view<char_type> format_str_;
+
+  template <typename Context, typename Range, typename CompiledFormat>
+  friend auto cf::vformat_to(Range out, CompiledFormat& cf,
+                             basic_format_args<Context> args) ->
+      typename Context::iterator;
+
+ public:
+  compiled_format() = delete;
+  explicit constexpr compiled_format(basic_string_view<char_type> format_str)
+      : compiled_format_base<S>(format_str), format_str_(format_str) {}
+};
+
+#ifdef __cpp_if_constexpr
+template <typename... Args> struct type_list {};
+
+// Returns a reference to the argument at index N from [first, rest...].
+template <int N, typename T, typename... Args>
+constexpr const auto& get(const T& first, const Args&... rest) {
+  static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
+  if constexpr (N == 0)
+    return first;
+  else
+    return get<N - 1>(rest...);
+}
+
+template <int N, typename> struct get_type_impl;
+
+template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
+  using type = remove_cvref_t<decltype(get<N>(std::declval<Args>()...))>;
+};
+
+template <int N, typename T>
+using get_type = typename get_type_impl<N, T>::type;
+
+template <typename T> struct is_compiled_format : std::false_type {};
+
+template <typename Char> struct text {
+  basic_string_view<Char> data;
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  OutputIt format(OutputIt out, const Args&...) const {
+    // TODO: reserve
+    return copy_str<Char>(data.begin(), data.end(), out);
+  }
+};
+
+template <typename Char>
+struct is_compiled_format<text<Char>> : std::true_type {};
+
+template <typename Char>
+constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos,
+                               size_t size) {
+  return {{&s[pos], size}};
+}
+
+template <typename Char, typename OutputIt, typename T,
+          std::enable_if_t<std::is_integral_v<T>, int> = 0>
+OutputIt format_default(OutputIt out, T value) {
+  // TODO: reserve
+  format_int fi(value);
+  return std::copy(fi.data(), fi.data() + fi.size(), out);
+}
+
+template <typename Char, typename OutputIt>
+OutputIt format_default(OutputIt out, double value) {
+  writer w(out);
+  w.write(value);
+  return w.out();
+}
+
+template <typename Char, typename OutputIt>
+OutputIt format_default(OutputIt out, Char value) {
+  *out++ = value;
+  return out;
+}
+
+template <typename Char, typename OutputIt>
+OutputIt format_default(OutputIt out, const Char* value) {
+  auto length = std::char_traits<Char>::length(value);
+  return copy_str<Char>(value, value + length, out);
+}
+
+// A replacement field that refers to argument N.
+template <typename Char, typename T, int N> struct field {
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  OutputIt format(OutputIt out, const Args&... args) const {
+    // This ensures that the argument type is convertile to `const T&`.
+    const T& arg = get<N>(args...);
+    return format_default<Char>(out, arg);
+  }
+};
+
+template <typename Char, typename T, int N>
+struct is_compiled_format<field<Char, T, N>> : std::true_type {};
+
+template <typename L, typename R> struct concat {
+  L lhs;
+  R rhs;
+  using char_type = typename L::char_type;
+
+  template <typename OutputIt, typename... Args>
+  OutputIt format(OutputIt out, const Args&... args) const {
+    out = lhs.format(out, args...);
+    return rhs.format(out, args...);
+  }
+};
+
+template <typename L, typename R>
+struct is_compiled_format<concat<L, R>> : std::true_type {};
+
+template <typename L, typename R>
+constexpr concat<L, R> make_concat(L lhs, R rhs) {
+  return {lhs, rhs};
+}
+
+struct unknown_format {};
+
+template <typename Char>
+constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
+  for (size_t size = str.size(); pos != size; ++pos) {
+    if (str[pos] == '{' || str[pos] == '}') break;
+  }
+  return pos;
+}
+
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str);
+
+template <typename Args, size_t POS, int ID, typename T, typename S>
+constexpr auto parse_tail(T head, S format_str) {
+  if constexpr (POS != to_string_view(format_str).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
+    if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
+                               unknown_format>())
+      return tail;
+    else
+      return make_concat(head, tail);
+  } else {
+    return head;
+  }
+}
+
+// Compiles a non-empty format string and returns the compiled representation
+// or unknown_format() on unrecognized input.
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str) {
+  using char_type = typename S::char_type;
+  constexpr basic_string_view<char_type> str = format_str;
+  if constexpr (str[POS] == '{') {
+    if (POS + 1 == str.size())
+      throw format_error("unmatched '{' in format string");
+    if constexpr (str[POS + 1] == '{') {
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+    } else if constexpr (str[POS + 1] == '}') {
+      using type = get_type<ID, Args>;
+      if constexpr (std::is_same<type, int>::value) {
+        return parse_tail<Args, POS + 2, ID + 1>(field<char_type, type, ID>(),
+                                                 format_str);
+      } else {
+        return unknown_format();
+      }
+    } else {
+      return unknown_format();
+    }
+  } else if constexpr (str[POS] == '}') {
+    if (POS + 1 == str.size())
+      throw format_error("unmatched '}' in format string");
+    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+  } else {
+    constexpr auto end = parse_text(str, POS + 1);
+    return parse_tail<Args, end, ID>(make_text(str, POS, end - POS),
+                                     format_str);
+  }
+}
+#endif  // __cpp_if_constexpr
+}  // namespace internal
+
+#if FMT_USE_CONSTEXPR
+#  ifdef __cpp_if_constexpr
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(is_compile_string<S>::value)>
+constexpr auto compile(S format_str) {
+  constexpr basic_string_view<typename S::char_type> str = format_str;
+  if constexpr (str.size() == 0) {
+    return internal::make_text(str, 0, 0);
+  } else {
+    constexpr auto result =
+        internal::compile_format_string<internal::type_list<Args...>, 0, 0>(
+            format_str);
+    if constexpr (std::is_same<remove_cvref_t<decltype(result)>,
+                               internal::unknown_format>()) {
+      return internal::compiled_format<S, Args...>(to_string_view(format_str));
+    } else {
+      return result;
+    }
+  }
+}
+
+template <typename CompiledFormat, typename... Args,
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(internal::is_compiled_format<CompiledFormat>::value)>
+std::basic_string<Char> format(const CompiledFormat& cf, const Args&... args) {
+  basic_memory_buffer<Char> buffer;
+  cf.format(std::back_inserter(buffer), args...);
+  return to_string(buffer);
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(internal::is_compiled_format<CompiledFormat>::value)>
+OutputIt format_to(OutputIt out, const CompiledFormat& cf,
+                   const Args&... args) {
+  return cf.format(out, args...);
+}
+#  else
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(is_compile_string<S>::value)>
+constexpr auto compile(S format_str) -> internal::compiled_format<S, Args...> {
+  return internal::compiled_format<S, Args...>(to_string_view(format_str));
+}
+#  endif  // __cpp_if_constexpr
+#endif    // FMT_USE_CONSTEXPR
+
+// Compiles the format string which must be a string literal.
+template <typename... Args, typename Char, size_t N>
+auto compile(const Char (&format_str)[N])
+    -> internal::compiled_format<const Char*, Args...> {
+  return internal::compiled_format<const Char*, Args...>(
+      basic_string_view<Char>(format_str, N - 1));
+}
+
+template <typename CompiledFormat, typename... Args,
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(std::is_base_of<internal::basic_compiled_format,
+                                        CompiledFormat>::value)>
+std::basic_string<Char> format(const CompiledFormat& cf, const Args&... args) {
+  basic_memory_buffer<Char> buffer;
+  using range = buffer_range<Char>;
+  using context = buffer_context<Char>;
+  internal::cf::vformat_to<context>(range(buffer), cf,
+                                    make_format_args<context>(args...));
+  return to_string(buffer);
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(std::is_base_of<internal::basic_compiled_format,
+                                        CompiledFormat>::value)>
+OutputIt format_to(OutputIt out, const CompiledFormat& cf,
+                   const Args&... args) {
+  using char_type = typename CompiledFormat::char_type;
+  using range = internal::output_range<OutputIt, char_type>;
+  using context = format_context_t<OutputIt, char_type>;
+  return internal::cf::vformat_to<context>(range(out), cf,
+                                           make_format_args<context>(args...));
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
+format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
+                                         const CompiledFormat& cf,
+                                         const Args&... args) {
+  auto it =
+      format_to(internal::truncating_iterator<OutputIt>(out, n), cf, args...);
+  return {it.base(), it.count()};
+}
+
+template <typename CompiledFormat, typename... Args>
+std::size_t formatted_size(const CompiledFormat& cf, const Args&... args) {
+  return format_to(internal::counting_iterator(), cf, args...).count();
+}
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_COMPILE_H_

core/src/spdlog/fmt/bundled/locale.h

@@ -0,0 +1,78 @@
+// Formatting library for C++ - std::locale support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_LOCALE_H_
+#define FMT_LOCALE_H_
+
+#include <locale>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+namespace internal {
+template <typename Char>
+typename buffer_context<Char>::iterator vformat_to(
+    const std::locale& loc, buffer<Char>& buf,
+    basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  using range = buffer_range<Char>;
+  return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str), args,
+                                          internal::locale_ref(loc));
+}
+
+template <typename Char>
+std::basic_string<Char> vformat(
+    const std::locale& loc, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  internal::vformat_to(loc, buffer, format_str, args);
+  return fmt::to_string(buffer);
+}
+}  // namespace internal
+
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vformat(
+    const std::locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  return internal::vformat(loc, to_string_view(format_str), args);
+}
+
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const std::locale& loc,
+                                      const S& format_str, Args&&... args) {
+  return internal::vformat(
+      loc, to_string_view(format_str),
+      internal::make_args_checked<Args...>(format_str, args...));
+}
+
+template <typename S, typename OutputIt, typename... Args,
+          typename Char = enable_if_t<
+              internal::is_output_iterator<OutputIt>::value, char_t<S>>>
+inline OutputIt vformat_to(
+    OutputIt out, const std::locale& loc, const S& format_str,
+    format_args_t<type_identity_t<OutputIt>, Char> args) {
+  using range = internal::output_range<OutputIt, Char>;
+  return vformat_to<arg_formatter<range>>(
+      range(out), to_string_view(format_str), args, internal::locale_ref(loc));
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value&&
+                            internal::is_string<S>::value)>
+inline OutputIt format_to(OutputIt out, const std::locale& loc,
+                          const S& format_str, Args&&... args) {
+  internal::check_format_string<Args...>(format_str);
+  using context = format_context_t<OutputIt, char_t<S>>;
+  format_arg_store<context, Args...> as{args...};
+  return vformat_to(out, loc, to_string_view(format_str),
+                    basic_format_args<context>(as));
+}
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_LOCALE_H_

core/src/spdlog/fmt/bundled/ostream.h

@@ -0,0 +1,166 @@
+// Formatting library for C++ - std::ostream support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_OSTREAM_H_
+#define FMT_OSTREAM_H_
+
+#include <ostream>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+template <typename CHar> class basic_printf_parse_context;
+template <typename OutputIt, typename Char> class basic_printf_context;
+
+namespace internal {
+
+template <class Char> class formatbuf : public std::basic_streambuf<Char> {
+ private:
+  using int_type = typename std::basic_streambuf<Char>::int_type;
+  using traits_type = typename std::basic_streambuf<Char>::traits_type;
+
+  buffer<Char>& buffer_;
+
+ public:
+  formatbuf(buffer<Char>& buf) : buffer_(buf) {}
+
+ protected:
+  // The put-area is actually always empty. This makes the implementation
+  // simpler and has the advantage that the streambuf and the buffer are always
+  // in sync and sputc never writes into uninitialized memory. The obvious
+  // disadvantage is that each call to sputc always results in a (virtual) call
+  // to overflow. There is no disadvantage here for sputn since this always
+  // results in a call to xsputn.
+
+  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
+    if (!traits_type::eq_int_type(ch, traits_type::eof()))
+      buffer_.push_back(static_cast<Char>(ch));
+    return ch;
+  }
+
+  std::streamsize xsputn(const Char* s, std::streamsize count) FMT_OVERRIDE {
+    buffer_.append(s, s + count);
+    return count;
+  }
+};
+
+template <typename Char> struct test_stream : std::basic_ostream<Char> {
+ private:
+  // Hide all operator<< from std::basic_ostream<Char>.
+  void_t<> operator<<(null<>);
+  void_t<> operator<<(const Char*);
+
+  template <typename T, FMT_ENABLE_IF(std::is_convertible<T, int>::value &&
+                                      !std::is_enum<T>::value)>
+  void_t<> operator<<(T);
+};
+
+// Checks if T has a user-defined operator<< (e.g. not a member of
+// std::ostream).
+template <typename T, typename Char> class is_streamable {
+ private:
+  template <typename U>
+  static bool_constant<!std::is_same<decltype(std::declval<test_stream<Char>&>()
+                                              << std::declval<U>()),
+                                     void_t<>>::value>
+  test(int);
+
+  template <typename> static std::false_type test(...);
+
+  using result = decltype(test<T>(0));
+
+ public:
+  static const bool value = result::value;
+};
+
+// Write the content of buf to os.
+template <typename Char>
+void write(std::basic_ostream<Char>& os, buffer<Char>& buf) {
+  const Char* buf_data = buf.data();
+  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
+  unsigned_streamsize size = buf.size();
+  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
+  do {
+    unsigned_streamsize n = size <= max_size ? size : max_size;
+    os.write(buf_data, static_cast<std::streamsize>(n));
+    buf_data += n;
+    size -= n;
+  } while (size != 0);
+}
+
+template <typename Char, typename T>
+void format_value(buffer<Char>& buf, const T& value,
+                  locale_ref loc = locale_ref()) {
+  formatbuf<Char> format_buf(buf);
+  std::basic_ostream<Char> output(&format_buf);
+#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+  if (loc) output.imbue(loc.get<std::locale>());
+#endif
+  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+  output << value;
+  buf.resize(buf.size());
+}
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template <typename T, typename Char>
+struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+    : private formatter<basic_string_view<Char>, Char> {
+  auto parse(basic_format_parse_context<Char>& ctx) -> decltype(ctx.begin()) {
+    return formatter<basic_string_view<Char>, Char>::parse(ctx);
+  }
+  template <typename ParseCtx,
+            FMT_ENABLE_IF(std::is_same<
+                          ParseCtx, basic_printf_parse_context<Char>>::value)>
+  auto parse(ParseCtx& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename OutputIt>
+  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx)
+      -> OutputIt {
+    basic_memory_buffer<Char> buffer;
+    format_value(buffer, value, ctx.locale());
+    basic_string_view<Char> str(buffer.data(), buffer.size());
+    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
+  }
+  template <typename OutputIt>
+  auto format(const T& value, basic_printf_context<OutputIt, Char>& ctx)
+      -> OutputIt {
+    basic_memory_buffer<Char> buffer;
+    format_value(buffer, value, ctx.locale());
+    return std::copy(buffer.begin(), buffer.end(), ctx.out());
+  }
+};
+}  // namespace internal
+
+template <typename Char>
+void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  internal::vformat_to(buffer, format_str, args);
+  internal::write(os, buffer);
+}
+
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::print(cerr, "Don't {}!", "panic");
+  \endrst
+ */
+template <typename S, typename... Args,
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
+  vprint(os, to_string_view(format_str),
+         internal::make_args_checked<Args...>(format_str, args...));
+}
+FMT_END_NAMESPACE
+
+#endif  // FMT_OSTREAM_H_

core/src/spdlog/fmt/bundled/posix.h

@@ -0,0 +1,2 @@
+#include "os.h"
+#warning "fmt/posix.h is deprecated; use fmt/os.h instead"

core/src/spdlog/fmt/bundled/printf.h

@@ -0,0 +1,726 @@
+// Formatting library for C++ - legacy printf implementation
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_PRINTF_H_
+#define FMT_PRINTF_H_
+
+#include <algorithm>  // std::max
+#include <limits>     // std::numeric_limits
+
+#include "ostream.h"
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+
+// Checks if a value fits in int - used to avoid warnings about comparing
+// signed and unsigned integers.
+template <bool IsSigned> struct int_checker {
+  template <typename T> static bool fits_in_int(T value) {
+    unsigned max = max_value<int>();
+    return value <= max;
+  }
+  static bool fits_in_int(bool) { return true; }
+};
+
+template <> struct int_checker<true> {
+  template <typename T> static bool fits_in_int(T value) {
+    return value >= (std::numeric_limits<int>::min)() &&
+           value <= max_value<int>();
+  }
+  static bool fits_in_int(int) { return true; }
+};
+
+class printf_precision_handler {
+ public:
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  int operator()(T value) {
+    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+      FMT_THROW(format_error("number is too big"));
+    return (std::max)(static_cast<int>(value), 0);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  int operator()(T) {
+    FMT_THROW(format_error("precision is not integer"));
+    return 0;
+  }
+};
+
+// An argument visitor that returns true iff arg is a zero integer.
+class is_zero_int {
+ public:
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  bool operator()(T value) {
+    return value == 0;
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  bool operator()(T) {
+    return false;
+  }
+};
+
+template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
+
+template <> struct make_unsigned_or_bool<bool> { using type = bool; };
+
+template <typename T, typename Context> class arg_converter {
+ private:
+  using char_type = typename Context::char_type;
+
+  basic_format_arg<Context>& arg_;
+  char_type type_;
+
+ public:
+  arg_converter(basic_format_arg<Context>& arg, char_type type)
+      : arg_(arg), type_(type) {}
+
+  void operator()(bool value) {
+    if (type_ != 's') operator()<bool>(value);
+  }
+
+  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
+  void operator()(U value) {
+    bool is_signed = type_ == 'd' || type_ == 'i';
+    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
+    if (const_check(sizeof(target_type) <= sizeof(int))) {
+      // Extra casts are used to silence warnings.
+      if (is_signed) {
+        arg_ = internal::make_arg<Context>(
+            static_cast<int>(static_cast<target_type>(value)));
+      } else {
+        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+        arg_ = internal::make_arg<Context>(
+            static_cast<unsigned>(static_cast<unsigned_type>(value)));
+      }
+    } else {
+      if (is_signed) {
+        // glibc's printf doesn't sign extend arguments of smaller types:
+        //   std::printf("%lld", -42);  // prints "4294967254"
+        // but we don't have to do the same because it's a UB.
+        arg_ = internal::make_arg<Context>(static_cast<long long>(value));
+      } else {
+        arg_ = internal::make_arg<Context>(
+            static_cast<typename make_unsigned_or_bool<U>::type>(value));
+      }
+    }
+  }
+
+  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
+  void operator()(U) {}  // No conversion needed for non-integral types.
+};
+
+// Converts an integer argument to T for printf, if T is an integral type.
+// If T is void, the argument is converted to corresponding signed or unsigned
+// type depending on the type specifier: 'd' and 'i' - signed, other -
+// unsigned).
+template <typename T, typename Context, typename Char>
+void convert_arg(basic_format_arg<Context>& arg, Char type) {
+  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
+}
+
+// Converts an integer argument to char for printf.
+template <typename Context> class char_converter {
+ private:
+  basic_format_arg<Context>& arg_;
+
+ public:
+  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
+
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  void operator()(T value) {
+    arg_ = internal::make_arg<Context>(
+        static_cast<typename Context::char_type>(value));
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  void operator()(T) {}  // No conversion needed for non-integral types.
+};
+
+// Checks if an argument is a valid printf width specifier and sets
+// left alignment if it is negative.
+template <typename Char> class printf_width_handler {
+ private:
+  using format_specs = basic_format_specs<Char>;
+
+  format_specs& specs_;
+
+ public:
+  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  unsigned operator()(T value) {
+    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
+    if (internal::is_negative(value)) {
+      specs_.align = align::left;
+      width = 0 - width;
+    }
+    unsigned int_max = max_value<int>();
+    if (width > int_max) FMT_THROW(format_error("number is too big"));
+    return static_cast<unsigned>(width);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  unsigned operator()(T) {
+    FMT_THROW(format_error("width is not integer"));
+    return 0;
+  }
+};
+
+template <typename Char, typename Context>
+void printf(buffer<Char>& buf, basic_string_view<Char> format,
+            basic_format_args<Context> args) {
+  Context(std::back_inserter(buf), format, args).format();
+}
+
+template <typename OutputIt, typename Char, typename Context>
+internal::truncating_iterator<OutputIt> printf(
+    internal::truncating_iterator<OutputIt> it, basic_string_view<Char> format,
+    basic_format_args<Context> args) {
+  return Context(it, format, args).format();
+}
+}  // namespace internal
+
+using internal::printf;  // For printing into memory_buffer.
+
+template <typename Range> class printf_arg_formatter;
+
+template <typename Char>
+class basic_printf_parse_context : public basic_format_parse_context<Char> {
+  using basic_format_parse_context<Char>::basic_format_parse_context;
+};
+template <typename OutputIt, typename Char> class basic_printf_context;
+
+/**
+  \rst
+  The ``printf`` argument formatter.
+  \endrst
+ */
+template <typename Range>
+class printf_arg_formatter : public internal::arg_formatter_base<Range> {
+ public:
+  using iterator = typename Range::iterator;
+
+ private:
+  using char_type = typename Range::value_type;
+  using base = internal::arg_formatter_base<Range>;
+  using context_type = basic_printf_context<iterator, char_type>;
+
+  context_type& context_;
+
+  void write_null_pointer(char) {
+    this->specs()->type = 0;
+    this->write("(nil)");
+  }
+
+  void write_null_pointer(wchar_t) {
+    this->specs()->type = 0;
+    this->write(L"(nil)");
+  }
+
+ public:
+  using format_specs = typename base::format_specs;
+
+  /**
+    \rst
+    Constructs an argument formatter object.
+    *buffer* is a reference to the output buffer and *specs* contains format
+    specifier information for standard argument types.
+    \endrst
+   */
+  printf_arg_formatter(iterator iter, format_specs& specs, context_type& ctx)
+      : base(Range(iter), &specs, internal::locale_ref()), context_(ctx) {}
+
+  template <typename T, FMT_ENABLE_IF(fmt::internal::is_integral<T>::value)>
+  iterator operator()(T value) {
+    // MSVC2013 fails to compile separate overloads for bool and char_type so
+    // use std::is_same instead.
+    if (std::is_same<T, bool>::value) {
+      format_specs& fmt_specs = *this->specs();
+      if (fmt_specs.type != 's') return base::operator()(value ? 1 : 0);
+      fmt_specs.type = 0;
+      this->write(value != 0);
+    } else if (std::is_same<T, char_type>::value) {
+      format_specs& fmt_specs = *this->specs();
+      if (fmt_specs.type && fmt_specs.type != 'c')
+        return (*this)(static_cast<int>(value));
+      fmt_specs.sign = sign::none;
+      fmt_specs.alt = false;
+      fmt_specs.align = align::right;
+      return base::operator()(value);
+    } else {
+      return base::operator()(value);
+    }
+    return this->out();
+  }
+
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+  iterator operator()(T value) {
+    return base::operator()(value);
+  }
+
+  /** Formats a null-terminated C string. */
+  iterator operator()(const char* value) {
+    if (value)
+      base::operator()(value);
+    else if (this->specs()->type == 'p')
+      write_null_pointer(char_type());
+    else
+      this->write("(null)");
+    return this->out();
+  }
+
+  /** Formats a null-terminated wide C string. */
+  iterator operator()(const wchar_t* value) {
+    if (value)
+      base::operator()(value);
+    else if (this->specs()->type == 'p')
+      write_null_pointer(char_type());
+    else
+      this->write(L"(null)");
+    return this->out();
+  }
+
+  iterator operator()(basic_string_view<char_type> value) {
+    return base::operator()(value);
+  }
+
+  iterator operator()(monostate value) { return base::operator()(value); }
+
+  /** Formats a pointer. */
+  iterator operator()(const void* value) {
+    if (value) return base::operator()(value);
+    this->specs()->type = 0;
+    write_null_pointer(char_type());
+    return this->out();
+  }
+
+  /** Formats an argument of a custom (user-defined) type. */
+  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
+    handle.format(context_.parse_context(), context_);
+    return this->out();
+  }
+};
+
+template <typename T> struct printf_formatter {
+  printf_formatter() = delete;
+
+  template <typename ParseContext>
+  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const T& value, FormatContext& ctx) -> decltype(ctx.out()) {
+    internal::format_value(internal::get_container(ctx.out()), value);
+    return ctx.out();
+  }
+};
+
+/** This template formats data and writes the output to a writer. */
+template <typename OutputIt, typename Char> class basic_printf_context {
+ public:
+  /** The character type for the output. */
+  using char_type = Char;
+  using iterator = OutputIt;
+  using format_arg = basic_format_arg<basic_printf_context>;
+  using parse_context_type = basic_printf_parse_context<Char>;
+  template <typename T> using formatter_type = printf_formatter<T>;
+
+ private:
+  using format_specs = basic_format_specs<char_type>;
+
+  OutputIt out_;
+  basic_format_args<basic_printf_context> args_;
+  parse_context_type parse_ctx_;
+
+  static void parse_flags(format_specs& specs, const Char*& it,
+                          const Char* end);
+
+  // Returns the argument with specified index or, if arg_index is -1, the next
+  // argument.
+  format_arg get_arg(int arg_index = -1);
+
+  // Parses argument index, flags and width and returns the argument index.
+  int parse_header(const Char*& it, const Char* end, format_specs& specs);
+
+ public:
+  /**
+   \rst
+   Constructs a ``printf_context`` object. References to the arguments and
+   the writer are stored in the context object so make sure they have
+   appropriate lifetimes.
+   \endrst
+   */
+  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
+                       basic_format_args<basic_printf_context> args)
+      : out_(out), args_(args), parse_ctx_(format_str) {}
+
+  OutputIt out() { return out_; }
+  void advance_to(OutputIt it) { out_ = it; }
+
+  internal::locale_ref locale() { return {}; }
+
+  format_arg arg(int id) const { return args_.get(id); }
+
+  parse_context_type& parse_context() { return parse_ctx_; }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    parse_ctx_.on_error(message);
+  }
+
+  /** Formats stored arguments and writes the output to the range. */
+  template <typename ArgFormatter = printf_arg_formatter<buffer_range<Char>>>
+  OutputIt format();
+};
+
+template <typename OutputIt, typename Char>
+void basic_printf_context<OutputIt, Char>::parse_flags(format_specs& specs,
+                                                       const Char*& it,
+                                                       const Char* end) {
+  for (; it != end; ++it) {
+    switch (*it) {
+    case '-':
+      specs.align = align::left;
+      break;
+    case '+':
+      specs.sign = sign::plus;
+      break;
+    case '0':
+      specs.fill[0] = '0';
+      break;
+    case ' ':
+      specs.sign = sign::space;
+      break;
+    case '#':
+      specs.alt = true;
+      break;
+    default:
+      return;
+    }
+  }
+}
+
+template <typename OutputIt, typename Char>
+typename basic_printf_context<OutputIt, Char>::format_arg
+basic_printf_context<OutputIt, Char>::get_arg(int arg_index) {
+  if (arg_index < 0)
+    arg_index = parse_ctx_.next_arg_id();
+  else
+    parse_ctx_.check_arg_id(--arg_index);
+  return internal::get_arg(*this, arg_index);
+}
+
+template <typename OutputIt, typename Char>
+int basic_printf_context<OutputIt, Char>::parse_header(const Char*& it,
+                                                       const Char* end,
+                                                       format_specs& specs) {
+  int arg_index = -1;
+  char_type c = *it;
+  if (c >= '0' && c <= '9') {
+    // Parse an argument index (if followed by '$') or a width possibly
+    // preceded with '0' flag(s).
+    internal::error_handler eh;
+    int value = parse_nonnegative_int(it, end, eh);
+    if (it != end && *it == '$') {  // value is an argument index
+      ++it;
+      arg_index = value;
+    } else {
+      if (c == '0') specs.fill[0] = '0';
+      if (value != 0) {
+        // Nonzero value means that we parsed width and don't need to
+        // parse it or flags again, so return now.
+        specs.width = value;
+        return arg_index;
+      }
+    }
+  }
+  parse_flags(specs, it, end);
+  // Parse width.
+  if (it != end) {
+    if (*it >= '0' && *it <= '9') {
+      internal::error_handler eh;
+      specs.width = parse_nonnegative_int(it, end, eh);
+    } else if (*it == '*') {
+      ++it;
+      specs.width = static_cast<int>(visit_format_arg(
+          internal::printf_width_handler<char_type>(specs), get_arg()));
+    }
+  }
+  return arg_index;
+}
+
+template <typename OutputIt, typename Char>
+template <typename ArgFormatter>
+OutputIt basic_printf_context<OutputIt, Char>::format() {
+  auto out = this->out();
+  const Char* start = parse_ctx_.begin();
+  const Char* end = parse_ctx_.end();
+  auto it = start;
+  while (it != end) {
+    char_type c = *it++;
+    if (c != '%') continue;
+    if (it != end && *it == c) {
+      out = std::copy(start, it, out);
+      start = ++it;
+      continue;
+    }
+    out = std::copy(start, it - 1, out);
+
+    format_specs specs;
+    specs.align = align::right;
+
+    // Parse argument index, flags and width.
+    int arg_index = parse_header(it, end, specs);
+    if (arg_index == 0) on_error("argument index out of range");
+
+    // Parse precision.
+    if (it != end && *it == '.') {
+      ++it;
+      c = it != end ? *it : 0;
+      if ('0' <= c && c <= '9') {
+        internal::error_handler eh;
+        specs.precision = parse_nonnegative_int(it, end, eh);
+      } else if (c == '*') {
+        ++it;
+        specs.precision = static_cast<int>(
+            visit_format_arg(internal::printf_precision_handler(), get_arg()));
+      } else {
+        specs.precision = 0;
+      }
+    }
+
+    format_arg arg = get_arg(arg_index);
+    if (specs.alt && visit_format_arg(internal::is_zero_int(), arg))
+      specs.alt = false;
+    if (specs.fill[0] == '0') {
+      if (arg.is_arithmetic())
+        specs.align = align::numeric;
+      else
+        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types.
+    }
+
+    // Parse length and convert the argument to the required type.
+    c = it != end ? *it++ : 0;
+    char_type t = it != end ? *it : 0;
+    using internal::convert_arg;
+    switch (c) {
+    case 'h':
+      if (t == 'h') {
+        ++it;
+        t = it != end ? *it : 0;
+        convert_arg<signed char>(arg, t);
+      } else {
+        convert_arg<short>(arg, t);
+      }
+      break;
+    case 'l':
+      if (t == 'l') {
+        ++it;
+        t = it != end ? *it : 0;
+        convert_arg<long long>(arg, t);
+      } else {
+        convert_arg<long>(arg, t);
+      }
+      break;
+    case 'j':
+      convert_arg<intmax_t>(arg, t);
+      break;
+    case 'z':
+      convert_arg<std::size_t>(arg, t);
+      break;
+    case 't':
+      convert_arg<std::ptrdiff_t>(arg, t);
+      break;
+    case 'L':
+      // printf produces garbage when 'L' is omitted for long double, no
+      // need to do the same.
+      break;
+    default:
+      --it;
+      convert_arg<void>(arg, c);
+    }
+
+    // Parse type.
+    if (it == end) FMT_THROW(format_error("invalid format string"));
+    specs.type = static_cast<char>(*it++);
+    if (arg.is_integral()) {
+      // Normalize type.
+      switch (specs.type) {
+      case 'i':
+      case 'u':
+        specs.type = 'd';
+        break;
+      case 'c':
+        visit_format_arg(internal::char_converter<basic_printf_context>(arg),
+                         arg);
+        break;
+      }
+    }
+
+    start = it;
+
+    // Format argument.
+    visit_format_arg(ArgFormatter(out, specs, *this), arg);
+  }
+  return std::copy(start, it, out);
+}
+
+template <typename Char>
+using basic_printf_context_t =
+    basic_printf_context<std::back_insert_iterator<internal::buffer<Char>>,
+                         Char>;
+
+using printf_context = basic_printf_context_t<char>;
+using wprintf_context = basic_printf_context_t<wchar_t>;
+
+using printf_args = basic_format_args<printf_context>;
+using wprintf_args = basic_format_args<wprintf_context>;
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::printf_args`.
+  \endrst
+ */
+template <typename... Args>
+inline format_arg_store<printf_context, Args...> make_printf_args(
+    const Args&... args) {
+  return {args...};
+}
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::wprintf_args`.
+  \endrst
+ */
+template <typename... Args>
+inline format_arg_store<wprintf_context, Args...> make_wprintf_args(
+    const Args&... args) {
+  return {args...};
+}
+
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vsprintf(
+    const S& format,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  printf(buffer, to_string_view(format), args);
+  return to_string(buffer);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string.
+
+  **Example**::
+
+    std::string message = fmt::sprintf("The answer is %d", 42);
+  \endrst
+*/
+template <typename S, typename... Args,
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+inline std::basic_string<Char> sprintf(const S& format, const Args&... args) {
+  using context = basic_printf_context_t<Char>;
+  return vsprintf(to_string_view(format), make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline int vfprintf(
+    std::FILE* f, const S& format,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  printf(buffer, to_string_view(format), args);
+  std::size_t size = buffer.size();
+  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
+             ? -1
+             : static_cast<int>(size);
+}
+
+/**
+  \rst
+  Prints formatted data to the file *f*.
+
+  **Example**::
+
+    fmt::fprintf(stderr, "Don't %s!", "panic");
+  \endrst
+ */
+template <typename S, typename... Args,
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+inline int fprintf(std::FILE* f, const S& format, const Args&... args) {
+  using context = basic_printf_context_t<Char>;
+  return vfprintf(f, to_string_view(format),
+                  make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline int vprintf(
+    const S& format,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
+  return vfprintf(stdout, to_string_view(format), args);
+}
+
+/**
+  \rst
+  Prints formatted data to ``stdout``.
+
+  **Example**::
+
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_string<S>::value)>
+inline int printf(const S& format_str, const Args&... args) {
+  using context = basic_printf_context_t<char_t<S>>;
+  return vprintf(to_string_view(format_str),
+                 make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline int vfprintf(
+    std::basic_ostream<Char>& os, const S& format,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  printf(buffer, to_string_view(format), args);
+  internal::write(os, buffer);
+  return static_cast<int>(buffer.size());
+}
+
+/** Formats arguments and writes the output to the range. */
+template <typename ArgFormatter, typename Char,
+          typename Context =
+              basic_printf_context<typename ArgFormatter::iterator, Char>>
+typename ArgFormatter::iterator vprintf(
+    internal::buffer<Char>& out, basic_string_view<Char> format_str,
+    basic_format_args<type_identity_t<Context>> args) {
+  typename ArgFormatter::iterator iter(out);
+  Context(iter, format_str, args).template format<ArgFormatter>();
+  return iter;
+}
+
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::fprintf(cerr, "Don't %s!", "panic");
+  \endrst
+ */
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline int fprintf(std::basic_ostream<Char>& os, const S& format_str,
+                   const Args&... args) {
+  using context = basic_printf_context_t<Char>;
+  return vfprintf(os, to_string_view(format_str),
+                  make_format_args<context>(args...));
+}
+FMT_END_NAMESPACE
+
+#endif  // FMT_PRINTF_H_

core/src/spdlog/fmt/bundled/ranges.h

@@ -0,0 +1,387 @@
+// Formatting library for C++ - experimental range support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2018 - present, Remotion (Igor Schulz)
+// All Rights Reserved
+// {fmt} support for ranges, containers and types tuple interface.
+
+#ifndef FMT_RANGES_H_
+#define FMT_RANGES_H_
+
+#include <initializer_list>
+#include <type_traits>
+
+#include "format.h"
+
+// output only up to N items from the range.
+#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
+#  define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
+#endif
+
+FMT_BEGIN_NAMESPACE
+
+template <typename Char> struct formatting_base {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+};
+
+template <typename Char, typename Enable = void>
+struct formatting_range : formatting_base<Char> {
+  static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
+      FMT_RANGE_OUTPUT_LENGTH_LIMIT;  // output only up to N items from the
+                                      // range.
+  Char prefix;
+  Char delimiter;
+  Char postfix;
+  formatting_range() : prefix('{'), delimiter(','), postfix('}') {}
+  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
+};
+
+template <typename Char, typename Enable = void>
+struct formatting_tuple : formatting_base<Char> {
+  Char prefix;
+  Char delimiter;
+  Char postfix;
+  formatting_tuple() : prefix('('), delimiter(','), postfix(')') {}
+  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
+};
+
+namespace internal {
+
+template <typename RangeT, typename OutputIterator>
+OutputIterator copy(const RangeT& range, OutputIterator out) {
+  for (auto it = range.begin(), end = range.end(); it != end; ++it)
+    *out++ = *it;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(const char* str, OutputIterator out) {
+  while (*str) *out++ = *str++;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(char ch, OutputIterator out) {
+  *out++ = ch;
+  return out;
+}
+
+/// Return true value if T has std::string interface, like std::string_view.
+template <typename T> class is_like_std_string {
+  template <typename U>
+  static auto check(U* p)
+      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
+  template <typename> static void check(...);
+
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+      is_string<T>::value || !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+template <typename Char>
+struct is_like_std_string<fmt::basic_string_view<Char>> : std::true_type {};
+
+template <typename... Ts> struct conditional_helper {};
+
+template <typename T, typename _ = void> struct is_range_ : std::false_type {};
+
+#if !FMT_MSC_VER || FMT_MSC_VER > 1800
+template <typename T>
+struct is_range_<
+    T, conditional_t<false,
+                     conditional_helper<decltype(std::declval<T>().begin()),
+                                        decltype(std::declval<T>().end())>,
+                     void>> : std::true_type {};
+#endif
+
+/// tuple_size and tuple_element check.
+template <typename T> class is_tuple_like_ {
+  template <typename U>
+  static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
+  template <typename> static void check(...);
+
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+// Check for integer_sequence
+#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
+template <typename T, T... N>
+using integer_sequence = std::integer_sequence<T, N...>;
+template <std::size_t... N> using index_sequence = std::index_sequence<N...>;
+template <std::size_t N>
+using make_index_sequence = std::make_index_sequence<N>;
+#else
+template <typename T, T... N> struct integer_sequence {
+  using value_type = T;
+
+  static FMT_CONSTEXPR std::size_t size() { return sizeof...(N); }
+};
+
+template <std::size_t... N>
+using index_sequence = integer_sequence<std::size_t, N...>;
+
+template <typename T, std::size_t N, T... Ns>
+struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
+template <typename T, T... Ns>
+struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
+
+template <std::size_t N>
+using make_index_sequence = make_integer_sequence<std::size_t, N>;
+#endif
+
+template <class Tuple, class F, size_t... Is>
+void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) FMT_NOEXCEPT {
+  using std::get;
+  // using free function get<I>(T) now.
+  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+  (void)_;  // blocks warnings
+}
+
+template <class T>
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
+    T const&) {
+  return {};
+}
+
+template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
+  const auto indexes = get_indexes(tup);
+  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+}
+
+template <typename Arg, FMT_ENABLE_IF(!is_like_std_string<
+                                      typename std::decay<Arg>::type>::value)>
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&) {
+  return add_space ? " {}" : "{}";
+}
+
+template <typename Arg, FMT_ENABLE_IF(is_like_std_string<
+                                      typename std::decay<Arg>::type>::value)>
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&) {
+  return add_space ? " \"{}\"" : "\"{}\"";
+}
+
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) {
+  return add_space ? " \"{}\"" : "\"{}\"";
+}
+FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
+  return add_space ? L" \"{}\"" : L"\"{}\"";
+}
+
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) {
+  return add_space ? " '{}'" : "'{}'";
+}
+FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
+  return add_space ? L" '{}'" : L"'{}'";
+}
+
+}  // namespace internal
+
+template <typename T> struct is_tuple_like {
+  static FMT_CONSTEXPR_DECL const bool value =
+      internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
+};
+
+template <typename TupleT, typename Char>
+struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
+ private:
+  // C++11 generic lambda for format()
+  template <typename FormatContext> struct format_each {
+    template <typename T> void operator()(const T& v) {
+      if (i > 0) {
+        if (formatting.add_prepostfix_space) {
+          *out++ = ' ';
+        }
+        out = internal::copy(formatting.delimiter, out);
+      }
+      out = format_to(out,
+                      internal::format_str_quoted(
+                          (formatting.add_delimiter_spaces && i > 0), v),
+                      v);
+      ++i;
+    }
+
+    formatting_tuple<Char>& formatting;
+    std::size_t& i;
+    typename std::add_lvalue_reference<decltype(
+        std::declval<FormatContext>().out())>::type out;
+  };
+
+ public:
+  formatting_tuple<Char> formatting;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
+
+  template <typename FormatContext = format_context>
+  auto format(const TupleT& values, FormatContext& ctx) -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    std::size_t i = 0;
+    internal::copy(formatting.prefix, out);
+
+    internal::for_each(values, format_each<FormatContext>{formatting, i, out});
+    if (formatting.add_prepostfix_space) {
+      *out++ = ' ';
+    }
+    internal::copy(formatting.postfix, out);
+
+    return ctx.out();
+  }
+};
+
+template <typename T, typename Char> struct is_range {
+  static FMT_CONSTEXPR_DECL const bool value =
+      internal::is_range_<T>::value &&
+      !internal::is_like_std_string<T>::value &&
+      !std::is_convertible<T, std::basic_string<Char>>::value &&
+      !std::is_constructible<internal::std_string_view<Char>, T>::value;
+};
+
+template <typename RangeT, typename Char>
+struct formatter<RangeT, Char,
+                 enable_if_t<fmt::is_range<RangeT, Char>::value>> {
+  formatting_range<Char> formatting;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format(const RangeT& values,
+                                          FormatContext& ctx) {
+    auto out = internal::copy(formatting.prefix, ctx.out());
+    std::size_t i = 0;
+    for (auto it = values.begin(), end = values.end(); it != end; ++it) {
+      if (i > 0) {
+        if (formatting.add_prepostfix_space) *out++ = ' ';
+        out = internal::copy(formatting.delimiter, out);
+      }
+      out = format_to(out,
+                      internal::format_str_quoted(
+                          (formatting.add_delimiter_spaces && i > 0), *it),
+                      *it);
+      if (++i > formatting.range_length_limit) {
+        out = format_to(out, " ... <other elements>");
+        break;
+      }
+    }
+    if (formatting.add_prepostfix_space) *out++ = ' ';
+    return internal::copy(formatting.postfix, out);
+  }
+};
+
+template <typename Char, typename... T> struct tuple_arg_join : internal::view {
+  const std::tuple<T...>& tuple;
+  basic_string_view<Char> sep;
+
+  tuple_arg_join(const std::tuple<T...>& t, basic_string_view<Char> s)
+      : tuple{t}, sep{s} {}
+};
+
+template <typename Char, typename... T>
+struct formatter<tuple_arg_join<Char, T...>, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format(
+      const tuple_arg_join<Char, T...>& value, FormatContext& ctx) {
+    return format(value, ctx, internal::make_index_sequence<sizeof...(T)>{});
+  }
+
+ private:
+  template <typename FormatContext, size_t... N>
+  typename FormatContext::iterator format(
+      const tuple_arg_join<Char, T...>& value, FormatContext& ctx,
+      internal::index_sequence<N...>) {
+    return format_args(value, ctx, std::get<N>(value.tuple)...);
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format_args(
+      const tuple_arg_join<Char, T...>&, FormatContext& ctx) {
+    // NOTE: for compilers that support C++17, this empty function instantiation
+    // can be replaced with a constexpr branch in the variadic overload.
+    return ctx.out();
+  }
+
+  template <typename FormatContext, typename Arg, typename... Args>
+  typename FormatContext::iterator format_args(
+      const tuple_arg_join<Char, T...>& value, FormatContext& ctx,
+      const Arg& arg, const Args&... args) {
+    using base = formatter<typename std::decay<Arg>::type, Char>;
+    auto out = ctx.out();
+    out = base{}.format(arg, ctx);
+    if (sizeof...(Args) > 0) {
+      out = std::copy(value.sep.begin(), value.sep.end(), out);
+      ctx.advance_to(out);
+      return format_args(value, ctx, args...);
+    }
+    return out;
+  }
+};
+
+/**
+  \rst
+  Returns an object that formats `tuple` with elements separated by `sep`.
+
+  **Example**::
+
+    std::tuple<int, char> t = {1, 'a'};
+    fmt::print("{}", fmt::join(t, ", "));
+    // Output: "1, a"
+  \endrst
+ */
+template <typename... T>
+FMT_CONSTEXPR tuple_arg_join<char, T...> join(const std::tuple<T...>& tuple,
+                                              string_view sep) {
+  return {tuple, sep};
+}
+
+template <typename... T>
+FMT_CONSTEXPR tuple_arg_join<wchar_t, T...> join(const std::tuple<T...>& tuple,
+                                                 wstring_view sep) {
+  return {tuple, sep};
+}
+
+/**
+  \rst
+  Returns an object that formats `initializer_list` with elements separated by
+  `sep`.
+
+  **Example**::
+
+    fmt::print("{}", fmt::join({1, 2, 3}, ", "));
+    // Output: "1, 2, 3"
+  \endrst
+ */
+template <typename T>
+arg_join<internal::iterator_t<const std::initializer_list<T>>, char> join(
+    std::initializer_list<T> list, string_view sep) {
+  return join(std::begin(list), std::end(list), sep);
+}
+
+template <typename T>
+arg_join<internal::iterator_t<const std::initializer_list<T>>, wchar_t> join(
+    std::initializer_list<T> list, wstring_view sep) {
+  return join(std::begin(list), std::end(list), sep);
+}
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_RANGES_H_