patrick/Vosklet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use std::variant, reorder struct member

Browse Source
This commit is contained in:
msqr1
2024-03-01 22:15:15 -08:00
parent 111961e217
commit 894fc1df99
15 changed files with 13623 additions and 8611 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/bindings.cc
View File

@@ -1,5 +1,4 @@
#include "spkModel.h"
#include "model.h"
#include "genericModel.h"
#include "recognizer.h"
#include <emscripten/bind.h>
@@ -7,22 +6,16 @@ using namespace emscripten;
EMSCRIPTEN_BINDINGS() {
function("setLogLevel", &vosk_set_log_level, allow_raw_pointers());
class_<model>("model")
.constructor<std::string, std::string, int>(allow_raw_pointers())
.function("checkModel", &model::checkModel, allow_raw_pointers())
.function("afterFetch", &model::afterFetch, allow_raw_pointers())
.function("load", &model::load, allow_raw_pointers());
class_<spkModel>("spkModel")
.constructor<std::string, std::string, int>(allow_raw_pointers())
.function("checkModel", &spkModel::checkModel, allow_raw_pointers())
.function("afterFetch", &spkModel::afterFetch, allow_raw_pointers())
.function("load", &spkModel::load, allow_raw_pointers());
class_<genericModel>("genericModel")
.constructor<std::string, std::string, int, bool>(allow_raw_pointers())
.function("check", &genericModel::check, allow_raw_pointers())
.function("afterFetch", &genericModel::afterFetch, allow_raw_pointers())
.function("load", &genericModel::load, allow_raw_pointers());
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())
.constructor<genericModel*, float, int>(allow_raw_pointers())
.constructor<genericModel*, genericModel*, float, int>(allow_raw_pointers())
.constructor<genericModel*, 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())

82
src/genericModel.cc
View File

@@ -1,7 +1,70 @@
#include "genericModel.h"
genericModel::genericModel(const std::string& storepath, const std::string &id, int index) : storepath(storepath), id(id), index(index) {}
void genericModel::checkModel() {
genericModel::genericModel(std::string storepath, std::string id, int index, bool normalMdl) : index(index), normalMdl(normalMdl) {
this->storepath = new char[storepath.size()];
this->id = new char[id.size()];
memcpy(this->storepath, storepath.c_str(), storepath.size());
memcpy(this->id, id.c_str(), id.size());
}
void genericModel::load(bool newTask) {
emscripten_console_log(storepath);
emscripten_console_log(id);
auto main{[this](){
if(normalMdl) {
VoskModel* temp {vosk_model_new(".")};
if(temp == nullptr) {
fireEv("_continue", "Unable to load model for recognition", index);
return;
}
mdl = temp;
}
else {
VoskSpkModel* temp {vosk_spk_model_new(".")};
if(temp == nullptr) {
fireEv("_continue", "Unable to load model for recognition", index);
return;
}
mdl = temp;
}
fireEv("_continue", nullptr, index);
}};
if(!newTask) {
main();
return;
}
thrd.addTask(main);
}
bool genericModel::checkFiles() {
if(std::holds_alternative<VoskModel*>(mdl)) {
return fs::exists("am/final.mdl", tank) &&
fs::exists("conf/mfcc.conf", tank) &&
fs::exists("conf/model.conf", tank) &&
fs::exists("graph/phones/word_boundary.int", tank) &&
fs::exists("graph/Gr.fst", tank) &&
fs::exists("graph/HCLr.fst", tank) &&
fs::exists("graph/disambig_tid.int", tank) &&
fs::exists("ivector/final.dubm", tank) &&
fs::exists("ivector/final.ie", tank) &&
fs::exists("ivector/final.mat", tank) &&
fs::exists("ivector/global_cmvn.stats", tank) &&
fs::exists("ivector/online_cmvn.conf", tank) &&
fs::exists("ivector/splice.conf", tank);
}
return fs::exists("mfcc.conf", tank) &&
fs::exists("final.ext.raw", tank) &&
fs::exists("mean.vec", tank) &&
fs::exists("transform.mat", tank);
}
genericModel::~genericModel() {
if(std::holds_alternative<VoskModel*>(mdl)) {
vosk_model_free(std::get<0>(mdl));
return;
}
vosk_spk_model_free(std::get<1>(mdl));
delete[] storepath;
delete[] id;
}
void genericModel::check() {
thrd.addTask([this](){
if(OPFSTried && !OPFSOk) {
fireEv("_checkMdl", "OPFS isn't available", index);
@@ -28,7 +91,7 @@ void genericModel::checkModel() {
if(tank.value() != 0) {
fireEv("_continue", "Unable to cd storepath", index);
}
if(!checkModelFiles() && !fs::exists("id", tank)) {
if(!checkFiles() && !fs::exists("id", tank)) {
fireEv("_checkMdl", "fetch", index);
return;
}
@@ -51,28 +114,31 @@ void genericModel::checkModel() {
};
fread(oldid, 1, oldsize, idFile);
fclose(idFile);
if(strcmp(oldid, id.c_str()) != 0) fireEv("_checkMdl", "fetch", index);
if(strcmp(oldid, id) != 0) fireEv("_checkMdl", "fetch", index);
else fireEv("_checkMdl", nullptr, index);
delete[] oldid;
});
}
void genericModel::afterFetch() {
thrd.addTask([this](){
if(!extractModel()) {
emscripten_console_log("1");
if(!extract()) {
fs::remove("/opfs/m0dEl.tar",tank);
fs::current_path("/opfs", tank);
fs::remove_all(storepath, tank);
fireEv("_continue", "Unable to extract model", index);
return;
}
emscripten_console_log("2");
fs::remove("/opfs/m0dEl.tar",tank);
fs::remove("README",tank);
if(!checkModelFiles()) {
if(!checkFiles()) {
fireEv("_continue", "URL points to invalid model files", index);
return;
}
emscripten_console_log("3");
int idFd {open("id", O_WRONLY | O_TRUNC)};
if(write(idFd, id.c_str(), id.size()) == -1) {
if(write(idFd, id, strlen(id)) == -1) {
fireEv("_continue", "Unable to write new ID", index);
close(idFd);
return;
@@ -81,7 +147,7 @@ void genericModel::afterFetch() {
load(false);
});
}
bool genericModel::extractModel() {
bool genericModel::extract() {
std::string path{};
archive* src {archive_read_new()};
archive_entry* entry{};

20
src/genericModel.h
View File

@@ -5,6 +5,7 @@
#include <filesystem>
#include <cstring>
#include <fcntl.h>
#include <variant>
#include <vosk_api.h>
#include <archive.h>
@@ -12,16 +13,19 @@
namespace fs = std::filesystem;
struct genericModel {
const std::string storepath{};
const std::string id{};
reusableThrd thrd{};
bool normalMdl{};
bool recognizerUsedThrd{};
int index{};
static bool extractModel();
virtual bool checkModelFiles() = 0;
virtual void load(bool newTask) = 0;
void checkModel();
char* storepath{};
char* id{};
std::variant<VoskModel*, VoskSpkModel*> mdl{};
reusableThrd thrd{};
static bool extract();
void load(bool newTask);
void check();
bool checkFiles();
void afterFetch();
genericModel(const std::string &storepath, const std::string &id, int index);
genericModel(std::string storepath, std::string id, int index, bool normalMdl);
~genericModel();
};

42
src/model.cc
View File

@@ -1,42 +0,0 @@
#include "model.h"
model::model(const std::string& storepath, const std::string& id, int index) : genericModel(storepath, id, index) {}
model::~model() {
vosk_model_free(mdl);
}
void model::afterFetch() {
genericModel::afterFetch();
}
void model::checkModel() {
genericModel::checkModel();
}
void model::load(bool newTask) {
auto main{[this](){
mdl = vosk_model_new(".");
if(mdl == nullptr) {
fireEv("_continue", "Unable to load model for recognition", index);
return;
}
fireEv("_continue", nullptr, index);
}};
if(!newTask) {
main();
return;
}
thrd.addTask(main);
}
bool model::checkModelFiles() {
return fs::exists("am/final.mdl", tank) &&
fs::exists("conf/mfcc.conf", tank) &&
fs::exists("conf/model.conf", tank) &&
fs::exists("graph/phones/word_boundary.int", tank) &&
fs::exists("graph/Gr.fst", tank) &&
fs::exists("graph/HCLr.fst", tank) &&
fs::exists("graph/disambig_tid.int", tank) &&
fs::exists("ivector/final.dubm", tank) &&
fs::exists("ivector/final.ie", tank) &&
fs::exists("ivector/final.mat", tank) &&
fs::exists("ivector/global_cmvn.stats", tank) &&
fs::exists("ivector/online_cmvn.conf", tank) &&
fs::exists("ivector/splice.conf", tank);
}

15
src/model.h
View File

@@ -1,15 +0,0 @@
#pragma once
#include "genericModel.h"
struct model : genericModel {
bool checkModelFiles();
VoskModel* mdl{};
model(const std::string& storepath, const std::string& id, int index);
void checkModel();
void afterFetch();
void load(bool newTask);
~model();
};

11
src/pre.js
View File

@@ -48,9 +48,8 @@ class genericModel extends EventTarget {
reject(ev.detail)
}
}, {once : true})
if(normalMdl) mdl.obj = new Module.model(storepath, id, objs.length-1)
else mdl.obj = new Module.spkModel(storepath, id, objs.length-1)
mdl.obj.checkModel()
mdl.obj = new Module.genericModel(storepath, id, objs.length-1, normalMdl)
mdl.obj.check()
})
}
delete() {
@@ -122,7 +121,7 @@ class Recognizer extends EventTarget {
return this.node
}
recognize(buf, channelIndex = 0) {
Module.HEAPF32.set(buf.getChannelData(channelIndex).subarray(0, 512), this.ptr);
Module.HEAPF32.set(buf.getChannelData(channelIndex).subarray(0, 512), this.ptr)
this.obj.acceptWaveForm()
}
delete() {
@@ -168,8 +167,8 @@ let processorUrl = URL.createObjectURL(new Blob(['(',
this.channelIndex = options.processorOptions.channelIndex
}
process(inputs, outputs, params) {
if(this.done) return false;
this.wasmMem.set(inputs[0].getChannelData(this.channelIndex));
if(this.done) return false
this.wasmMem.set(inputs[0].getChannelData(this.channelIndex))
this.recognizerPort.postMessage("0")
outputs = inputs
return true

36
src/recognizer.cc
View File

@@ -1,25 +1,25 @@
#include "recognizer.h"
recognizer::recognizer(model* mdl, float sampleRate, int index) : index(index) {
auto main{[this, mdl, sampleRate](){
rec = vosk_recognizer_new(mdl->mdl,sampleRate);
recognizer::recognizer(genericModel* model, float sampleRate, int index) : index(index) {
auto main{[this, model, sampleRate](){
rec = vosk_recognizer_new(std::get<0>(model->mdl),sampleRate);
finishConstruction();
}};
tryStealMdlThrd(main, mdl);
tryStealMdlThrd(main, model);
}
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);
recognizer::recognizer(genericModel* model, genericModel* spkMdl, float sampleRate, int index) {
auto main{[this, model, sampleRate, spkMdl](){
rec = vosk_recognizer_new_spk(std::get<0>(model->mdl), sampleRate, std::get<1>(spkMdl->mdl));
finishConstruction();
}};
tryStealMdlThrd(main, mdl);
tryStealMdlThrd(main, model);
}
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());
recognizer::recognizer(genericModel* model, const std::string& grm, float sampleRate, int index, int dummy) {
auto main{[this, model, sampleRate, grm](){
rec = vosk_recognizer_new_grm(std::get<0>(model->mdl), sampleRate, grm.c_str());
finishConstruction();
}};
tryStealMdlThrd(main, mdl);
tryStealMdlThrd(main, model);
}
recognizer::~recognizer() {
done.test_and_set(std::memory_order_relaxed);
@@ -29,10 +29,10 @@ 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;
void recognizer::tryStealMdlThrd(std::function<void()>&& main, genericModel* model) {
if(model->recognizerUsedThrd) {
model->thrd.addTask(std::move(main));
model->recognizerUsedThrd = true;
return;
}
std::thread t{main};
@@ -64,8 +64,8 @@ void recognizer::acceptWaveForm() {
void recognizer::setGrm(const std::string& grm) {
vosk_recognizer_set_grm(rec, grm.c_str());
}
void recognizer::setSpkModel(spkModel* mdl) {
vosk_recognizer_set_spk_model(rec, mdl->mdl);
void recognizer::setSpkModel(genericModel* spkModel) {
vosk_recognizer_set_spk_model(rec, std::get<1>(spkModel->mdl));
}
void recognizer::setWords(bool words) {
vosk_recognizer_set_words(rec,words);

13
src/recognizer.h
View File

@@ -1,6 +1,5 @@
#pragma once
#include "model.h"
#include "spkModel.h"
#include "genericModel.h"
#include "global.h"
struct recognizer {
@@ -9,14 +8,14 @@ struct recognizer {
float* dataPtr{};
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(genericModel* model, float sampleRate, int index);
recognizer(genericModel* model, genericModel* spkModel, float sampleRate, int index);
recognizer(genericModel* model, const std::string& grm, float sampleRate, int index, int dummy);
~recognizer();
void finishConstruction();
void tryStealMdlThrd(std::function<void()>&& main, model* mdl);
void tryStealMdlThrd(std::function<void()>&& main, genericModel* mdl);
void acceptWaveForm();
void setSpkModel(spkModel* model);
void setSpkModel(genericModel* model);
void setGrm(const std::string& grm);
void setWords(bool words);
void setPartialWords(bool partialWords);

37
src/spkModel.cc
View File

@@ -1,37 +0,0 @@
#include "spkModel.h"
spkModel::spkModel(const std::string& storepath, const std::string& id, int index) : genericModel(storepath, id, index) {
mdl = vosk_spk_model_new(".");
if(mdl == nullptr) {
fireEv("_continue", "Unable to initialize speaker model", index);
}
}
spkModel::~spkModel() {
vosk_spk_model_free(mdl);
}
void spkModel::checkModel() {
genericModel::checkModel();
}
void spkModel::afterFetch() {
genericModel::afterFetch();
}
void spkModel::load(bool newTask) {
auto main{[this](){
mdl = vosk_spk_model_new(".");
if(mdl == nullptr) {
fireEv("_continue", "Unable to load model for recognition", index);
return;
}
fireEv("_continue", nullptr, index);
}};
if(!newTask) {
main();
return;
}
thrd.addTask(main);
}
bool spkModel::checkModelFiles() {
return fs::exists("mfcc.conf", tank) &&
fs::exists("final.ext.raw", tank) &&
fs::exists("mean.vec", tank) &&
fs::exists("transform.mat", tank);
}

12
src/spkModel.h
View File

@@ -1,12 +0,0 @@
#pragma once
#include "genericModel.h"
struct spkModel : genericModel {
bool checkModelFiles();
VoskSpkModel* mdl{};
spkModel(const std::string& storepath, const std::string& id, int index);
void checkModel();
void afterFetch();
void load(bool newTask);
~spkModel();
};