@streaming-sortformer-node/darwin-arm64 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streaming-sortformer-node/darwin-arm64",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Native bindings for SortFormer on macOS ARM64",
   "os": [
     "darwin"

package/src/StreamFeedWorker.cpp

@@ -0,0 +1,74 @@
+#include "StreamFeedWorker.h"
+#include <cstring>
+
+// Number of speakers output by the model
+static constexpr int NUM_SPEAKERS = 4;
+
+StreamFeedWorker::StreamFeedWorker(
+    Napi::Env env,
+    sortformer_stream_state* stream,
+    std::vector<float> audio,
+    Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env)
+    , stream_(stream)
+    , audio_(std::move(audio))
+    , deferred_(deferred)
+{
+}
+
+void StreamFeedWorker::Execute() {
+    // IMPORTANT: This runs on a worker thread - NO Napi calls allowed!
+
+    if (!stream_) {
+        SetError("Stream is null");
+        return;
+    }
+
+    // Allocate output buffer (generous size)
+    // hop=160, plus margin for padding
+    int max_frames = static_cast<int>(audio_.size() / 160) + 100;
+    predictions_.resize(max_frames * NUM_SPEAKERS);
+
+    n_frames_ = sortformer_stream_feed(
+        stream_,
+        audio_.data(),
+        static_cast<int>(audio_.size()),
+        predictions_.data(),
+        max_frames);
+
+    if (n_frames_ < 0) {
+        SetError("Stream feed failed");
+        return;
+    }
+
+    predictions_.resize(n_frames_ * NUM_SPEAKERS);
+}
+
+void StreamFeedWorker::OnOK() {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
+
+    Napi::Object result = Napi::Object::New(env);
+
+    // Copy predictions to a JS-owned ArrayBuffer
+    Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(
+        env,
+        predictions_.size() * sizeof(float));
+
+    std::memcpy(buffer.Data(), predictions_.data(), predictions_.size() * sizeof(float));
+
+    Napi::Float32Array predictions = Napi::Float32Array::New(
+        env,
+        predictions_.size(),
+        buffer,
+        0);
+
+    result.Set("predictions", predictions);
+    result.Set("frameCount", Napi::Number::New(env, n_frames_));
+
+    deferred_.Resolve(result);
+}
+
+void StreamFeedWorker::OnError(const Napi::Error& e) {
+    deferred_.Reject(e.Value());
+}

package/src/StreamFeedWorker.h

@@ -0,0 +1,38 @@
+#ifndef STREAM_FEED_WORKER_H
+#define STREAM_FEED_WORKER_H
+
+#include <napi.h>
+#include <vector>
+
+#include "sortformer.h"
+
+/**
+ * AsyncWorker for non-blocking streaming feed.
+ *
+ * Runs sortformer_stream_feed() on a worker thread to avoid blocking
+ * the Node.js event loop. Returns a Promise that resolves with
+ * { predictions: Float32Array, frameCount: number }.
+ */
+class StreamFeedWorker : public Napi::AsyncWorker {
+public:
+    StreamFeedWorker(
+        Napi::Env env,
+        sortformer_stream_state* stream,
+        std::vector<float> audio,
+        Napi::Promise::Deferred deferred);
+
+    void Execute() override;
+    void OnOK() override;
+    void OnError(const Napi::Error& e) override;
+
+private:
+    sortformer_stream_state* stream_;
+    std::vector<float> audio_;
+    Napi::Promise::Deferred deferred_;
+
+    // Results (populated in Execute, used in OnOK)
+    std::vector<float> predictions_;
+    int n_frames_ = 0;
+};
+
+#endif // STREAM_FEED_WORKER_H

package/src/StreamFlushWorker.cpp

@@ -0,0 +1,68 @@
+#include "StreamFlushWorker.h"
+#include <cstring>
+
+// Number of speakers output by the model
+static constexpr int NUM_SPEAKERS = 4;
+
+StreamFlushWorker::StreamFlushWorker(
+    Napi::Env env,
+    sortformer_stream_state* stream,
+    Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env)
+    , stream_(stream)
+    , deferred_(deferred)
+{
+}
+
+void StreamFlushWorker::Execute() {
+    // IMPORTANT: This runs on a worker thread - NO Napi calls allowed!
+
+    if (!stream_) {
+        SetError("Stream is null");
+        return;
+    }
+
+    int max_frames = 1000;
+    predictions_.resize(max_frames * NUM_SPEAKERS);
+
+    n_frames_ = sortformer_stream_flush(
+        stream_,
+        predictions_.data(),
+        max_frames);
+
+    if (n_frames_ < 0) {
+        SetError("Stream flush failed");
+        return;
+    }
+
+    predictions_.resize(n_frames_ * NUM_SPEAKERS);
+}
+
+void StreamFlushWorker::OnOK() {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
+
+    Napi::Object result = Napi::Object::New(env);
+
+    // Copy predictions to a JS-owned ArrayBuffer
+    Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(
+        env,
+        predictions_.size() * sizeof(float));
+
+    std::memcpy(buffer.Data(), predictions_.data(), predictions_.size() * sizeof(float));
+
+    Napi::Float32Array predictions = Napi::Float32Array::New(
+        env,
+        predictions_.size(),
+        buffer,
+        0);
+
+    result.Set("predictions", predictions);
+    result.Set("frameCount", Napi::Number::New(env, n_frames_));
+
+    deferred_.Resolve(result);
+}
+
+void StreamFlushWorker::OnError(const Napi::Error& e) {
+    deferred_.Reject(e.Value());
+}

package/src/StreamFlushWorker.h

@@ -0,0 +1,36 @@
+#ifndef STREAM_FLUSH_WORKER_H
+#define STREAM_FLUSH_WORKER_H
+
+#include <napi.h>
+#include <vector>
+
+#include "sortformer.h"
+
+/**
+ * AsyncWorker for non-blocking streaming flush.
+ *
+ * Runs sortformer_stream_flush() on a worker thread to avoid blocking
+ * the Node.js event loop. Returns a Promise that resolves with
+ * { predictions: Float32Array, frameCount: number }.
+ */
+class StreamFlushWorker : public Napi::AsyncWorker {
+public:
+    StreamFlushWorker(
+        Napi::Env env,
+        sortformer_stream_state* stream,
+        Napi::Promise::Deferred deferred);
+
+    void Execute() override;
+    void OnOK() override;
+    void OnError(const Napi::Error& e) override;
+
+private:
+    sortformer_stream_state* stream_;
+    Napi::Promise::Deferred deferred_;
+
+    // Results (populated in Execute, used in OnOK)
+    std::vector<float> predictions_;
+    int n_frames_ = 0;
+};
+
+#endif // STREAM_FLUSH_WORKER_H