whisper.cpp/bindings/javascript/emscripten.cpp at master · isbee/whisper.cpp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
//
// This is the Javascript API of whisper.cpp
//
// Very crude at the moment.
// Feel free to contribute and make this better!
//
// See the tests/test-whisper.js for sample usage
//

#include"whisper.h"

#include<emscripten.h>
#include<emscripten/bind.h>

#include<thread>
#include<vector>

structwhisper_context * g_context;

EMSCRIPTEN_BINDINGS(whisper) {
emscripten::function("init", emscripten::optional_override([](const std::string & path_model) {
if (g_context == nullptr) {
 g_context = whisper_init_from_file_with_params(path_model.c_str(), whisper_context_default_params());
if (g_context != nullptr) {
returntrue;
 } else {
returnfalse;
 }
 }

returnfalse;
 }));

emscripten::function("free", emscripten::optional_override([]() {
if (g_context) {
whisper_free(g_context);
 g_context = nullptr;
 }
 }));

emscripten::function("full_default", emscripten::optional_override([](const emscripten::val & audio, const std::string & lang, bool translate) {
if (g_context == nullptr) {
return -1;
 }

structwhisper_full_params params = whisper_full_default_params(whisper_sampling_strategy::WHISPER_SAMPLING_GREEDY);

 params.print_realtime = true;
 params.print_progress = false;
 params.print_timestamps = true;
 params.print_special = false;
 params.translate = translate;
 params.language = whisper_is_multilingual(g_context) ? lang.c_str() : "en";
 params.n_threads = std::min(8, (int) std::thread::hardware_concurrency());
 params.offset_ms = 0;

 std::vector<float> pcmf32;
constint n = audio["length"].as<int>();

 emscripten::val heap = emscripten::val::module_property("HEAPU8");
 emscripten::val memory = heap["buffer"];

 pcmf32.resize(n);

 emscripten::val memoryView = audio["constructor"].new_(memory, reinterpret_cast<uintptr_t>(pcmf32.data()), n);
 memoryView.call<void>("set", audio);

// print system information
 {
printf("\n");
printf("system_info: n_threads = %d / %d | %s\n",
 params.n_threads, std::thread::hardware_concurrency(), whisper_print_system_info());

printf("\n");
printf("%s: processing %d samples, %.1f sec, %d threads, %d processors, lang = %s, task = %s ...\n",
 __func__, int(pcmf32.size()), float(pcmf32.size())/WHISPER_SAMPLE_RATE,
 params.n_threads, 1,
 params.language,
 params.translate ? "translate" : "transcribe");

printf("\n");
 }

// run whisper
 {
whisper_reset_timings(g_context);
whisper_full(g_context, params, pcmf32.data(), pcmf32.size());
whisper_print_timings(g_context);
 }

return0;
 }));
}