@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-rt/lib/src/services/wav_reader.h

@@ -0,0 +1,213 @@
+#pragma once 
+
+#include <files.h>
+#include <types/types.h>
+#include <service.h>
+
+/**
+ * Service Documentation
+ * Service ID: wav-reader
+ * Service Name: WavReader
+ * Runtime: hkp-rt
+ * Modes: unspecified
+ * Key Config: runtime-specific state/config
+ * IO: in=runtime-dependent -> out=runtime-dependent
+ * Arrays: service-dependent
+ * Binary: supported (service-dependent)
+ * MixedData: native in runtime (service-dependent usage)
+ *
+ * `filePath` lies inside a folder this server gives boards (files.h).
+ */
+namespace hkp {
+
+class WavReader : public Service
+{
+public:
+  static std::string serviceId() { return "wav-reader"; }
+
+  WavReader(const std::string& instanceId) 
+    : Service(instanceId, serviceId())
+  {
+    
+  }
+
+  ~WavReader()
+  {
+   
+  }
+
+  json configure(Data data) override
+  {
+    auto buf = getJSONFromData(data);
+    if (buf)
+    {
+      updateIfNeeded(m_filePath, (*buf)["filePath"]);
+    }
+
+    return Service::configure(data);
+  }
+
+  std::string getServiceId() const override
+  {
+    return serviceId();
+  }
+
+  json getState() const override
+  {
+    auto state = json{};
+    if (!m_filePath.empty())
+    {
+      state["filePath"] = m_filePath;
+    }
+    
+    
+    return Service::mergeBypassState(state);
+  }
+
+
+  Data process(Data data = Undefined()) override
+  {
+    if (m_filePath.empty())
+    {
+      std::cerr << "WavReader service: no file path provided" << std::endl;
+      return Null();
+    }
+
+    std::string problem;
+    auto path = files::resolve(m_filePath, problem);
+    if (!path)
+    {
+      std::cerr << "WavReader service: " << problem << std::endl;
+      return Null();
+    }
+    auto file = files::input(*path);
+    if (!file.is_open())
+    {
+      std::cerr << "WavReader service: failed to open file: " << m_filePath << std::endl;
+      return Null();
+    } 
+
+    std::vector<uint8_t> buffer((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+    file.close();
+
+    auto pcm = readWavFile(buffer);
+    if (!pcm)
+    {
+      std::cerr << "WavReader service: failed to read WAV file: " << m_filePath << std::endl;
+      return Null();
+    }
+
+    return Data(*pcm);
+  }
+
+  std::optional<std::vector<uint8_t>> readWavFile(const std::vector<uint8_t>& buffer)
+  {
+    if (buffer.size() < 44) // Minimum WAV header size
+    {
+      std::cerr << "readWavFile: Buffer too small to contain a valid WAV file" << std::endl;
+      return std::nullopt;
+    }
+
+    // Parse the WAV header
+    const uint8_t* data = buffer.data();
+
+    // Check the "RIFF" chunk descriptor
+    if (std::string(data, data + 4) != "RIFF")
+    {
+      std::cerr << "readWavFile: Missing RIFF header" << std::endl;
+      return std::nullopt;
+    }
+
+    // Check the "WAVE" format
+    if (std::string(data + 8, data + 12) != "WAVE")
+    {
+      std::cerr << "readWavFile: Missing WAVE format" << std::endl;
+      return std::nullopt;
+    }
+
+    // Locate the "fmt " subchunk
+    size_t fmtChunkOffset = 12;
+    while (fmtChunkOffset + 8 <= buffer.size())
+    {
+      std::string chunkId(data + fmtChunkOffset, data + fmtChunkOffset + 4);
+      uint32_t chunkSize = *reinterpret_cast<const uint32_t*>(data + fmtChunkOffset + 4);
+
+      if (chunkId == "fmt ")
+      {
+        break;
+      }
+
+      fmtChunkOffset += 8 + chunkSize;
+    }
+
+    if (fmtChunkOffset + 8 > buffer.size())
+    {
+      std::cerr << "readWavFile: Missing fmt chunk" << std::endl;
+      return std::nullopt;
+    }
+
+    // Parse the "fmt " chunk
+    uint16_t audioFormat = *reinterpret_cast<const uint16_t*>(data + fmtChunkOffset + 8);
+    uint16_t numChannels = *reinterpret_cast<const uint16_t*>(data + fmtChunkOffset + 10);
+    uint32_t sampleRate = *reinterpret_cast<const uint32_t*>(data + fmtChunkOffset + 12);
+    uint16_t bitsPerSample = *reinterpret_cast<const uint16_t*>(data + fmtChunkOffset + 22);
+
+    if (audioFormat != 1) // PCM format
+    {
+      std::cerr << "readWavFile: Unsupported audio format (only PCM is supported)" << std::endl;
+      return std::nullopt;
+    }
+
+    if (bitsPerSample != 16)
+    {
+      std::cerr << "readWavFile: Unsupported bits per sample (only 16-bit is supported)" << std::endl;
+      return std::nullopt;
+    }
+
+    // Locate the "data" subchunk
+    size_t dataChunkOffset = fmtChunkOffset + 8 + *reinterpret_cast<const uint32_t*>(data + fmtChunkOffset + 4);
+    while (dataChunkOffset + 8 <= buffer.size())
+    {
+      std::string chunkId(data + dataChunkOffset, data + dataChunkOffset + 4);
+      uint32_t chunkSize = *reinterpret_cast<const uint32_t*>(data + dataChunkOffset + 4);
+
+      if (chunkId == "data")
+      {
+        // Extract raw PCM data
+        size_t dataStart = dataChunkOffset + 8;
+        size_t dataEnd = dataStart + chunkSize;
+
+        if (dataEnd > buffer.size())
+        {
+          std::cerr << "readWavFile: Data chunk size exceeds buffer size" << std::endl;
+          return std::nullopt;
+        }
+
+        std::vector<float> floatSamples;
+        const int16_t* samples = reinterpret_cast<const int16_t*>(data + dataStart);
+        size_t numSamples = chunkSize / sizeof(int16_t);
+
+        for (size_t i = 0; i < numSamples; ++i)
+        {
+          floatSamples.push_back(samples[i] / 32768.0f); // Normalize 16-bit PCM to float [-1.0, 1.0]
+        }
+
+        std::vector<uint8_t> pcmData(reinterpret_cast<uint8_t*>(floatSamples.data()), 
+                   reinterpret_cast<uint8_t*>(floatSamples.data() + floatSamples.size()));
+        return pcmData;
+      }
+
+      dataChunkOffset += 8 + chunkSize;
+    }
+
+    std::cerr << "readWavFile: Missing data chunk" << std::endl;
+    return std::nullopt;
+  }  
+
+private: 
+  std::string m_filePath;
+};
+
+
+
+}

package/bundle/hkp-rt/lib/src/services/websocket_client_service.h

@@ -0,0 +1,182 @@
+#pragma once
+
+#include <thread>
+
+#include <boost/asio.hpp>
+#include <types/types.h>
+#include <service.h>
+#include <common/websocket_config.h>
+#include <common/websocket_client_session.h>
+
+/**
+ * Service Documentation
+ * Service ID: websocket-client
+ * Service Name: WebsocketClientService
+ * Runtime: hkp-rt
+ * Modes: unspecified
+ * Key Config: runtime-specific state/config
+ * IO: in=runtime-dependent -> out=runtime-dependent
+ * Arrays: service-dependent
+ * Binary: supported (service-dependent)
+ * MixedData: native in runtime (service-dependent usage)
+ */
+namespace hkp {
+
+class WebsocketClientService : public Service
+{
+public:
+  static std::string serviceId() { return "websocket-client"; } 
+  
+  WebsocketClientService(const std::string& instanceId)
+      : Service(instanceId, serviceId())
+      , m_state{{ "mode", "writeOnly" }}
+  {
+  }
+
+  ~WebsocketClientService()
+  {
+    stop();
+  }
+
+  void start()
+  {
+    if (m_session)
+    {
+      stop();
+      m_ioc.restart();
+    }
+
+    if (m_config.host.empty() || m_config.port.empty() || m_config.path.empty())
+    {
+      throw std::runtime_error("WebsockeClient: not configured correctly");
+    }
+
+    m_session = std::make_shared<WebsocketClientSession>(m_ioc, m_config.host, m_config.port, m_config.path);
+    m_t = std::thread(&WebsocketClientService::run, this);
+  }
+
+  void stop()
+  {
+    if (m_session)
+    {
+      m_session->close();
+      m_ioc.stop();
+      m_t.join();
+    }
+  }
+
+  json configure(Data data) override
+  {
+    auto buf = getJSONFromData(data);
+    if (buf)
+    { 
+      m_config.update(*buf);
+    }
+
+    auto mode = (*buf)["mode"];
+    if (!mode.is_null() && 
+         mode == "writeOnly" || 
+         mode == "readOnly" || 
+         mode == "writeProcessAcc") {
+      m_state["mode"] = mode;
+    }
+
+     if (mode == "writeProcessAcc")
+    {
+      m_accumulated = std::make_shared<FloatRingBuffer>(m_instanceId);
+    }
+    
+    return Service::configure(data);
+  }
+
+  bool onBypassChanged(bool bypass) override
+  {
+    if (bypass)
+    {
+      stop();
+    }
+    else // request to start websocket
+    {
+      if (!m_config.isValid())
+      {
+        return true; // still bypassed
+      }
+      start();
+    }
+    return bypass;
+  }
+
+  Data process(Data data) override
+  {
+    std::string mode = m_state["mode"];
+    if (mode == "writeOnly" || mode == "writeProcessAcc")
+    {
+      if (m_session->isConnected()) 
+      {
+        m_session->signalSend(data);
+      }
+    }
+    
+    return mode == "writeProcessAcc" ? m_accumulated : data;
+  }
+
+  std::string getServiceId() const override
+  {
+    return serviceId();
+  }
+
+  json getState() const override
+  {
+    auto state = m_config.serialise();
+    state.update(m_state);
+    return Service::mergeBypassState(state);
+  }
+
+  void onSessionData(beast::flat_buffer& buffer, std::size_t bytes_transferred, bool isBinary)
+  {
+    std::string mode = m_state["mode"];
+    if (mode == "readOnly")
+    {
+      auto data = flatBufferToData(buffer, isBinary);
+      next(data);
+      return;
+    }
+    else if (mode == "writeProcessAcc")
+    {
+      FloatRingBuffer::createFromSerialised(buffer, buffer.size(), *m_accumulated);
+      return;
+    }
+    else
+    {
+      std::cout << "WebsocketClientService::onSessionData() received: " << bytes_transferred << std::endl;
+    }
+  }
+
+private:
+  void run()
+  {
+    try
+    {
+      m_session->start(
+        "client-" + m_instanceName + "-" + m_instanceId,  
+        std::bind(&WebsocketClientService::onSessionData, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
+      );
+      m_ioc.run();
+    } 
+    catch (...)
+    {
+      std::cerr << "WebsocketClientService: caught unhandled exception: " << std::endl;
+    }
+  }
+
+private:
+  json m_state;
+  boost::asio::io_context m_ioc;
+  std::shared_ptr<WebsocketClientSession> m_session;
+  std::thread m_t;
+  WebsocketConfig m_config;
+
+  std::shared_ptr<FloatRingBuffer> m_accumulated; // only available when accumulating data mode
+};
+
+}

package/bundle/hkp-rt/lib/src/services/websocket_reader.h

@@ -0,0 +1,148 @@
+#pragma once
+
+#include <thread>
+
+#include <types/types.h>
+#include <service.h>
+#include <common/websocket_config.h>
+
+#include "./receiver_session.h"
+
+/**
+ * Service Documentation
+ * Service ID: websocket-reader
+ * Service Name: WebsocketReader
+ * Runtime: hkp-rt
+ * Modes: unspecified
+ * Key Config: runtime-specific state/config
+ * IO: in=runtime-dependent -> out=runtime-dependent
+ * Arrays: service-dependent
+ * Binary: supported (service-dependent)
+ * MixedData: native in runtime (service-dependent usage)
+ */
+namespace hkp {
+
+class WebsocketReader : public Service
+{
+public:
+  static std::string serviceId() { return "websocket-reader"; }
+
+  WebsocketReader(const std::string& instanceId) 
+    : Service(instanceId, serviceId())
+    , m_buffer(std::make_shared<FloatRingBuffer>(instanceId))
+  {
+  }
+
+  ~WebsocketReader()
+  {
+    stop();
+  }
+
+  void start()
+  {
+    if (m_session)
+    {
+      stop();
+      m_ioc.restart();
+    }
+
+    if (!m_config.isValid())
+    {
+      throw std::runtime_error("WebsocketReader: not configured correctly");
+    }
+    m_session = std::make_shared<ReceiverSession>(m_ioc, m_config.host, m_config.port, m_config.path);
+    m_t = std::thread(&WebsocketReader::run, this);
+  }
+
+  void stop()
+  {
+    if (m_session)
+    {
+      m_session->close();
+      m_ioc.stop();
+      m_t.join();
+      std::cout << "WebsocketReader::stop() thread joined" << std::endl;
+    }
+  }
+
+  json configure(Data data) override
+  {
+    auto buf = getJSONFromData(data);
+    if (buf)
+    {
+      m_config.update(*buf);
+    }
+    return Service::configure(data);
+  }
+
+
+  bool onBypassChanged(bool bypass) override
+  {
+    if (bypass)
+    {
+      stop();
+    }
+    else // request to start websocket
+    {
+      if (!m_config.isValid())
+      {
+        return true; // still bypassed
+      }
+      start();
+    }
+    return bypass;
+  }
+
+  Data process(Data data) override
+  {
+    return m_buffer;
+  }
+
+  std::string getServiceId() const override
+  {
+    return serviceId();
+  }
+
+  json getState() const override
+  {
+    auto state = m_config.serialise();
+    return Service::mergeBypassState(state);
+  }
+
+private:
+  void run()
+  {
+    try
+    {
+      auto runWithCallback = true; // otherwise collect incoming data in shared ring buffer
+      if (runWithCallback)
+      {
+        m_session->start("reader", [this](Data data){ next(data); });
+      }
+      else 
+      {
+        m_session->start("reader", m_buffer);
+      }
+      
+      m_ioc.run();
+      std::cout << "Finishing Websocket Reader" << std::endl;
+    } 
+    catch (std::runtime_error err)
+    {
+      std::cerr << "WebsocketReader runtime error: " << err.what() << " config: " << m_config << std::endl;
+    }
+    catch (...) 
+    {
+      std::cerr << "WebsocketReader unknown error: " << m_config << std::endl;
+    }
+  }
+
+private:
+  net::io_context m_ioc; // The io_context is required for all I/O
+  std::shared_ptr<ReceiverSession> m_session;
+  std::shared_ptr<FloatRingBuffer> m_buffer;
+  std::thread m_t;
+  WebsocketConfig m_config;
+};
+
+}