@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-rt/lib/src/services/ffmpeg/detail.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <types/types.h>
+#include "./types.h"
+
+#include "codeccontext.h"
+
+
+#ifdef _MSC_VER
+    using ssize_t = int;
+#endif
+
+namespace hkp {
+
+namespace detail {
+
+bool processAudioDecodeEncode(const std::string& input, const std::string& out, unsigned int sampleRate);
+
+bool processAudioDecodeEncodeWithInput(av::FormatContext& ictx, OutputType out, unsigned int sampleRate, av::AudioDecoderContext& adec, ssize_t audioStream);
+
+bool convertFloatBufferToMp3(const BinaryData& rawFloatData, int sampleRate, OutputType output);
+bool convertFloatBufferToOgg(const BinaryData& rawFloatData, OutputType output);
+bool convertFloatBufferToWav(const BinaryData& rawFloatData, OutputType output);
+
+void resampleBuffer(AudioData& io, unsigned int dstSampleRate);
+
+} // namespace detail
+
+} // namespace hkp

package/bundle/hkp-rt/lib/src/services/ffmpeg/ffmpeg.cpp

@@ -0,0 +1,193 @@
+#include "./ffmpeg.h"
+
+#include <iostream>
+#include <set>
+#include <map>
+#include <memory>
+#include <functional>
+#include <filesystem>
+
+#include <files.h>
+
+#include "av.h"
+#include "ffmpeg.h"
+#include "codec.h"
+#include "packet.h"
+#include "videorescaler.h"
+#include "audioresampler.h"
+#include "avutils.h"
+
+// API2
+#include "format.h"
+#include "formatcontext.h"
+#include "codec.h"
+#include "codeccontext.h"
+
+#include "./detail.h"
+
+namespace hkp {
+
+Ffmpeg::Ffmpeg(const std::string& instanceId)
+    : Service(instanceId, serviceId())
+    , m_targetSampleRate(-1)
+{
+}
+
+json Ffmpeg::configure(Data data)
+{
+  auto buf = getJSONFromData(data);
+  if (buf)
+  {
+    updateIfNeeded(m_outputFolder, (*buf)["outputFolder"]);
+    updateIfNeeded(m_targetSampleRate, (*buf)["targetSampleRate"]);
+    updateIfNeeded(m_outputFormat, (*buf)["outputFormat"]);
+  }
+
+  return Service::configure(data);
+}
+
+std::string Ffmpeg::getServiceId() const
+{
+  return serviceId();
+}
+
+json Ffmpeg::getState() const
+{ 
+  return Service::mergeStateWith({
+    {"outputFolder", m_outputFolder},
+    {"targetSampleRate", m_targetSampleRate},
+    {"outputFormat", m_outputFormat}
+  });
+}
+
+Data Ffmpeg::process(Data data)
+{
+  auto j = getJSONFromData(data);
+  if (!j)
+  {
+    auto custom = getCustomDataFromData(data);
+    auto binaryData = getBinaryFromData(data);
+    auto ringBuffer = getRingBufferFromData(data);
+    if (custom && std::string(custom->type) == "murea/AudioData" && custom->data) // used by murea plugin to resample audio data
+    {
+      if (m_targetSampleRate == -1)
+      {
+        std::cerr << "Ffmpeg service: target sample rate not set, cannot resample." << std::endl;
+        return Null(); 
+      }
+      auto buffer = static_cast<AudioData*>(custom->data);
+      detail::resampleBuffer(*buffer, m_targetSampleRate);
+      return data;
+    }
+    else if (binaryData || ringBuffer)
+    {
+      if (m_targetSampleRate == -1)
+      {
+        std::cerr << "Ffmpeg service: target sample rate not set, cannot resample." << std::endl;
+        return Null(); 
+      }
+
+    
+      BinaryData data;
+      if (binaryData)
+      {
+        data = *binaryData;
+      }
+      else
+      {
+        ringBuffer->consumeAvailable(data, true);
+      }
+
+      static unsigned int counter = 0;
+      std::string filename = m_outputFolder.empty() ? "" : "output_" + std::to_string(counter++ % 2) + ".mp3";
+      if (!filename.empty())
+      {
+        std::string problem;
+        auto folder = files::resolve(m_outputFolder, problem);
+        auto outPath = folder ? files::resolveIn(*folder, filename, problem) : std::nullopt;
+        if (!outPath)
+        {
+          std::cerr << "Ffmpeg service: " << problem << std::endl;
+          return json{{ "error", problem }};
+        }
+        auto success = detail::convertFloatBufferToMp3(data, m_targetSampleRate, outPath->string());
+        return success ?
+          json{{ "output", outPath->string() }} :
+          json{{ "error", "Failed to process audio" }};
+      }
+      else // render to memory buffer instead of file
+      {
+        if (m_outputFormat == "mp3")
+        {  
+          auto outputIO = std::make_shared<MemoryIO>();
+          OutputType output ("output.mp3", outputIO);
+          auto success = detail::convertFloatBufferToMp3(data, m_targetSampleRate, output);
+          if (!success)
+          {
+            std::cerr << "Ffmpeg service: failed to process audio." << std::endl;
+          }
+          return success ? outputIO->data() : Null();
+        }
+        else if (m_outputFormat == "ogg")
+        {
+          auto outputIO = std::make_shared<MemoryIO>();
+          OutputType output ("output.ogg", outputIO);
+          auto success = detail::convertFloatBufferToOgg(data, output);
+          if (!success)
+          {
+            std::cerr << "Ffmpeg service: failed to process audio." << std::endl;
+          }
+          return success ? outputIO->data() : Null();
+        }
+        else if (m_outputFormat == "wav")
+        {
+          auto outputIO = std::make_shared<MemoryIO>();
+          OutputType output ("output.wav", outputIO);
+          auto success = detail::convertFloatBufferToWav(data, output);
+          if (!success)
+          {
+            std::cerr << "Ffmpeg service: failed to process audio." << std::endl;
+          }
+          return success ? outputIO->data() : Null();
+        }
+        else
+        {
+          std::cerr << "Ffmpeg service: unsupported output format: " << m_outputFormat << std::endl;
+          return Null();
+        }
+      }
+    }
+    else
+    {
+      std::cerr << "Ffmpeg service: invalid data type, expected JSON or murea/AudioData." << std::endl;
+      return Null();
+    }
+  }
+  std::string input = (*j)["input"];
+  std::string output = (*j)["output"];
+  unsigned int sampleRate = j->contains("sampleRate") ? (*j)["sampleRate"].get<unsigned int>() : 48000;
+  // A file inside a folder this server gives boards, never a URL: ffmpeg
+  // would open any protocol it knows. An empty outputFolder is the default
+  // folder.
+  std::string problem;
+  auto inPath = files::resolve(input, problem);
+  auto folder = inPath ? files::resolve(m_outputFolder.empty() ? "." : m_outputFolder, problem) : std::nullopt;
+  auto outPath = folder ? files::resolveIn(*folder, output, problem) : std::nullopt;
+  if (!outPath)
+  {
+    std::cerr << "Ffmpeg service: " << problem << std::endl;
+    return json{{ "error", problem }};
+  }
+  // check if output already exists;
+  if (files::exists(*outPath))
+  {
+    std::cout << "Ffmpeg service: output file already exists: " << outPath->string() << std::endl;
+    return json{{ "output", outPath->string() }};
+  }
+  
+  return detail::processAudioDecodeEncode("file:" + inPath->string(), outPath->string(), sampleRate) ?
+    json{{ "output", outPath->string() }} :
+    json{{ "error", "Failed to process audio" }};
+}
+
+} // namespace hkp

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

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <types/types.h>
+#include <service.h>
+
+/**
+ * Service Documentation
+ * Service ID: ffmpeg
+ * Service Name: Ffmpeg
+ * 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)
+ *
+ * `outputFolder`, and the `input` and `output` a request names, lie inside a
+ * folder this server gives boards (files.h); `input` is a file, never a URL.
+ */
+namespace hkp {
+
+class Ffmpeg : public Service 
+{
+public:
+  static std::string serviceId() { return "ffmpeg"; }
+
+  Ffmpeg(const std::string& instanceId);
+  json configure(Data data) override;
+  std::string getServiceId() const override;
+  json getState() const override;
+  Data process(Data data) override;
+
+private:
+  std::string m_outputFolder;
+  int m_targetSampleRate;
+  std::string m_outputFormat = "mp3"; // default output format
+};
+
+}

package/bundle/hkp-rt/lib/src/services/ffmpeg/types.h

@@ -0,0 +1,120 @@
+#pragma once
+
+#include <string>
+#include <memory>
+
+#include "formatcontext.h"
+
+namespace hkp {
+
+class MemoryIO : public av::CustomIO 
+{
+public:
+  MemoryIO()
+    : m_pos(0) 
+  {
+  }
+
+  MemoryIO(const uint8_t* data, size_t buf_size)
+    : m_pos(0) 
+  {
+    m_data.reserve(buf_size);
+    m_data.insert(m_data.end(), data, data + buf_size); 
+  }
+
+  int read(uint8_t *data, size_t buf_size) override 
+  {
+      if (m_pos >= m_data.size())
+      {
+        return AVERROR_EOF;
+      }
+          
+      int toRead = std::min(buf_size, static_cast<size_t>(m_data.size() - m_pos));
+      memcpy(data, &m_data[0] + m_pos, toRead);
+      m_pos += toRead;
+      return toRead;
+  }
+
+  int64_t seek(int64_t offset, int whence) override 
+  {
+    switch (whence) 
+    {
+      case SEEK_SET:
+          m_pos = offset;
+          break;
+      case SEEK_CUR:
+          m_pos += offset;
+          break;
+      case SEEK_END:
+          m_pos = m_data.size() + offset;
+          break;
+      default:
+          return -1;
+    }
+    if (m_pos < 0 || m_pos > m_data.size())
+    {
+      return -1;
+    }
+    return m_pos;
+  }
+
+  int write(const uint8_t *data, size_t size) override
+  {
+    m_data.insert(m_data.end(), data, data + size);
+    m_pos += size;
+    return size;  
+  }
+
+  int patchDataAt(size_t pos, const uint8_t *data, size_t size)
+  {
+    if (pos + size > m_data.size())
+    {
+      std::cerr << "MemoryIO::patchDataAt: position out of bounds" << std::endl;
+      return -1; // Out of bounds
+    }
+    memcpy(&m_data[pos], data, size);
+    return size;  
+  }
+
+  Data data() const 
+  {
+    return m_data;
+  }
+
+  static int write_packet(void* opaque, const uint8_t* buf, int buf_size) 
+  {
+    MemoryIO* mem_output = static_cast<MemoryIO*>(opaque);
+    mem_output->m_data.insert(mem_output->m_data.end(), buf, buf + buf_size);
+    return buf_size;
+  }
+
+  const std::vector<uint8_t>& dataBuffer() const 
+  {
+    return m_data;
+  }
+private:
+  std::vector<uint8_t> m_data;
+  size_t m_pos;
+};
+
+struct OutputType
+{
+    OutputType(const std::string& filename)
+      : filename(filename), memoryIO(nullptr) {}
+    OutputType(const std::string& filename, std::shared_ptr<MemoryIO> memoryIO)
+      : filename(filename), memoryIO(memoryIO) {}
+    ~OutputType() {}
+    
+    std::string filename;
+    std::shared_ptr<MemoryIO> memoryIO;
+};
+
+// This is used by the murea plugin to resample audio data!
+struct AudioData
+{
+  unsigned int numChannels;
+  unsigned int sampleRate;
+  std::vector<std::vector<float> > samples;
+};
+
+} // namespace hkp

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

@@ -0,0 +1,190 @@
+#pragma once
+
+#include <vector>
+#include <complex>
+#include <cmath>
+#include <stdexcept>
+#include <iostream>
+
+#include <types/types.h>
+#include <service.h>
+#include <types/data.h>
+
+/**
+ * Service Documentation
+ * Service ID: fft
+ * Service Name: FFTService
+ * 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 FFTService : public Service 
+{
+public:
+  using complexf = std::complex<float>;
+
+  static std::string serviceId() { return "fft"; }
+
+  FFTService(const std::string& instanceId)
+    : Service(instanceId, serviceId())
+    , m_windowLength(512) // Default FFT window length
+  { 
+  }
+
+  json configure(Data data) override
+  {
+    auto buf = getJSONFromData(data);
+    if (buf)
+    {
+      updateIfNeeded(m_windowLength, (*buf)["windowLength"]);
+      updateIfNeeded(m_outputMode, (*buf)["outputMode"]);
+    }
+    return Service::configure(data);
+  }
+
+  std::string getServiceId() const override
+  {
+    return serviceId();
+  }
+
+  json getState() const override
+  {
+    auto state = json{{ "windowLength", m_windowLength }, { "outputMode", m_outputMode }};
+    return Service::mergeBypassState(state);
+  }
+
+  Data process(Data data) override
+  {
+    auto buffer = getRingBufferFromData(data);
+    if (buffer)
+    {
+      std::vector<float> samples;
+      if (buffer->consumeExact(samples, m_windowLength) == 0)
+      {
+        return Null();
+      }
+
+      std::vector<complexf> spectrum = fft(samples);
+      auto result = json::array();
+      if (m_outputMode == "complex")
+      {
+        // Full complex spectrum: [{re, im}, ...] for all N bins.
+        // Preserves phase so the IFFT can reconstruct without artifacts.
+        for (const auto& bin : spectrum)
+        {
+          result.push_back({{"re", bin.real()}, {"im", bin.imag()}});
+        }
+      }
+      else
+      {
+        // Default: magnitude only (N/2 bins, phase discarded).
+        for (unsigned int i = 0, n = m_windowLength / 2; i < n; ++i)
+        {
+          result.push_back(std::abs(spectrum[i]));
+        }
+      }
+      return Data(result);
+    }
+    return data;
+  }
+
+private:
+  static constexpr float PI = 3.14159265358979323846f;
+
+  // Internal recursive FFT function
+  inline void fft_recursive(std::vector<complexf>& a, bool inverse) 
+  {
+      size_t n = a.size();
+      if (n <= 1) 
+      {
+        return;
+      }
+
+      std::vector<complexf> even(n / 2), odd(n / 2);
+      for (size_t i = 0; i < n / 2; ++i) 
+      {
+          even[i] = a[i * 2];
+          odd[i]  = a[i * 2 + 1];
+      }
+
+      fft_recursive(even, inverse);
+      fft_recursive(odd, inverse);
+
+      for (size_t k = 0; k < n / 2; ++k) 
+      {
+          float angle = (inverse ? 2.0f : -2.0f) * PI * k / static_cast<float>(n);
+          complexf twiddle = std::polar(1.0f, angle) * odd[k];
+          a[k] = even[k] + twiddle;
+          a[k + n / 2] = even[k] - twiddle;
+      }
+  }
+
+  // Forward FFT: from real input to complex frequency domain
+  inline std::vector<complexf> fft(const std::vector<float>& input) 
+  {
+      size_t n = input.size();
+
+      // Check if n is a power of 2
+      if ((n & (n - 1)) != 0) 
+      {
+          std::cout << "FFT input size must be a power of 2" << std::endl;;
+          n = previous_power_of_two(n);
+      }
+
+      std::vector<complexf> data(n);
+      for (size_t i = 0; i < n; ++i) 
+      {
+          data[i] = complexf(input[i], 0.0f);
+      }
+      fft_recursive(data, false);
+
+      return data;
+  }
+
+  inline uint32_t previous_power_of_two(uint32_t n) {
+    if (n == 0) return 0;
+
+    // Set all bits below the highest set bit
+    n |= (n >> 1);
+    n |= (n >> 2);
+    n |= (n >> 4);
+    n |= (n >> 8);
+    n |= (n >> 16);
+
+    // The result is now all 1s below the highest set bit
+    // Shift right once and add 1 to get the highest power of 2 <= original
+    return n - (n >> 1);
+}
+
+inline void resample_down(std::vector<float>& data, size_t new_size) 
+{
+  size_t old_size = data.size();
+  if (new_size >= old_size || new_size == 0)
+  {
+    return;
+  }
+
+  std::vector<float> result(new_size);
+  float scale = static_cast<float>(old_size) / new_size;
+  for (size_t i = 0; i < new_size; ++i) 
+  {
+    float idx = i * scale;
+    size_t idx0 = static_cast<size_t>(idx);
+    size_t idx1 = std::min(idx0 + 1, old_size - 1);
+    float frac = idx - idx0;
+    // Linear interpolation
+    result[i] = data[idx0] * (1.0f - frac) + data[idx1] * frac;
+  }
+  data = std::move(result);
+}
+  unsigned int m_windowLength; // Length of the FFT window
+  std::string m_outputMode = "magnitude"; // "magnitude" | "complex"
+};
+
+}