Update to latest gradio

go/vosk.go

@@ -1,7 +1,8 @@
 package vosk
 
 // #cgo CPPFLAGS: -I ${SRCDIR}/../src
-// #cgo LDFLAGS: -L ${SRCDIR}/../src -lvosk -ldl -lpthread
+// #cgo !windows LDFLAGS: -L ${SRCDIR}/../src -lvosk -ldl -lpthread
+// #cgo windows LDFLAGS: -L ${SRCDIR}/../src -lvosk -lpthread
 // #include <stdlib.h>
 // #include <vosk_api.h>
 import "C"

python/example/test_ep.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+
+import wave
+import sys
+
+from vosk import Model, KaldiRecognizer, SetLogLevel, EndpointerMode
+
+# You can set log level to -1 to disable debug messages
+SetLogLevel(0)
+
+wf = wave.open(sys.argv[1], "rb")
+if wf.getnchannels() != 1 or wf.getsampwidth() != 2 or wf.getcomptype() != "NONE":
+    print("Audio file must be WAV format mono PCM.")
+    sys.exit(1)
+
+model = Model(lang="en-us")
+
+# You can also init model by name or with a folder path
+# model = Model(model_name="vosk-model-en-us-0.21")
+# model = Model("models/en")
+
+rec = KaldiRecognizer(model, wf.getframerate())
+rec.SetWords(True)
+rec.SetPartialWords(True)
+rec.SetEndpointerMode(EndpointerMode.VERY_LONG)
+
+while True:
+    data = wf.readframes(4000)
+    if len(data) == 0:
+        break
+    if rec.AcceptWaveform(data):
+        print(rec.Result())
+    else:
+        print(rec.PartialResult())
+
+print(rec.FinalResult())
+
+
+wf = wave.open(sys.argv[1], "rb")
+if wf.getnchannels() != 1 or wf.getsampwidth() != 2 or wf.getcomptype() != "NONE":
+    print("Audio file must be WAV format mono PCM.")
+    sys.exit(1)
+
+rec.SetEndpointerDelays(0.5, 0.3, 10.0)
+
+while True:
+    data = wf.readframes(4000)
+    if len(data) == 0:
+        break
+    if rec.AcceptWaveform(data):
+        print(rec.Result())
+    else:
+        print(rec.PartialResult())
+
+print(rec.FinalResult())

python/example/test_gradio.py

@@ -1,40 +1,39 @@
-#!/usr/bin/env python3
-
-import json
-import gradio as gr
-
-from vosk import KaldiRecognizer, Model
-
-model = Model(lang="en-us")
-
-def transcribe(data, state):
-    sample_rate, audio_data = data
-    audio_data = (audio_data >> 16).astype("int16").tobytes()
-
-    if state is None:
-        rec = KaldiRecognizer(model, sample_rate)
-        result = []
-    else:
-        rec, result = state
-
-    if rec.AcceptWaveform(audio_data):
-        text_result = json.loads(rec.Result())["text"]
-        if text_result != "":
-            result.append(text_result)
-        partial_result = ""
-    else:
-        partial_result = json.loads(rec.PartialResult())["partial"] + " "
-
-    return "\n".join(result) + "\n" + partial_result, (rec, result)
-
-gr.Interface(
-    fn=transcribe,
-    inputs=[
-        gr.Audio(source="microphone", type="numpy", streaming=True),
-        "state"
-    ],
-    outputs=[
-        "textbox",
-        "state"
-    ],
-    live=True).launch(share=True)
+#!/usr/bin/env python3
+
+import json
+import gradio as gr
+
+from vosk import KaldiRecognizer, Model
+
+model = Model(lang="en-us")
+
+def transcribe(stream, new_chunk):
+
+    sample_rate, audio_data = new_chunk
+    audio_data = audio_data.tobytes()
+
+    if stream is None:
+        rec = KaldiRecognizer(model, sample_rate)
+        result = []
+    else:
+        rec, result = stream
+
+    if rec.AcceptWaveform(audio_data):
+        text_result = json.loads(rec.Result())["text"]
+        if text_result != "":
+            result.append(text_result)
+        partial_result = ""
+    else:
+        partial_result = json.loads(rec.PartialResult())["partial"] + " "
+
+    return (rec, result), "\n".join(result) + "\n" + partial_result
+
+gr.Interface(
+    fn=transcribe,
+    inputs=[
+        "state", gr.Audio(sources=["microphone"], type="numpy", streaming=True),
+    ],
+    outputs=[
+        "state", "text",
+    ],
+    live=True).launch(share=True)

python/setup.py

@@ -45,7 +45,7 @@ with open("README.md", "rb") as fh:
 
 setuptools.setup(
     name="vosk",
-    version="0.3.45",
+    version="0.3.46",
     author="Alpha Cephei Inc",
     author_email="contact@alphacephei.com",
     description="Offline open source speech recognition API based on Kaldi and Vosk",

python/vosk/__init__.py

@@ -142,10 +142,11 @@ class SpkModel:
     def __del__(self):
         _c.vosk_spk_model_free(self._handle)
 
-class EpMode(enum.Enum):
+class EndpointerMode(enum.Enum):
     DEFAULT = 0
     SHORT = 1
     LONG = 2
+    VERY_LONG = 3
 
 class KaldiRecognizer:
 
@@ -179,8 +180,11 @@ class KaldiRecognizer:
     def SetNLSML(self, enable_nlsml):
         _c.vosk_recognizer_set_nlsml(self._handle, 1 if enable_nlsml else 0)
 
-    def SetEpMode(self, mode):
-        _c.vosk_recognizer_set_ep_mode(self._handle, mode.value)
+    def SetEndpointerMode(self, mode):
+        _c.vosk_recognizer_set_endpointer_mode(self._handle, mode.value)
+
+    def SetEndpointerDelays(self, t_start_max, t_end, t_max):
+        _c.vosk_recognizer_set_endpointer_delays(self._handle, t_start_max, t_end, t_max)
 
     def SetSpkModel(self, spk_model):
         _c.vosk_recognizer_set_spk_model(self._handle, spk_model._handle)

python/vosk/transcriber/cli.py

@@ -15,8 +15,8 @@ parser.add_argument(
         "--model", "-m", type=str,
         help="model path")
 parser.add_argument(
-        "--server", "-s", const="ws://localhost:2700", action="store_const",
-        help="use server for recognition")
+        "--server", "-s", type=str,
+        help="use server for recognition. For example ws://localhost:2700")
 parser.add_argument(
         "--list-models", default=False, action="store_true",
         help="list available models")

python/vosk/transcriber/transcriber.py

@@ -99,7 +99,7 @@ class Transcriber:
             monologues = {"schemaVersion":"2.0", "monologues":[], "text":[]}
             for part in result:
                 if part["text"] != "":
-                    monologues["text"] += part["text"]
+                    monologues["text"] += [part["text"]]
             for _, res in enumerate(result):
                 if not "result" in res:
                     continue

src/recognizer.cc

@@ -220,7 +220,7 @@ void Recognizer::SetNLSML(bool nlsml)
     nlsml_ = nlsml;
 }
 
-void Recognizer::SetEpMode(int mode)
+void Recognizer::SetEndpointerMode(int mode)
 {
     float scale = 1.0;
     switch(mode) {
@@ -230,16 +230,37 @@ void Recognizer::SetEpMode(int mode)
         case 2:
            scale = 1.50;
            break;
-        default:
+        case 3:
            scale = 4.0;
+           break;
     }
-    KALDI_LOG << "Endpointer Scale " << scale;
+    KALDI_LOG << "Updating endpointer scale " << scale;
     endpoint_config_ = model_->endpoint_config_;
     endpoint_config_.rule2.min_trailing_silence *= scale;
     endpoint_config_.rule3.min_trailing_silence *= scale;
     endpoint_config_.rule4.min_trailing_silence *= scale;
 }
 
+void Recognizer::SetEndpointerDelays(float t_start_max, float t_end, float t_max)
+{
+    float rule1, rule2, rule3, rule4, rule5;
+
+    rule1 = t_start_max;
+    rule2 = t_end;
+    rule3 = t_end * 1.5;
+    rule4 = t_end * 2;
+    rule5 = t_max;
+
+    KALDI_LOG << "Updating endpointer delays " << rule1 << "," << rule2 << "," << rule3 << "," << rule4 << "," << rule5;
+    endpoint_config_ = model_->endpoint_config_;
+    endpoint_config_.rule1.min_trailing_silence = rule1;
+    endpoint_config_.rule2.min_trailing_silence = rule2;
+    endpoint_config_.rule3.min_trailing_silence = rule3;
+    endpoint_config_.rule4.min_trailing_silence = rule4;
+    endpoint_config_.rule5.min_utterance_length = rule5;
+}
+
+
 void Recognizer::SetSpkModel(SpkModel *spk_model)
 {
     if (state_ == RECOGNIZER_RUNNING) {

src/recognizer.h

@@ -52,7 +52,8 @@ class Recognizer {
         void SetWords(bool words);
         void SetPartialWords(bool partial_words);
         void SetNLSML(bool nlsml);
-        void SetEpMode(int mode);
+        void SetEndpointerMode(int mode);
+        void SetEndpointerDelays(float t_start_max, float t_end, float t_max);
         bool AcceptWaveform(const char *data, int len);
         bool AcceptWaveform(const short *sdata, int len);
         bool AcceptWaveform(const float *fdata, int len);

src/vosk_api.cc

@@ -129,12 +129,20 @@ void vosk_recognizer_set_grm(VoskRecognizer *recognizer, char const *grammar)
     ((Recognizer *)recognizer)->SetGrm(grammar);
 }
 
-void vosk_recognizer_set_ep_mode(VoskRecognizer *recognizer, VoskEpMode mode)
+void vosk_recognizer_set_endpointer_mode(VoskRecognizer *recognizer, VoskEndpointerMode mode)
 {
     if (recognizer == nullptr) {
        return;
     }
-    ((Recognizer *)recognizer)->SetEpMode(mode);
+    ((Recognizer *)recognizer)->SetEndpointerMode(mode);
+}
+
+void vosk_recognizer_set_endpointer_delays(VoskRecognizer *recognizer, float t_start_max, float t_end, float t_max)
+{
+    if (recognizer == nullptr) {
+       return;
+    }
+    ((Recognizer *)recognizer)->SetEndpointerDelays(t_start_max, t_end, t_max);
 }
 
 int vosk_recognizer_accept_waveform(VoskRecognizer *recognizer, const char *data, int length)

src/vosk_api.h

@@ -221,14 +221,24 @@ typedef enum VoskEpMode {
     VOSK_EP_ANSWER_DEFAULT = 0,
     VOSK_EP_ANSWER_SHORT = 1,
     VOSK_EP_ANSWER_LONG = 2,
-} VoskEpMode;
+    VOSK_EP_ANSWER_VERY_LONG = 3,
+} VoskEndpointerMode;
 
 /**
  * Set endpointer scaling factor
  *
  * @param mode - Endpointer mode
  **/
-void vosk_recognizer_set_ep_mode(VoskRecognizer *recognizer,  VoskEpMode mode);
+void vosk_recognizer_set_endpointer_mode(VoskRecognizer *recognizer,  VoskEndpointerMode mode);
+
+/**
+ * Set endpointer delays
+ *
+ * @param t_start_max     timeout for stopping recognition in case of initial silence (usually around 5.0)
+ * @param t_end           timeout for stopping recognition in milliseconds after we recognized something (usually around 0.5 - 1.0)
+ * @param t_max           timeout for forcing utterance end in milliseconds (usually around 20-30)
+ **/
+void vosk_recognizer_set_endpointer_delays(VoskRecognizer *recognizer, float t_start_max, float t_end, float t_max);
 
 /** Accept voice data
  *