Overload constructor of recognizer, maximal debug configuration

src/bindings.cc

@@ -21,6 +21,8 @@ EMSCRIPTEN_BINDINGS() {
   
   class_<recognizer>("recognizer") 
   .constructor<model*, float, int>(allow_raw_pointers())
+  .constructor<model*, spkModel*, float, int>(allow_raw_pointers())
+  .constructor<model*, std::string, float, int, int>(allow_raw_pointers())
   .function("setWords", &recognizer::setWords, allow_raw_pointers())
   .function("setPartialWords", &recognizer::setPartialWords, allow_raw_pointers())
   .function("setGrm", &recognizer::setGrm, allow_raw_pointers())

src/pre.js

@@ -68,7 +68,7 @@ class Recognizer extends EventTarget {
     super()
     objs.push(this)
   }
-  static async _init(model, sampleRate) {
+  static async _init1(model, sampleRate) {
     let rec = new Recognizer()
     return new Promise((resolve, reject) => {
       rec.addEventListener("_continue", (ev) => {
@@ -82,6 +82,34 @@ class Recognizer extends EventTarget {
       rec.obj = new Module.recognizer(model, sampleRate, objs.length-1)  
     })
   }
+  static async _init2(model, spkModel, sampleRate) {
+    let rec = new Recognizer()
+    return new Promise((resolve, reject) => {
+      rec.addEventListener("_continue", (ev) => {
+        if(ev.detail == "0") {
+          rec.ptr = Module._malloc(512)
+          return resolve(rec)
+        }
+        rec.delete()
+        reject(ev.detail)
+      }, {once : true})
+      rec.obj = new Module.recognizer(model, spkModel, sampleRate, objs.length-1)  
+    })
+  }
+  static async _init3(model, grammar, sampleRate) {
+    let rec = new Recognizer()
+    return new Promise((resolve, reject) => {
+      rec.addEventListener("_continue", (ev) => {
+        if(ev.detail == "0") {
+          rec.ptr = Module._malloc(512)
+          return resolve(rec)
+        }
+        rec.delete()
+        reject(ev.detail)
+      }, {once : true})
+      rec.obj = new Module.recognizer(model, grammar, sampleRate, objs.length-1, 0)  
+    })
+  }
   async getNode(ctx, channelIndex = 0) {
     if(typeof this.node === "undefined") {
       let msgChannel = new MessageChannel()
@@ -123,6 +151,12 @@ class Recognizer extends EventTarget {
 Module.makeRecognizer = (model, sampleRate) => {
   return Recognizer._init(model.obj, sampleRate)
 }
+Module.makeRecognizerWithSpkModel = (model, spkModel, sampleRate) => {
+  return Recognizer._init2(model.obj, spkModel.obj, sampleRate)
+} 
+Module.makeRecognizerWithGrm = (model, grammar, sampleRate) => {
+  return Recognizer._init3(model.obj, grammar, sampleRate)
+} 
 let processorUrl = URL.createObjectURL(new Blob(['(',
   (() => {
     registerProcessor("BRProcessor", class extends AudioWorkletProcessor {

src/recognizer.cc

@@ -3,31 +3,23 @@
 recognizer::recognizer(model* mdl, float sampleRate, int index) : index(index) {
   auto main{[this, mdl, sampleRate](){
     rec = vosk_recognizer_new(mdl->mdl,sampleRate);
-    if(rec == nullptr) {
-      fireEv("_continue", "Unable to initialize recognizer", this->index);
-      return;
-    }
-    fireEv("_continue", nullptr, this->index);
-    while(!done.test(std::memory_order_relaxed)) {
-      controller.wait(!done.test(std::memory_order_relaxed), std::memory_order_relaxed);
-      controller.clear(std::memory_order_relaxed);
-      if(done.test(std::memory_order_relaxed)) continue;
-      switch(vosk_recognizer_accept_waveform_f(rec, dataPtr, 512)) {
-      case 0:
-      fireEv("result", vosk_recognizer_result(rec), this->index);
-      break;
-      case 1:
-      fireEv("partialResult", vosk_recognizer_partial_result(rec), this->index);
-      }
-    }
+    finishConstruction();
   }};
-  if(mdl->recognizerUsedThrd) {
-    mdl->thrd.addTask(main);
-    mdl->recognizerUsedThrd = true;
-    return;
-  }
-  std::thread t{main};
-  t.detach();
+  tryStealMdlThrd(main, mdl);
+}
+recognizer::recognizer(model* mdl, spkModel* spkMdl, float sampleRate, int index) {
+  auto main{[this, mdl, sampleRate, spkMdl](){
+    rec = vosk_recognizer_new_spk(mdl->mdl, sampleRate, spkMdl->mdl);
+    finishConstruction();
+  }};
+  tryStealMdlThrd(main, mdl);
+}
+recognizer::recognizer(model* mdl, const std::string& grm, float sampleRate, int index, int dummy) {
+  auto main{[this, mdl, sampleRate, grm](){
+    rec = vosk_recognizer_new_grm(mdl->mdl, sampleRate, grm.c_str());
+    finishConstruction();
+  }};
+  tryStealMdlThrd(main, mdl);
 }
 recognizer::~recognizer() {
   done.test_and_set(std::memory_order_relaxed);
@@ -37,7 +29,34 @@ recognizer::~recognizer() {
   vosk_recognizer_free(rec);
   free(dataPtr);
 }
-
+void recognizer::tryStealMdlThrd(std::function<void()>&& main, model* mdl) {
+  if(mdl->recognizerUsedThrd) {
+    mdl->thrd.addTask(std::move(main));
+    mdl->recognizerUsedThrd = true;
+    return;
+  }
+  std::thread t{main};
+  t.detach();
+}
+void recognizer::finishConstruction() {
+  if(rec == nullptr) {
+    fireEv("_continue", "Unable to initialize recognizer", this->index);
+    return;
+  }
+  fireEv("_continue", nullptr, this->index);
+  while(!done.test(std::memory_order_relaxed)) {
+    controller.wait(!done.test(std::memory_order_relaxed), std::memory_order_relaxed);
+    controller.clear(std::memory_order_relaxed);
+    if(done.test(std::memory_order_relaxed)) continue;
+    switch(vosk_recognizer_accept_waveform_f(rec, dataPtr, 512)) {
+      case 0:
+        fireEv("result", vosk_recognizer_result(rec), this->index);
+        break;
+      case 1:
+        fireEv("partialResult", vosk_recognizer_partial_result(rec), this->index);
+    }
+  }
+}
 void recognizer::acceptWaveForm() {
   controller.test_and_set(std::memory_order_relaxed);
   controller.notify_one();

src/recognizer.h

@@ -3,9 +3,6 @@
 #include "spkModel.h"
 #include "global.h"
 
-#include <filesystem>
-namespace fs = std::filesystem;
-
 struct recognizer {
   std::atomic_flag done{};
   std::atomic_flag controller{};
@@ -13,7 +10,11 @@ struct recognizer {
   int index{};
   VoskRecognizer* rec{};
   recognizer(model* model, float sampleRate, int index);
+  recognizer(model* model, spkModel* spkModel, float sampleRate, int index);
+  recognizer(model* model, const std::string& grm, float sampleRate, int index, int dummy);
   ~recognizer();
+  void finishConstruction();
+  void tryStealMdlThrd(std::function<void()>&& main, model* mdl);
   void acceptWaveForm();
   void setSpkModel(spkModel* model);
   void setGrm(const std::string& grm);