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

Use wasmfs memfs backend instead for speedup and 1 less extra thread. Reorder function argument

Browse Source
This commit is contained in:
msqr1
2024-03-20 23:30:30 -07:00
parent 37e526cbc1
commit 638de69e67
12 changed files with 417 additions and 1108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/bindings.cc
View File

@@ -7,14 +7,13 @@ using namespace emscripten;
EMSCRIPTEN_BINDINGS() {
function("setLogLevel", &vosk_set_log_level, 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());
.constructor<int, bool, std::string, std::string>(allow_raw_pointers())
.function("extractAndLoad", &genericModel::extractAndLoad, allow_raw_pointers());
class_<recognizer>("recognizer")
.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())
.constructor<int, float, genericModel*>(allow_raw_pointers())
.constructor<int, float, genericModel*, genericModel*>(allow_raw_pointers())
.constructor<int, float, genericModel*, std::string, 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())

189
src/genericModel.cc
View File

@@ -1,156 +1,57 @@
#include "genericModel.h"
genericModel::genericModel(std::string storepath, std::string id, int index, bool normalMdl) : index(index), normalMdl(normalMdl), storepath("/opfs/" + std::move(storepath)), id(std::move(id)), entry(archive_entry_new()) {}
void genericModel::load() {
thrd.addTask([this](){
if(normalMdl) mdl = vosk_model_new(storepath.c_str());
genericModel::genericModel(int index, bool normalMdl, std::string storepath, std::string id) : index(index), normalMdl(normalMdl), storepath(std::move(storepath)), id(std::move(id)), entry(archive_entry_new()) {}
void genericModel::extractAndLoad(int tarStart, int tarSize) {
static fs::path path{};
static int fd{};
thrd.addTask([this, tarStart, tarSize](){
archive* src {archive_read_new()};
archive_read_support_format_tar(src);
archive_read_open_memory(src, (void*)tarStart, tarSize);
free((void*)tarStart);
if(archive_errno(src) != 0) {
emscripten_console_logf("Unable to open tar in WASM memory: %s", archive_error_string(src));
fireEv(index, "Unable to open tar in WASM memory");
return;
}
while(1) {
if(archive_read_next_header2(src, entry) != ARCHIVE_OK) {
emscripten_console_logf("Tar header read failed: %s", archive_error_string(src));
fireEv(index, "Tar header read failed");
return;
}
path = archive_entry_pathname(entry);
path = storepath + path.generic_string().substr(path.generic_string().find("/"));
emscripten_console_logf("Creating file or directory %s", path.c_str());
if(!path.has_extension()) {
fs::create_directory(path);
continue;
}
fd = creat(path.c_str(),0777);
if(fd == -1) {
emscripten_console_log("Unable to create model files");
fireEv(index, "Unable to create model files");
return;
}
archive_read_data_into_fd(src, fd);
close(fd);
if(archive_errno(src) != 0) {
emscripten_console_logf("Cannot write into model files: %s", archive_error_string(src));
fireEv(index, "Cannot write into model files");
return;
}
}
fs::remove(storepath + "/README");
archive_read_free(src);
/*if(normalMdl) mdl = vosk_model_new(storepath.c_str());
else vosk_spk_model_new(storepath.c_str());
emscripten_console_log("Loading finished!");
if(normalMdl ? std::get<0>(mdl) == nullptr : std::get<1>(mdl) == nullptr) fireEv(index, "Unable to load model for recognition");
else fireEv(index, "0");
else fireEv(index, "0");*/
});
}
bool genericModel::checkFiles() {
if(normalMdl) {
return fs::exists(storepath + "/am/final.mdl") &&
fs::exists(storepath + "/conf/mfcc.conf") &&
fs::exists(storepath + "/conf/model.conf") &&
fs::exists(storepath + "/graph/phones/word_boundary.int") &&
fs::exists(storepath + "/graph/Gr.fst") &&
fs::exists(storepath + "/graph/HCLr.fst") &&
fs::exists(storepath + "/graph/disambig_tid.int") &&
fs::exists(storepath + "/ivector/final.dubm") &&
fs::exists(storepath + "/ivector/final.ie") &&
fs::exists(storepath + "/ivector/final.mat") &&
fs::exists(storepath + "/ivector/global_cmvn.stats") &&
fs::exists(storepath + "/ivector/online_cmvn.conf") &&
fs::exists(storepath + "/ivector/splice.conf");
}
return fs::exists(storepath + "/mfcc.conf") &&
fs::exists(storepath + "/final.ext.raw") &&
fs::exists(storepath + "/mean.vec") &&
fs::exists(storepath + "/transform.mat");
}
genericModel::~genericModel() {
archive_entry_free(entry);
if(normalMdl) vosk_model_free(std::get<0>(mdl));
else vosk_spk_model_free(std::get<1>(mdl));
}
void genericModel::check() {
thrd.addTask([this](){
if(OPFSTried && !OPFSOk) {
emscripten_console_log("OPFS isn't available");
fireEv(index, "OPFS isn't available");
return;
}
if(!OPFSTried){
emscripten_console_log("Trying to acquire OPFS");
OPFSTried = true;
OPFSOk = wasmfs_create_directory("/opfs", 0777, wasmfs_create_opfs_backend()) == 0;
};
emscripten_console_log("Initializing OPFS");
if(!OPFSOk) {
emscripten_console_log("OPFS initialization failed");
fireEv(index, "OPFS initialization failed");
return;
}
if(!checkFiles() && !fs::exists(storepath + "/id")) {
emscripten_console_log("Model is not available or incorrect file, fetching...");
fireEv(index, "1");
return;
}
emscripten_console_log("Model is available, verifying ID");
std::ifstream idFile(storepath + "/id");
idFile.seekg(0, std::ios::end);
size_t oldSize = idFile.tellg();
std::string oldID(oldSize, ' ');
idFile.seekg(0);
idFile.read(&oldID[0], oldSize);
if(id.compare(oldID.c_str()) != 0) {
emscripten_console_log("ID doesn't match, fetching...");
fireEv(index, "1");
}
else {
emscripten_console_log("ID matches, loading...");
load();
}
emscripten_console_log("Success! Model is ready!");
});
}
void genericModel::afterFetch() {
thrd.addTask([this](){
emscripten_console_log("Trying to extract...");
if(!extract()) {
fs::remove(storepath + ".tar");
fs::remove_all(storepath);
emscripten_console_log("Unable to extract model");
fireEv(index, "Unable to extract model");
return;
}
emscripten_console_log("Extract done, checking files...");
if(!checkFiles()) {
emscripten_console_log("URL points to invalid model files");
fireEv(index, "URL points to invalid model files");
return;
}
emscripten_console_log("Creating ID file...");
int idFd {creat((storepath + "/id").c_str(),0777)};
if(idFd == -1) {
emscripten_console_log("Unable to create ID file");
fireEv(index, "Unable to create ID file");
fs::remove(storepath + ".tar");
fs::remove_all(storepath);
return;
}
emscripten_console_log("Writing ID...");
if(write(idFd,id.data(), id.size()) == -1) {
emscripten_console_log("Unable to write new ID");
fireEv(index, "Unable to write new ID");
fs::remove(storepath + ".tar");
fs::remove_all(storepath);
close(idFd);
return;
};
close(idFd);
emscripten_console_log("Success! Model is ready!");
});
load();
}
bool genericModel::extract() {
static fs::path path{};
static int fd{};
archive* src {archive_read_new()};
archive_read_support_format_tar(src);
archive_read_open_filename(src, (storepath + ".tar").c_str(), 10240);
if(archive_errno(src) != 0) {
emscripten_console_log(archive_error_string(src));
return false;
}
while(archive_read_next_header2(src, entry) == ARCHIVE_OK) {
if(archive_errno(src) != 0) {
emscripten_console_log(archive_error_string(src));
return false;
}
path = archive_entry_pathname(entry);
path = storepath + path.generic_string().substr(path.generic_string().find("/"));
emscripten_console_logf("Creating file/dir %s", path.c_str());
if(!path.has_extension()) {
fs::create_directory(path);
continue;
}
fd = creat(path.c_str(),0777);
if(fd == -1) {
return false;
}
archive_read_data_into_fd(src, fd);
close(fd);
if(archive_errno(src) != 0) {
emscripten_console_log(archive_error_string(src));
return false;
}
}
fs::remove(storepath + "/README");
fs::remove(storepath + ".tar" );
archive_read_free(src);
return true;
}

11
src/genericModel.h
View File

@@ -1,7 +1,6 @@
#pragma once
#include "jsBridge.h"
#include "proxier.h"
#include <string>
#include <filesystem>
#include <fstream>
#include <fcntl.h>
@@ -20,12 +19,8 @@ struct genericModel {
std::variant<VoskModel*, VoskSpkModel*> mdl;
reusableThrd thrd;
archive_entry* entry;
bool extract();
void load();
void check();
bool checkFiles();
void afterFetch();
genericModel(std::string storepath, std::string id, int index, bool normalMdl);
void extractAndLoad(int tarStart, int tarSize);
genericModel(int index, bool normalMdl, std::string storepath, std::string id);
~genericModel();
};

117
src/pre.js
View File

@@ -8,6 +8,14 @@ Module.locateFile = (path, scriptDir) => {
if(path === "Vosklet.js") return pthreadUrl
return scriptDir+path
}
async function getFileHandle(path, create = false) {
let components = path.split("/")
let prevDir = await navigator.storage.getDirectory()
for(let component of components.slice(0, -1)) {
prevDir = await prevDir.getDirectoryHandle(component, { create : create })
}
return prevDir.getFileHandle(components[components.length - 1], { create : create })
}
class genericModel extends EventTarget {
constructor(url, storepath, id, normalMdl) {
super()
@@ -18,39 +26,46 @@ class genericModel extends EventTarget {
this.normalMdl = normalMdl
}
static async _init(url, storepath, id, normalMdl) {
return new Promise((resolve, reject) => {
let mdl = new genericModel(url, storepath, id, normalMdl)
mdl.addEventListener("0", async function listener(ev) {
switch(ev.detail) {
case "0":
mdl.removeEventListener("0", listener)
return resolve(mdl)
case "1":
let res = await fetch(url)
if(!res.ok) {
return reject("Unable to download model")
}
let wStream = await (await (await navigator.storage.getDirectory()).getFileHandle(storepath + ".tar", {create : true})).createWritable()
let tarReader = res.body.pipeThrough(new DecompressionStream("gzip")).getReader()
while(true) {
let readRes = await tarReader.read()
if(!readRes.done) await wStream.write(readRes.value)
else break
}
tarReader.releaseLock()
await wStream.close()
console.log("Fetching and writing tar done!")
mdl.obj.afterFetch()
break
default:
mdl.delete()
mdl.removeEventListener("0", listener)
reject(ev.detail)
let mdl = new genericModel(url, storepath, id, normalMdl)
let tar
mdl.addEventListener("0", async (ev) => {
switch(ev.detail) {
case "0":
return mdl
default:
mdl.delete()
throw ev.detail
}
}, { once : true })
mdl.obj = new Module.genericModel(objs.length - 1, normalMdl, "/" + storepath, id)
try {
let dataFile = await (await getFileHandle(storepath + "/model.tgz")).getFile()
let idFile = await (await getFileHandle(storepath + "/id")).getFile()
if(await idFile.text() !== id) throw ""
tar = await new Response(dataFile.stream().pipeThrough(new DecompressionStream("gzip"))).arrayBuffer()
}
catch {
try {
let res = await fetch(url)
if(!res.ok) {
throw "Unable to download model"
}
})
mdl.obj = new Module.genericModel(storepath, id, objs.length-1, normalMdl)
mdl.obj.check()
})
let newDataFile = await (await getFileHandle(storepath + "/model.tgz", true)).createWritable()
tar = await new Response(res.body.pipeThrough(new DecompressionStream("gzip"))).arrayBuffer()
await newDataFile.write(tar)
await newDataFile.close()
let newIDFile = await (await getFileHandle(storepath + "/id", true)).createWritable()
await newIDFile.write(id)
await newIDFile.close()
}
catch(e) {
mdl.obj.delete()
throw e
}
}
let tarStart = Module._malloc(tar.byteLength)
Module.HEAPU8.set(new Uint8Array(tar), tarStart)
mdl.obj.extractAndLoad(tarStart, tar.byteLength)
}
delete() {
if (this.obj) this.obj.delete()
@@ -68,27 +83,25 @@ class Recognizer extends EventTarget {
objs.push(this)
}
static async _init(model, sampleRate, mode, grammar, spkModel) {
return new Promise((resolve, reject) => {
let rec = new Recognizer()
rec.addEventListener("0", (ev) => {
if(ev.detail === "0") {
rec.ptr = Module._malloc(512)
return resolve(rec)
}
rec.delete()
reject(ev.detail)
}, {once : true})
switch(mode) {
case 1:
rec.obj = new Module.recognizer(model, sampleRate, objs.length-1)
break
case 2:
rec.obj = new Module.recognizer(model, spkModel, sampleRate, objs.length-1)
break
default:
rec.obj = new Module.recognizer(model, grammar, sampleRate, objs.length-1, 0)
let rec = new Recognizer()
rec.addEventListener("0", (ev) => {
if(ev.detail === "0") {
rec.ptr = Module._malloc(512)
return rec
}
})
rec.delete()
throw ev.detail
}, { once : true })
switch(mode) {
case 1:
rec.obj = new Module.recognizer(model, sampleRate, objs.length-1)
break
case 2:
rec.obj = new Module.recognizer(model, spkModel, sampleRate, objs.length-1)
break
default:
rec.obj = new Module.recognizer(model, grammar, sampleRate, objs.length-1, 0)
}
}
async getNode(ctx, channelIndex = 0) {
if(typeof this.node === "undefined") {

4
src/JSBridge.cc → src/proxier.cc
View File

@@ -1,8 +1,6 @@
#include "jsBridge.h"
#include "proxier.h"
pthread_t dstThrd{pthread_self()};
bool OPFSOk{};
bool OPFSTried{};
ProxyingQueue glbQ{};
void fireEv(int index, const char* content, const char* type) {
auto proxy{[index, content, type](){

5
src/jsBridge.h → src/proxier.h
View File

@@ -2,7 +2,6 @@
#include <thread>
#include <mutex>
#include <queue>
#include <condition_variable>
#include <emscripten/wasmfs.h>
#include <emscripten/console.h>
@@ -10,9 +9,6 @@
#include <emscripten/proxying.h>
using namespace emscripten;
extern bool OPFSOk;
extern bool OPFSTried;
extern std::error_code tank;
extern pthread_t dstThrd;
extern ProxyingQueue glbQ;
@@ -20,7 +16,6 @@ void fireEv(int index, const char* content, const char* type = nullptr);
struct reusableThrd {
std::queue<std::function<void()>> queue{};
bool done{};
void addTask(std::function<void()>&& task);
reusableThrd();
~reusableThrd();

6
src/recognizer.cc
View File

@@ -1,16 +1,16 @@
#include "recognizer.h"
recognizer::recognizer(genericModel* model, float sampleRate, int index) : index(index) {
recognizer::recognizer(int index, float sampleRate, genericModel* model) : index(index) {
emscripten_console_log("Recognizer constructor called...");
rec = vosk_recognizer_new(std::get<0>(model->mdl),sampleRate);
finishConstruction(model, nullptr);
}
recognizer::recognizer(genericModel* model, genericModel* spkMdl, float sampleRate, int index) : index(index) {
recognizer::recognizer(int index, float sampleRate, genericModel* model, genericModel* spkMdl) : index(index) {
emscripten_console_log("Recognizer constructor called...");
rec = vosk_recognizer_new_spk(std::get<0>(model->mdl), sampleRate, std::get<1>(spkMdl->mdl));
finishConstruction(model, spkMdl);
}
recognizer::recognizer(genericModel* model, const std::string& grm, float sampleRate, int index, int dummy) : index(index) {
recognizer::recognizer(int index, float sampleRate, genericModel* model, const std::string& grm, int dummy) : index(index) {
emscripten_console_log("Recognizer constructor called...");
rec = vosk_recognizer_new_grm(std::get<0>(model->mdl), sampleRate, grm.c_str());
finishConstruction(model, nullptr);

7
src/recognizer.h
View File

@@ -1,6 +1,5 @@
#pragma once
#include "genericModel.h"
#include "jsBridge.h"
struct recognizer {
std::atomic_flag done{};
@@ -8,9 +7,9 @@ struct recognizer {
float* dataPtr;
int index;
VoskRecognizer* rec;
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(int index, float sampleRate, genericModel* model);
recognizer(int index, float sampleRate, genericModel* model, genericModel* spkModel);
recognizer(int index, float sampleRate, genericModel* model, const std::string& grm, int dummy);
~recognizer();
void finishConstruction(genericModel* model, genericModel* spkModel);
void acceptWaveForm();