Changed project structure

source_modules/rtl_tcp_source/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.13)
+project(rtl_tcp_source)
+
+if (MSVC)
+    add_compile_options(/O2 /Ob2 /std:c++17 /EHsc)
+elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    add_compile_options(-O3 -std=c++17 -Wno-unused-command-line-argument -undefined dynamic_lookup)
+else ()
+    add_compile_options(-O3 -std=c++17)
+endif ()
+
+include_directories("src/")
+
+file(GLOB SRC "src/*.cpp")
+
+add_library(rtl_tcp_source SHARED ${SRC})
+target_link_libraries(rtl_tcp_source PRIVATE sdrpp_core)
+set_target_properties(rtl_tcp_source PROPERTIES PREFIX "")
+
+if(WIN32)
+  target_link_libraries(rtl_tcp_source PRIVATE wsock32 ws2_32)
+endif()
+
+# Install directives
+install(TARGETS rtl_tcp_source DESTINATION lib/sdrpp/plugins)

source_modules/rtl_tcp_source/src/main.cpp

@@ -0,0 +1,383 @@
+#include <rtltcp_client.h>
+#include <imgui.h>
+#include <spdlog/spdlog.h>
+#include <module.h>
+#include <gui/gui.h>
+#include <signal_path/signal_path.h>
+#include <core.h>
+#include <options.h>
+#include <gui/style.h>
+
+#define CONCAT(a, b) ((std::string(a) + b).c_str())
+
+SDRPP_MOD_INFO {
+    /* Name:            */ "rtl_tcp_source",
+    /* Description:     */ "RTL-TCP source module for SDR++",
+    /* Author:          */ "Ryzerth",
+    /* Version:         */ 0, 1, 0,
+    /* Max instances    */ 1
+};
+
+ConfigManager config;
+
+const double sampleRates[] = {
+    250000,
+    1024000,
+    1536000,
+    1792000,
+    1920000,
+    2048000,
+    2160000,
+    2400000,
+    2560000,
+    2880000,
+    3200000
+};
+
+const char* sampleRatesTxt[] = {
+    "250KHz",
+    "1.024MHz",
+    "1.536MHz",
+    "1.792MHz",
+    "1.92MHz",
+    "2.048MHz",
+    "2.16MHz",
+    "2.4MHz",
+    "2.56MHz",
+    "2.88MHz",
+    "3.2MHz"
+};
+
+#define SAMPLE_RATE_COUNT   (sizeof(sampleRates) / sizeof(double))
+
+class RTLTCPSourceModule : public ModuleManager::Instance {
+public:
+    RTLTCPSourceModule(std::string name) {
+        this->name = name;
+
+        sampleRate = 2400000.0;
+
+        int _24id = 0;
+        for (int i = 0; i < SAMPLE_RATE_COUNT; i++) {
+            if (sampleRates[i] == 2400000) { _24id = i; }
+            srTxt += sampleRatesTxt[i];
+            srTxt += '\0';
+        }
+        srId = 7;
+
+        config.acquire();
+        std::string hostStr = config.conf["host"];
+        port = config.conf["port"];
+        double wantedSr = config.conf["sampleRate"];
+        directSamplingMode = config.conf["directSamplingMode"];
+        ppm = config.conf["ppm"];
+        rtlAGC = config.conf["rtlAGC"];
+        tunerAGC = config.conf["tunerAGC"];
+        gain = std::clamp<int>(config.conf["gainIndex"], 0, 28);
+        biasTee = config.conf["biasTee"];
+        offsetTuning = config.conf["offsetTuning"];
+        hostStr = hostStr.substr(0, 1023);
+        strcpy(ip, hostStr.c_str());
+        config.release();
+
+        bool found = false;
+        for (int i = 0; i < SAMPLE_RATE_COUNT; i++) {
+            if (sampleRates[i] == wantedSr) {
+                found = true;
+                srId = i;
+                sampleRate = sampleRates[i];
+                break;
+            }
+        }
+        if (!found) {
+            srId = _24id;
+            sampleRate = sampleRates[_24id];
+        }
+
+        handler.ctx = this;
+        handler.selectHandler = menuSelected;
+        handler.deselectHandler = menuDeselected;
+        handler.menuHandler = menuHandler;
+        handler.startHandler = start;
+        handler.stopHandler = stop;
+        handler.tuneHandler = tune;
+        handler.stream = &stream;
+        sigpath::sourceManager.registerSource("RTL-TCP", &handler);
+    }
+
+    ~RTLTCPSourceModule() {
+        stop(this);
+        sigpath::sourceManager.unregisterSource("RTL-TCP");
+    }
+
+    void postInit() {}
+
+    void enable() {
+        enabled = true;
+    }
+
+    void disable() {
+        enabled = false;
+    }
+
+    bool isEnabled() {
+        return enabled;
+    }
+
+private:
+    static void menuSelected(void* ctx) {
+        RTLTCPSourceModule* _this = (RTLTCPSourceModule*)ctx;
+        core::setInputSampleRate(_this->sampleRate);
+        spdlog::info("RTLTCPSourceModule '{0}': Menu Select!", _this->name);
+    }
+
+    static void menuDeselected(void* ctx) {
+        RTLTCPSourceModule* _this = (RTLTCPSourceModule*)ctx;
+        spdlog::info("RTLTCPSourceModule '{0}': Menu Deselect!", _this->name);
+    }
+    
+    static void start(void* ctx) {
+        RTLTCPSourceModule* _this = (RTLTCPSourceModule*)ctx;
+        if (_this->running) { return; }
+        if (!_this->client.connectToRTL(_this->ip, _this->port)) {
+            spdlog::error("Could not connect to {0}:{1}", _this->ip, _this->port);
+            return;
+        }
+        spdlog::warn("Setting sample rate to {0}", _this->sampleRate);
+        _this->client.setFrequency(_this->freq);
+        _this->client.setSampleRate(_this->sampleRate);
+        _this->client.setPPM(_this->ppm);
+        _this->client.setDirectSampling(_this->directSamplingMode);
+        _this->client.setAGCMode(_this->rtlAGC);
+        _this->client.setBiasTee(_this->biasTee);
+        _this->client.setOffsetTuning(_this->offsetTuning);
+        if (_this->tunerAGC) {
+            _this->client.setGainMode(0);
+        }
+        else {
+            _this->client.setGainMode(1);
+
+            // Setting it twice because for some reason it refuses to do it on the first time
+            _this->client.setGainIndex(_this->gain);
+        }
+        
+        _this->running = true;
+        _this->workerThread = std::thread(worker, _this);
+        spdlog::info("RTLTCPSourceModule '{0}': Start!", _this->name);
+    }
+    
+    static void stop(void* ctx) {
+        RTLTCPSourceModule* _this = (RTLTCPSourceModule*)ctx;
+        if (!_this->running) { return; }
+        _this->running = false;
+        _this->stream.stopWriter();
+        _this->workerThread.join();
+        _this->stream.clearWriteStop();
+        _this->client.disconnect();
+        spdlog::info("RTLTCPSourceModule '{0}': Stop!", _this->name);
+    }
+    
+    static void tune(double freq, void* ctx) {
+        RTLTCPSourceModule* _this = (RTLTCPSourceModule*)ctx;
+        if (_this->running) {
+            _this->client.setFrequency(freq);
+        }
+        _this->freq = freq;
+        spdlog::info("RTLTCPSourceModule '{0}': Tune: {1}!", _this->name, freq);
+    }
+    
+    static void menuHandler(void* ctx) {
+        RTLTCPSourceModule* _this = (RTLTCPSourceModule*)ctx;
+        float menuWidth = ImGui::GetContentRegionAvailWidth();
+        float portWidth = ImGui::CalcTextSize("00000").x + 20;
+
+        if (_this->running) { style::beginDisabled(); }
+
+        ImGui::SetNextItemWidth(menuWidth - portWidth);
+        if (ImGui::InputText(CONCAT("##_ip_select_", _this->name), _this->ip, 1024)) {
+            config.acquire();
+            config.conf["host"] = std::string(_this->ip);
+            config.release(true);
+        }
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(portWidth);
+        if (ImGui::InputInt(CONCAT("##_port_select_", _this->name), &_this->port, 0)) {
+            config.acquire();
+            config.conf["port"] = _this->port;
+            config.release(true);
+        }
+
+        ImGui::SetNextItemWidth(menuWidth);
+        if (ImGui::Combo(CONCAT("##_rtltcp_sr_", _this->name), &_this->srId, _this->srTxt.c_str())) {
+            _this->sampleRate = sampleRates[_this->srId];
+            core::setInputSampleRate(_this->sampleRate);
+            config.acquire();
+            config.conf["sampleRate"] = _this->sampleRate;
+            config.release(true);
+        }
+
+        if (_this->running) { style::endDisabled(); }
+
+        ImGui::LeftLabel("Direct Sampling");
+        ImGui::SetNextItemWidth(menuWidth - ImGui::GetCursorPosX());
+        if (ImGui::Combo(CONCAT("##_rtltcp_ds_", _this->name), &_this->directSamplingMode, "Disabled\0I branch\0Q branch\0")) {
+            if (_this->running) {
+                _this->client.setDirectSampling(_this->directSamplingMode);
+                _this->client.setGainIndex(_this->gain);
+            }
+            config.acquire();
+            config.conf["directSamplingMode"] = _this->directSamplingMode;
+            config.release(true);
+        }
+
+        ImGui::LeftLabel("PPM Correction");
+        ImGui::SetNextItemWidth(menuWidth - ImGui::GetCursorPosX());
+        if (ImGui::InputInt(CONCAT("##_rtltcp_ppm_", _this->name), &_this->ppm, 1, 10)) {
+            if (_this->running) {
+                _this->client.setPPM(_this->ppm);
+            }
+            config.acquire();
+            config.conf["ppm"] = _this->ppm;
+            config.release(true);
+        }
+
+        if (_this->tunerAGC) { style::beginDisabled(); }
+        ImGui::SetNextItemWidth(menuWidth);
+        if (ImGui::SliderInt(CONCAT("##_gain_select_", _this->name), &_this->gain, 0, 28, "")) {
+            if (_this->running) {
+                _this->client.setGainIndex(_this->gain);
+            }
+            config.acquire();
+            config.conf["gainIndex"] = _this->gain;
+            config.release(true);
+        }
+        if (_this->tunerAGC) { style::endDisabled(); }
+
+        if (ImGui::Checkbox(CONCAT("Bias-T##_biast_select_", _this->name), &_this->biasTee)) {
+            if (_this->running) {
+                _this->client.setBiasTee(_this->biasTee);
+            }
+            config.acquire();
+            config.conf["biasTee"] = _this->biasTee;
+            config.release(true);
+        }
+
+        if (ImGui::Checkbox(CONCAT("Offset Tuning##_biast_select_", _this->name), &_this->offsetTuning)) {
+            if (_this->running) {
+                _this->client.setOffsetTuning(_this->offsetTuning);
+            }
+            config.acquire();
+            config.conf["offsetTuning"] = _this->offsetTuning;
+            config.release(true);
+        }
+
+        if (ImGui::Checkbox("RTL AGC", &_this->rtlAGC)) {
+            if (_this->running) {
+                _this->client.setAGCMode(_this->rtlAGC);
+                if (!_this->rtlAGC) {
+                    _this->client.setGainIndex(_this->gain);
+                }
+            }
+            config.acquire();
+            config.conf["rtlAGC"] = _this->rtlAGC;
+            config.release(true);
+        }
+
+        if (ImGui::Checkbox("Tuner AGC", &_this->tunerAGC)) {
+            if (_this->running) {
+                _this->client.setGainMode(!_this->tunerAGC);
+                if (!_this->tunerAGC) {
+                    _this->client.setGainIndex(_this->gain);
+                }
+            }
+            config.acquire();
+            config.conf["tunerAGC"] = _this->tunerAGC;
+            config.release(true);
+        }
+    }
+
+    static void worker(void* ctx) {
+        RTLTCPSourceModule* _this = (RTLTCPSourceModule*)ctx;
+        int blockSize = _this->sampleRate / 200.0f;
+        uint8_t* inBuf = new uint8_t[blockSize * 2];
+
+        while (true) {
+            // Read samples here
+            _this->client.receiveData(inBuf, blockSize * 2);
+            for (int i = 0; i < blockSize; i++) {
+                _this->stream.writeBuf[i].re = ((double)inBuf[i * 2] - 128.0) / 128.0;
+                _this->stream.writeBuf[i].im = ((double)inBuf[(i * 2) + 1] - 128.0) / 128.0;
+            }
+            if (!_this->stream.swap(blockSize)) { break; };
+        }
+
+        delete[] inBuf;
+    }
+
+    std::string name;
+    bool enabled = true;
+    dsp::stream<dsp::complex_t> stream;
+    double sampleRate;
+    SourceManager::SourceHandler handler;
+    std::thread workerThread;
+    RTLTCPClient client;
+    bool running = false;
+    double freq;
+    char ip[1024] = "localhost";
+    int port = 1234;
+    int gain = 0;
+    int ppm = 0;
+    bool rtlAGC = false;
+    bool tunerAGC = false;
+    int directSamplingMode = 0;
+    int srId = 0;
+    bool biasTee = false;
+    bool offsetTuning = false;
+
+    std::string srTxt = "";
+};
+
+MOD_EXPORT void _INIT_() {
+   config.setPath(options::opts.root + "/rtl_tcp_config.json");
+   json defConf;
+   defConf["host"] = "localhost";
+   defConf["port"] = 1234;
+   defConf["sampleRate"] = 2400000.0;
+   defConf["directSamplingMode"] = 0;
+   defConf["ppm"] = 0;
+   defConf["rtlAGC"] = false;
+   defConf["tunerAGC"] = false;
+   defConf["gainIndex"] = 0;
+   defConf["biasTee"] = false;
+   defConf["offsetTuning"] = false;
+   config.load(defConf);
+   config.enableAutoSave();
+
+    config.acquire();
+    if (!config.conf.contains("biasTee")) {
+        config.conf["biasTee"] = false;
+    }
+    if (!config.conf.contains("offsetTuning")) {
+        config.conf["offsetTuning"] = false;
+    }
+    if (!config.conf.contains("ppm")) {
+        config.conf["ppm"] = 0;
+    }
+    if (!config.conf.contains("sampleRate")) {
+        config.conf["sampleRate"] = 2400000.0;
+    }
+    config.release(true);
+}
+
+MOD_EXPORT ModuleManager::Instance* _CREATE_INSTANCE_(std::string name) {
+    return new RTLTCPSourceModule(name);
+}
+
+MOD_EXPORT void _DELETE_INSTANCE_(ModuleManager::Instance* instance) {
+    delete (RTLTCPSourceModule*)instance;
+}
+
+MOD_EXPORT void _END_() {
+    config.disableAutoSave();
+    config.save();
+}

source_modules/rtl_tcp_source/src/rtltcp_client.h

@@ -0,0 +1,202 @@
+#pragma once
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#ifdef _WIN32
+#include <WinSock2.h>
+#include <WS2tcpip.h>
+#else
+#include <unistd.h>
+#include <strings.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h> 
+#endif
+
+#ifdef _WIN32
+#define __attribute__(x)
+#pragma pack(push, 1)
+#endif
+struct command_t{
+	unsigned char cmd;
+	unsigned int param;
+}__attribute__((packed));
+#ifdef _WIN32
+#pragma pack(pop)
+#endif
+
+class RTLTCPClient {
+public:
+    RTLTCPClient() {
+        
+    }
+
+    bool connectToRTL(char* host, uint16_t port) {
+        if (connected) {
+            return true;
+        }
+
+#ifdef _WIN32
+        struct addrinfo *result = NULL;
+        struct addrinfo *ptr = NULL;
+        struct addrinfo hints;
+
+        WSADATA wsaData;
+        WSAStartup(MAKEWORD(2,2), &wsaData);
+
+        ZeroMemory( &hints, sizeof(hints) );
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_protocol = IPPROTO_TCP;
+
+        char buf[128];
+        sprintf(buf, "%hu", port);
+
+        int iResult = getaddrinfo(host, buf, &hints, &result);
+        if (iResult != 0) {
+            // TODO: log error
+            printf("\n%s\n", gai_strerror(iResult));
+            WSACleanup();
+            return false;
+        }
+        ptr = result;
+
+        sock = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
+
+        if (sock == INVALID_SOCKET) {
+            // TODO: log error
+            printf("B");
+            freeaddrinfo(result);
+            WSACleanup();
+            return false;
+        }
+
+        iResult = connect(sock, ptr->ai_addr, (int)ptr->ai_addrlen);
+        if (iResult == SOCKET_ERROR) {
+            printf("C");
+            closesocket(sock);
+            freeaddrinfo(result);
+            WSACleanup();
+            return false;
+        }
+        freeaddrinfo(result);
+#else
+        sockfd = socket(AF_INET, SOCK_STREAM, 0);
+        if (sockfd < 0) {
+            // TODO: Log error
+            return false;
+        }
+        struct hostent *server = gethostbyname(host);
+        struct sockaddr_in serv_addr;
+        bzero(&serv_addr, sizeof(struct sockaddr_in));
+        serv_addr.sin_family = AF_INET;
+        bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr, server->h_length);
+        serv_addr.sin_port = htons(port);
+        if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0) {
+            // TODO: log error
+            return false;
+        }
+#endif
+
+        connected = true;
+
+        printf("Connected");
+
+        return true;
+    }
+
+    void disconnect() {
+        if (!connected) {
+            return;
+        }
+#ifdef _WIN32
+        closesocket(sock);
+        WSACleanup();
+#else
+        close(sockfd);
+#endif
+        connected = false;
+    }
+
+    // struct command_t {
+    //     uint8_t cmd;
+    //     uint32_t arg;
+    // };
+
+    void sendCommand(uint8_t command, uint32_t param) {
+        command_t cmd;
+        cmd.cmd = command;
+        cmd.param = htonl(param);
+#ifdef _WIN32
+        send(sock, (char*)&cmd, sizeof(command_t), 0);  
+#else
+        (void)write(sockfd, &cmd, sizeof(command_t));
+#endif
+    }
+
+    void receiveData(uint8_t* buf, size_t count) {
+        int received = 0;
+        int ret = 0;
+        while (received < count) {
+#ifdef _WIN32
+            ret = recv(sock, (char*)&buf[received], count - received, 0);
+#else
+            ret = read(sockfd, &buf[received], count - received);
+#endif
+            if (ret <= 0) { return; }
+            received += ret;
+        }
+    }
+
+    void setFrequency(double freq) {
+        sendCommand(1, freq);
+    }
+
+    void setSampleRate(double sr) {
+        sendCommand(2, sr);
+    }
+
+    void setGainMode(int mode) {
+        sendCommand(3, mode);
+    }
+
+    void setGain(double gain) {
+        sendCommand(4, gain);
+    }
+
+    void setPPM(int ppm) {
+        sendCommand(5, (uint32_t)ppm);
+    }
+
+    void setAGCMode(int mode) {
+        sendCommand(8, mode);
+    }
+
+    void setDirectSampling(int mode) {
+        sendCommand(9, mode);
+    }
+
+    void setOffsetTuning(bool enabled) {
+        sendCommand(10, enabled);
+    }
+
+    void setGainIndex(int index) {
+        sendCommand(13, index);
+    }
+
+    void setBiasTee(bool enabled) {
+        sendCommand(14, enabled);
+    }
+
+private:
+#ifdef _WIN32
+    SOCKET sock;
+#else
+    int sockfd;
+#endif
+    
+    bool connected = false;
+
+};