JS8.h

Go to the documentation of this file.

 
#ifndef __JS8
#define __JS8
 
#include <QObject>
#include <QSemaphore>
#include <QThread>
#include <array>
#include <functional>
#include <string>
#include <variant>
 
namespace JS8 {
Q_NAMESPACE
 
namespace Costas {
enum class Type { ORIGINAL, MODIFIED };

using Array = std::array<std::array<int, 7>, 3>;

constexpr auto array = [] {
    constexpr auto COSTAS =
        std::array{std::array{std::array{4, 2, 5, 6, 1, 3, 0},
                              std::array{4, 2, 5, 6, 1, 3, 0},
                              std::array{4, 2, 5, 6, 1, 3, 0}},
                   std::array{std::array{0, 6, 2, 3, 5, 4, 1},
                              std::array{1, 5, 0, 2, 3, 6, 4},
                              std::array{2, 5, 0, 6, 4, 1, 3}}};
 
    return [COSTAS](Type type) -> Array const & {
        return COSTAS[static_cast<std::underlying_type_t<Type>>(type)];
    };
}();
} // namespace Costas

void encode(int type, Costas::Array const &costas, const char *message,
            int *tones);
 
namespace Event {
struct DecodeStarted {
    int submodes; 
};

struct SyncStart {
    int position; 
    int size;     
};

struct SyncState {
    enum class Type { CANDIDATE, DECODED } type;
    int mode;       
    float frequency;
    float dt;       
    union {
        int candidate; 
        float decoded; 
    } sync;
};

struct Decoded {
    int utc;           
    int snr;           
    float xdt;         
    float frequency;   
    std::string data;  
    int type;          
    float quality;     
    int mode;          
};

struct DecodeFinished {
    std::size_t decoded; 
};

using Variant =
    std::variant<DecodeStarted, SyncStart, SyncState, Decoded, DecodeFinished>;

using Emitter = std::function<void(Variant const &)>;
} // namespace Event

class Worker;

class Decoder : public QObject {
        Q_OBJECT
 
        QSemaphore m_semaphore; 
        QThread m_thread;       
        Worker *m_worker;       
 
    public:
        Decoder(QObject *parent = nullptr);
 
    signals:

        void decodeEvent(Event::Variant const &);
 
    public slots:

        void start(QThread::Priority priority);

        void quit();

        void decode();
};
} // namespace JS8
 
#endif