A n o t h e r b i g c h a n g e

src/genericModel.cc

@@ -56,6 +56,7 @@ void genericModel::extractAndLoad(int tarStart, int tarSize) {
   std::thread t{[this](){
     func();
     blocker.lock();
+    blocker.unlock();
     func();
   }};
   t.detach();

src/genericModel.h

@@ -15,7 +15,7 @@ namespace fs = std::filesystem;
 
 struct genericModel {
   bool normalMdl;
-  bool thrdConsumed{};
+  bool resourceUsed{};
   int index;
   std::string storepath;
   std::string id;

src/link.cc

@@ -11,7 +11,7 @@ void fireEv(int index, const char* content, const char* type) {
   if(dstThrd == pthread_self()) proxy();
   else glbQ.proxySync(dstThrd, proxy);
 }
-void fireEv(int index, char* state, float* dataBuf) {
+void fireEv(int index, std::atomic_int* state, float* dataBuf) {
   auto proxy{[index, state, dataBuf](){
     EM_ASM({
       objs[$0].dispatchEvent(new CustomEvent("0", { "detail" : $1 + "," + $2}));

src/link.h

@@ -3,6 +3,5 @@
 #include <emscripten/proxying.h>
 using namespace emscripten;
 
-
 void fireEv(int index, const char* content, const char* type = nullptr); // Normal
-void fireEv(int index, char* state, float* dataBuf); // For recognizer's success initialization
+void fireEv(int index, std::atomic_int* state, float* dataBuf); // For recognizer's success initialization

src/pre.js

@@ -95,7 +95,7 @@ class Recognizer extends EventTarget {
       rec.addEventListener("0", ev => {
         if(ev.detail.indexOf(",") !== -1) {
           let loadInfo = ev.detail.split(",")
-          rec.state = Module.HEAP8.subarray(parseInt(loadInfo[0]), parseInt(loadInfo[0]) + 1) // State is an array with 1 element, there is no other way to get a reference to a single element
+          rec.state = Module.HEAP32.subarray(parseInt(loadInfo[0]), parseInt(loadInfo[0]) + 1) // State is an array with 1 element, there is no other way to get a reference to a single element
           rec.dataBuf = Module.HEAPF32.subarray(parseInt(loadInfo[1]), parseInt(loadInfo[1]) + 128)
           return resolve(rec)
         }
@@ -167,9 +167,9 @@ let processorUrl = URL.createObjectURL(new Blob(['(',
         this.state = options.processorOptions.state
       }
       process(inputs, outputs, params) {
-        while(state[0])
+        Atomics.wait(state, 0)
         inputs.copyFromChannel(this.dataBuf, this.channelIndex)
-        state[0] = 1
+        
         return true
       }
     })

src/recognizer.cc

@@ -1,17 +1,16 @@
 #include "recognizer.h" 
 
-recognizer::recognizer(int index, float sampleRate, genericModel* model) : index{index}, rec{vosk_recognizer_new(std::get<0>(model->mdl),sampleRate)} {
+recognizer::recognizer(int index, float sampleRate, genericModel* model) : index{index}, sampleRate{sampleRate}, rec{vosk_recognizer_new(std::get<0>(model->mdl),sampleRate)} {
   finishConstruction(model);
 }
-recognizer::recognizer(int index, float sampleRate, genericModel* model, genericModel* spkModel) : index(index), rec{vosk_recognizer_new_spk(std::get<0>(model->mdl), sampleRate, std::get<1>(spkModel->mdl))} {
+recognizer::recognizer(int index, float sampleRate, genericModel* model, genericModel* spkModel) : index(index), sampleRate{sampleRate}, rec{vosk_recognizer_new_spk(std::get<0>(model->mdl), sampleRate, std::get<1>(spkModel->mdl))} {
   finishConstruction(model, spkModel);
 }
-recognizer::recognizer(int index, float sampleRate, genericModel* model, const std::string& grm, int dummy) : index{index}, rec{vosk_recognizer_new_grm(std::get<0>(model->mdl), sampleRate, grm.c_str())} {
+recognizer::recognizer(int index, float sampleRate, genericModel* model, const std::string& grm, int dummy) : index{index}, sampleRate{sampleRate}, rec{vosk_recognizer_new_grm(std::get<0>(model->mdl), sampleRate, grm.c_str())} {
   finishConstruction(model);
 }
 recognizer::~recognizer() {
-  done.test_and_set(std::memory_order_relaxed);
-  done.notify_one();
+  done = true;
   vosk_recognizer_free(rec);
 }
 void recognizer::reset() {
@@ -25,32 +24,27 @@ void recognizer::finishConstruction(genericModel* model, genericModel* spkModel)
   auto main {[this](){
     emscripten_console_log("Recognizer loaded!");
     fireEv(index, &state, dataBuf);
-    int sample{};
-    char buffer[22480];
-    ALCdevice* mic{alcCaptureOpenDevice("Emscripten OpenAL capture", sampleRate, AL_FORMAT_MONO16, 22480)};
-    alcCaptureStart(mic);
-    while(!done.test(std::memory_order_relaxed)) {
-      alcGetIntegerv(mic, ALC_CAPTURE_SAMPLES, 4, &sample);
-      alcCaptureSamples(mic, buffer, sample);
-      switch(vosk_recognizer_accept_waveform(rec, buffer, 22480)) {
+    while(!done) {
+      switch(vosk_recognizer_accept_waveform_f(rec, dataBuf, 512)) {
         case 0:
           fireEv(index, vosk_recognizer_result(rec), "result");
           break;
         case 1:
           fireEv(index, vosk_recognizer_partial_result(rec), "partialResult");
       }
+      state = 0;
+      state.wait(0, std::memory_order_relaxed);
     }
-    alcCaptureCloseDevice(mic);
   }};
-  if(!model->thrdConsumed) {
-    model->thrdConsumed = true;
+  if(!model->resourceUsed) {
+    model->resourceUsed = true;
     model->func = main;
     model->blocker.unlock();
     emscripten_console_log("Using model's thread");
     return;
   }
-  if(spkModel != nullptr && !spkModel->thrdConsumed) {
-    spkModel->thrdConsumed = true;
+  if(spkModel != nullptr && !spkModel->resourceUsed) {
+    spkModel->resourceUsed = true;
     spkModel->func = main;
     spkModel->blocker.unlock();
     emscripten_console_log("Using speaker model's thread");

src/recognizer.h

@@ -1,12 +1,10 @@
 #pragma once
 #include "genericModel.h"
-
-#include <AL/al.h>
-#include <AL/alc.h>
+#include <condition_variable>
 
 struct recognizer {
-  std::atomic_flag done{};
-  char state; // 0: Copying data from JS, 1: Processing from C++
+  std::atomic_bool done;
+  std::atomic_int state; // 0: Copying data from JS, 1: Processing from C++
   float dataBuf[128];
   float sampleRate;
   int index;
@@ -15,11 +13,10 @@ struct recognizer {
   recognizer(int index, float sampleRate, genericModel* model, genericModel* spkModel);
   recognizer(int index, float sampleRate, genericModel* model, const std::string& grm, int dummy);
   ~recognizer();
-  void reset();
   void finishConstruction(genericModel* model, genericModel* spkModel = nullptr);
+  void reset();
   void setEndpointerMode(VoskEndpointerMode mode);
   void setEndpointerDelays(float tStartMax, float tEnd, float tMax);
-  void acceptWaveForm();
   void setSpkModel(genericModel* model);
   void setGrm(const std::string& grm);
   void setWords(bool words);