block.h

Go to the documentation of this file.

#pragma once

 
#include "base/dsp_buffer.h"
#include "core/exception.h"
#include "dsp/base/stream.h"
#include "nlohmann/json.hpp"
#include <mutex>
#include <thread>
#include <vector>
 
namespace satdump
{
    namespace ndsp // TODOREWORK back to normal DSP!
    {
        enum BlockIOType
        {
            DSP_SAMPLE_TYPE_CF32,
            DSP_SAMPLE_TYPE_F32,
            DSP_SAMPLE_TYPE_S16,
            DSP_SAMPLE_TYPE_S8,
            DSP_SAMPLE_TYPE_U8,
        };

        struct BlockIO
        {
            std::string name;
            BlockIOType type;
            std::shared_ptr<DSPStream> fifo = nullptr;
            std::shared_ptr<void> blkdata = nullptr;
 
            // TODOREWORK DOCUMENT
            uint64_t samplerate = 0;
            double frequency = 0;
        };
 
        // TODOREWORK cleanup!!!!
        inline void add_param_simple(nlohmann::ordered_json &p, std::string id, std::string type, std::string name = "")
        {
            p[id]["type"] = type;
            if (name != "")
                p[id]["name"] = name;
        }
 
        inline void add_param_range(nlohmann::ordered_json &p, std::string id, std::string type, nlohmann::ordered_json min, nlohmann::ordered_json max, nlohmann::ordered_json step,
                                    std::string name = "")
        {
            p[id]["type"] = type;
            if (name != "")
                p[id]["name"] = name;
            p[id]["range"] = {min, max, step};
        }
 
        inline void add_param_list(nlohmann::ordered_json &p, std::string id, std::string type, nlohmann::json list, std::string name = "")
        {
            p[id]["type"] = type;
            if (name != "")
                p[id]["name"] = name;
            p[id]["list"] = list;
        }

        class Block
        {
        public:
            const std::string d_id;
 
        protected:
            std::vector<BlockIO> inputs;
            std::vector<BlockIO> outputs;
 
        public:
            virtual std::vector<BlockIO> get_inputs() { return inputs; }

            virtual std::vector<BlockIO> get_outputs() { return outputs; }

            virtual void set_input(BlockIO f, int i)
            {
                if (i >= (int)inputs.size())
                    throw satdump_exception("Input index " + std::to_string(i) + " does not exist for " + d_id + "!");
                if (inputs[i].type != f.type)
                    throw satdump_exception("Input type " + std::to_string(inputs[i].type) + " not compatible with " + std::to_string(f.type) + " for " + d_id + "!");
                inputs[i].fifo = f.fifo;
            }

            virtual BlockIO get_output(int i, int nbuf)
            {
                if (i >= (int)outputs.size())
                    throw satdump_exception("Ouput index " + std::to_string(i) + " does not exist for " + d_id + "!");
                if (nbuf > 0)
                    outputs[i].fifo = std::make_shared<DSPStream>(nbuf);
                return outputs[i];
            }

            void link(Block *ptr, int output_index, int input_index, int nbuf) { set_input(ptr->get_output(output_index, nbuf), input_index); }
 
        private:
            bool blk_should_run;
            std::mutex blk_th_mtx;
            std::thread blk_th;
            void run()
            {
                while (blk_should_run)
                    if (work())
                        break;
            }
 
        protected:
            bool work_should_exit;

            virtual bool work() = 0;
 
            // TODOREWORK
            bool is_work_running() { return blk_should_run; }
 
        public:
            Block(std::string id, std::vector<BlockIO> in = {}, std::vector<BlockIO> out = {}) : d_id(id), inputs(in), outputs(out)
            {
                blk_should_run = false;
                work_should_exit = false;
            }
 
            virtual ~Block()
            {
                if (blk_should_run || blk_th.joinable())
                    throw satdump_exception("Block wasn't properly stopped before destructor was called!");
            }
 
        public:
            virtual bool is_async() { return inputs.size() == 0; }
 
        public:
            enum cfg_res_t
            {
                RES_OK = 0,
                RES_LISTUPD = 1,
                RES_IOUPD = 2,
                RES_ERR = 3,
            };

            virtual nlohmann::ordered_json get_cfg_list() { return {}; }

            virtual nlohmann::json get_cfg(std::string key) = 0;

            nlohmann::json get_cfg()
            {
                nlohmann::json p;
                auto v = get_cfg_list();
                for (auto &v2 : v.items())
                    p[v2.key()] = get_cfg(v2.key());
                return p;
            }

            virtual cfg_res_t set_cfg(std::string key, nlohmann::json v) = 0;

            cfg_res_t set_cfg(nlohmann::json v)
            {
                cfg_res_t r = RES_OK;
                for (auto &i : v.items())
                {
                    cfg_res_t r2 = set_cfg(i.key(), i.value());
                    if (r2 > r)
                        r = r2;
                }
                return r;
            }
 
        protected:
            template <typename T>
            void setValFromJSONIfExists(T &v, nlohmann::json p)
            {
                if (!p.is_null())
                    v = p.get<T>();
            }
 
        protected:
            virtual void init() {}
 
        public:
            virtual void start()
            {
                if (blk_should_run || blk_th.joinable())
                    throw satdump_exception("Block wasn't properly stopped before start() was called again!");
 
                init();
                work_should_exit = false;
                blk_should_run = true;
                blk_th = std::thread(&Block::run, this);
#ifndef _WIN32
#ifndef __APPLE__
                std::string th_id = d_id;
                th_id.resize(15);
                pthread_setname_np(blk_th.native_handle(), th_id.c_str());
#endif
#endif
            }

            virtual void stop(bool stop_now = false, bool force = false)
            { // TODOREWORK allow sending terminator in this function?
                if (stop_now)
                    work_should_exit = true;
                if (force)
                    blk_should_run = false;
 
                blk_th_mtx.lock();
                if (blk_th.joinable())
                    blk_th.join();
                blk_th_mtx.unlock();
                blk_should_run = false;
            }
        };
    } // namespace ndsp
} // namespace satdump