Support not using external buffers for node-addon

.github/scripts/node-addon/run.sh

@@ -18,7 +18,7 @@ fi
 SHERPA_ONNX_VERSION=$(grep "SHERPA_ONNX_VERSION" ./CMakeLists.txt  | cut -d " " -f 2  | cut -d '"' -f 2)
 echo "SHERPA_ONNX_VERSION $SHERPA_ONNX_VERSION"
 
-# SHERPA_ONNX_VERSION=1.0.25
+# SHERPA_ONNX_VERSION=1.0.27
 
 if [ -z $owner ]; then
   owner=k2-fsa

.github/workflows/npm-addon.yaml

@@ -55,7 +55,7 @@ jobs:
 
           SHERPA_ONNX_VERSION=$(grep "SHERPA_ONNX_VERSION" ./CMakeLists.txt  | cut -d " " -f 2  | cut -d '"' -f 2)
           echo "SHERPA_ONNX_VERSION $SHERPA_ONNX_VERSION"
-          # SHERPA_ONNX_VERSION=1.0.25
+          # SHERPA_ONNX_VERSION=1.0.27
 
           src_dir=.github/scripts/node-addon
           sed -i.bak s/SHERPA_ONNX_VERSION/$SHERPA_ONNX_VERSION/g $src_dir/package.json

nodejs-addon-examples/package.json

@@ -1,5 +1,5 @@
 {
   "dependencies": {
-    "sherpa-onnx-node": "^1.0.25"
+    "sherpa-onnx-node": "^1.0.27"
   }
 }

nodejs-addon-examples/test_tts_non_streaming_vits_coqui_de.js

@@ -24,7 +24,12 @@ const tts = createOfflineTts();
 const text = 'Alles hat ein Ende, nur die Wurst hat zwei.'
 
 let start = Date.now();
-const audio = tts.generate({text: text, sid: 0, speed: 1.0});
+const audio = tts.generate({
+  text: text,
+  sid: 0,
+  speed: 1.0,
+  enableExternalBuffer: true,
+});
 let stop = Date.now();
 const elapsed_seconds = (stop - start) / 1000;
 const duration = audio.samples.length / audio.sampleRate;

scripts/check_style_cpplint.sh

@@ -99,7 +99,7 @@ function do_check() {
       ;;
     2)
       echo "Check all files"
-      files=$(find $sherpa_onnx_dir/sherpa-onnx -name "*.h" -o -name "*.cc")
+      files=$(find $sherpa_onnx_dir/sherpa-onnx/csrc $sherpa_onnx_dir/sherpa-onnx/python $sherpa_onnx_dir/scripts/node-addon-api/src $sherpa_onnx_dir/sherpa-onnx/jni $sherpa_onnx_dir/sherpa-onnx/c-api -name "*.h" -o -name "*.cc")
       ;;
     *)
       echo "Check last commit"

scripts/node-addon-api/lib/speaker-identification.js

@@ -18,9 +18,9 @@ class SpeakerEmbeddingExtractor {
   }
 
   // return a float32 array
-  compute(stream) {
+  compute(stream, enableExternalBuffer = true) {
     return addon.speakerEmbeddingExtractorComputeEmbedding(
-        this.handle, stream.handle);
+        this.handle, stream.handle, enableExternalBuffer);
   }
 }
 

scripts/node-addon-api/lib/vad.js

@@ -11,8 +11,9 @@ class CircularBuffer {
   }
 
   // return a float32 array
-  get(startIndex, n) {
-    return addon.circularBufferGet(this.handle, startIndex, n);
+  get(startIndex, n, enableExternalBuffer = true) {
+    return addon.circularBufferGet(
+        this.handle, startIndex, n, enableExternalBuffer);
   }
 
   pop(n) {
@@ -48,23 +49,23 @@ config = {
   }
 
   acceptWaveform(samples) {
-    addon.voiceActivityDetectorAcceptWaveform(this.handle, samples)
+    addon.voiceActivityDetectorAcceptWaveform(this.handle, samples);
   }
 
   isEmpty() {
-    return addon.voiceActivityDetectorIsEmpty(this.handle)
+    return addon.voiceActivityDetectorIsEmpty(this.handle);
   }
 
   isDetected() {
-    return addon.voiceActivityDetectorIsDetected(this.handle)
+    return addon.voiceActivityDetectorIsDetected(this.handle);
   }
 
   pop() {
-    addon.voiceActivityDetectorPop(this.handle)
+    addon.voiceActivityDetectorPop(this.handle);
   }
 
   clear() {
-    addon.VoiceActivityDetectorClearWrapper(this.handle)
+    addon.VoiceActivityDetectorClearWrapper(this.handle);
   }
 
   /*
@@ -73,12 +74,12 @@ config = {
   start: a int32
 }
    */
-  front() {
-    return addon.voiceActivityDetectorFront(this.handle)
+  front(enableExternalBuffer = true) {
+    return addon.voiceActivityDetectorFront(this.handle, enableExternalBuffer);
   }
 
   reset() {
-    return addon.VoiceActivityDetectorResetWrapper(this.handle)
+    return addon.VoiceActivityDetectorResetWrapper(this.handle);
   }
 }
 

scripts/node-addon-api/src/non-streaming-tts.cc

@@ -2,6 +2,7 @@
 //
 // Copyright (c)  2024  Xiaomi Corporation
 
+#include <algorithm>
 #include <sstream>
 
 #include "macros.h"  // NOLINT
@@ -265,6 +266,13 @@ static Napi::Object OfflineTtsGenerateWrapper(const Napi::CallbackInfo &info) {
     return {};
   }
 
+  bool enable_external_buffer = true;
+  if (obj.Has("enableExternalBuffer") &&
+      obj.Get("enableExternalBuffer").IsBoolean()) {
+    enable_external_buffer =
+        obj.Get("enableExternalBuffer").As<Napi::Boolean>().Value();
+  }
+
   Napi::String _text = obj.Get("text").As<Napi::String>();
   std::string text = _text.Utf8Value();
   int32_t sid = obj.Get("sid").As<Napi::Number>().Int32Value();
@@ -273,20 +281,37 @@ static Napi::Object OfflineTtsGenerateWrapper(const Napi::CallbackInfo &info) {
   const SherpaOnnxGeneratedAudio *audio =
       SherpaOnnxOfflineTtsGenerate(tts, text.c_str(), sid, speed);
 
-  Napi::ArrayBuffer arrayBuffer = Napi::ArrayBuffer::New(
-      env, const_cast<float *>(audio->samples), sizeof(float) * audio->n,
-      [](Napi::Env /*env*/, void * /*data*/,
-         const SherpaOnnxGeneratedAudio *hint) {
-        SherpaOnnxDestroyOfflineTtsGeneratedAudio(hint);
-      },
-      audio);
-  Napi::Float32Array float32Array =
-      Napi::Float32Array::New(env, audio->n, arrayBuffer, 0);
-
-  Napi::Object ans = Napi::Object::New(env);
-  ans.Set(Napi::String::New(env, "samples"), float32Array);
-  ans.Set(Napi::String::New(env, "sampleRate"), audio->sample_rate);
-  return ans;
+  if (enable_external_buffer) {
+    Napi::ArrayBuffer arrayBuffer = Napi::ArrayBuffer::New(
+        env, const_cast<float *>(audio->samples), sizeof(float) * audio->n,
+        [](Napi::Env /*env*/, void * /*data*/,
+           const SherpaOnnxGeneratedAudio *hint) {
+          SherpaOnnxDestroyOfflineTtsGeneratedAudio(hint);
+        },
+        audio);
+    Napi::Float32Array float32Array =
+        Napi::Float32Array::New(env, audio->n, arrayBuffer, 0);
+
+    Napi::Object ans = Napi::Object::New(env);
+    ans.Set(Napi::String::New(env, "samples"), float32Array);
+    ans.Set(Napi::String::New(env, "sampleRate"), audio->sample_rate);
+    return ans;
+  } else {
+    // don't use external buffer
+    Napi::ArrayBuffer arrayBuffer =
+        Napi::ArrayBuffer::New(env, sizeof(float) * audio->n);
+
+    Napi::Float32Array float32Array =
+        Napi::Float32Array::New(env, audio->n, arrayBuffer, 0);
+
+    std::copy(audio->samples, audio->samples + audio->n, float32Array.Data());
+
+    Napi::Object ans = Napi::Object::New(env);
+    ans.Set(Napi::String::New(env, "samples"), float32Array);
+    ans.Set(Napi::String::New(env, "sampleRate"), audio->sample_rate);
+    SherpaOnnxDestroyOfflineTtsGeneratedAudio(audio);
+    return ans;
+  }
 }
 
 void InitNonStreamingTts(Napi::Env env, Napi::Object exports) {

scripts/node-addon-api/src/speaker-identification.cc

@@ -1,6 +1,7 @@
 // scripts/node-addon-api/src/speaker-identification.cc
 //
 // Copyright (c)  2024  Xiaomi Corporation
+#include <algorithm>
 #include <sstream>
 
 #include "macros.h"  // NOLINT
@@ -175,9 +176,9 @@ static Napi::Boolean SpeakerEmbeddingExtractorIsReadyWrapper(
 static Napi::Float32Array SpeakerEmbeddingExtractorComputeEmbeddingWrapper(
     const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
-  if (info.Length() != 2) {
+  if (info.Length() != 2 && info.Length() != 3) {
     std::ostringstream os;
-    os << "Expect only 2 arguments. Given: " << info.Length();
+    os << "Expect only 2 or 3 arguments. Given: " << info.Length();
 
     Napi::TypeError::New(env, os.str()).ThrowAsJavaScriptException();
 
@@ -199,6 +200,16 @@ static Napi::Float32Array SpeakerEmbeddingExtractorComputeEmbeddingWrapper(
     return {};
   }
 
+  bool enable_external_buffer = true;
+  if (info.Length() == 3) {
+    if (info[2].IsBoolean()) {
+      enable_external_buffer = info[2].As<Napi::Boolean>().Value();
+    } else {
+      Napi::TypeError::New(env, "Argument 2 should be a boolean.")
+          .ThrowAsJavaScriptException();
+    }
+  }
+
   SherpaOnnxSpeakerEmbeddingExtractor *extractor =
       info[0].As<Napi::External<SherpaOnnxSpeakerEmbeddingExtractor>>().Data();
 
@@ -210,14 +221,29 @@ static Napi::Float32Array SpeakerEmbeddingExtractorComputeEmbeddingWrapper(
 
   int32_t dim = SherpaOnnxSpeakerEmbeddingExtractorDim(extractor);
 
-  Napi::ArrayBuffer arrayBuffer = Napi::ArrayBuffer::New(
-      env, const_cast<float *>(v), sizeof(float) * dim,
-      [](Napi::Env /*env*/, void *data) {
-        SherpaOnnxSpeakerEmbeddingExtractorDestroyEmbedding(
-            reinterpret_cast<float *>(data));
-      });
+  if (enable_external_buffer) {
+    Napi::ArrayBuffer arrayBuffer = Napi::ArrayBuffer::New(
+        env, const_cast<float *>(v), sizeof(float) * dim,
+        [](Napi::Env /*env*/, void *data) {
+          SherpaOnnxSpeakerEmbeddingExtractorDestroyEmbedding(
+              reinterpret_cast<float *>(data));
+        });
+
+    return Napi::Float32Array::New(env, dim, arrayBuffer, 0);
+  } else {
+    // don't use external buffer
+    Napi::ArrayBuffer arrayBuffer =
+        Napi::ArrayBuffer::New(env, sizeof(float) * dim);
+
+    Napi::Float32Array float32Array =
+        Napi::Float32Array::New(env, dim, arrayBuffer, 0);
 
-  return Napi::Float32Array::New(env, dim, arrayBuffer, 0);
+    std::copy(v, v + dim, float32Array.Data());
+
+    SherpaOnnxSpeakerEmbeddingExtractorDestroyEmbedding(v);
+
+    return float32Array;
+  }
 }
 
 static Napi::External<SherpaOnnxSpeakerEmbeddingManager>