Move to 3-value endpointer config

go/vosk.go

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

python/example/test_ep.py

@@ -41,7 +41,7 @@ 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)
+rec.SetEndpointerDelays(300, 500, 2000)
 
 while True:
     data = wf.readframes(4000)

python/example/test_gradio.py

@@ -1,39 +1,40 @@
-#!/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)
+#!/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)

python/vosk/__init__.py

@@ -144,9 +144,15 @@ class SpkModel:
 
 class EndpointerMode(enum.Enum):
     DEFAULT = 0
-    SHORT = 1
-    LONG = 2
-    VERY_LONG = 3
+    SINGLE_WORD = 1
+    VERY_SHORT = 2
+    SHORT = 3
+    STANDARD = 4
+    STANDARD_5 = 5
+    STANDARD_180 = 6
+    LONG = 7
+    VERY_LONG = 8
+    VERY_LONG_180 = 9
 
 class KaldiRecognizer:
 
@@ -183,8 +189,8 @@ class KaldiRecognizer:
     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 SetEndpointerDelays(self, sct, nit, t):
+        _c.vosk_recognizer_set_endpointer_delays(self._handle, sct, nit, t)
 
     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", type=str,
-        help="use server for recognition. For example ws://localhost:2700")
+        "--server", "-s", const="ws://localhost:2700", action="store_const",
+        help="use server for recognition")
 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

@@ -222,36 +222,110 @@ void Recognizer::SetNLSML(bool nlsml)
 
 void Recognizer::SetEndpointerMode(int mode)
 {
+    float rule1, rule2, rule3, rule4, rule5;
+    if (mode == 0) {
+        endpoint_config_ = model_->endpoint_config_;
+        return;
+    }
+
     float scale = 1.0;
     switch(mode) {
-        case 1:
-           scale = 0.75;
+        case 1: // SINGLE_WORD
+           rule2 = 0.1;
+           rule3 = 0.15;
+           rule4 = 0.2;
+           rule1 = 4.0;
+           rule5 = 7.0;
            break;
-        case 2:
-           scale = 1.50;
+        case 2: // VERY_SHORT
+           rule2 = 0.3;
+           rule3 = 0.3;
+           rule4 = 0.6;
+           rule1 = 3.0;
+           rule5 = 5.0;
            break;
-        case 3:
-           scale = 4.0;
+        case 3: // SHORT
+           rule2 = 0.3;
+           rule3 = 0.4;
+           rule4 = 0.6;
+           rule1 = 3.0;
+           rule5 = 5.0;
+           break;
+        case 4: // STANDARD
+           rule2 = 0.8;
+           rule3 = 0.9;
+           rule4 = 1.0;
+           rule1 = 3.0;
+           rule5 = 7.0;
+           break;
+        case 5: // STANDARD_5
+           rule2 = 0.8;
+           rule3 = 0.9;
+           rule4 = 1.5;
+           rule1 = 5.0;
+           rule5 = 7.0;
+           break;
+        case 6: // STANDARD_180
+           rule2 = 0.8;
+           rule3 = 0.9;
+           rule4 = 1.5;
+           rule1 = 3.0;
+           rule5 = 180.0;
+           break;
+        case 7: // LONG
+           rule2 = 1.0;
+           rule3 = 1.2;
+           rule4 = 2.0;
+           rule1 = 4.0;
+           rule5 = 10.0;
+           break;
+        case 8: // VERY_LONG
+           rule2 = 2.0;
+           rule3 = 2.5;
+           rule4 = 3.0;
+           rule1 = 4.0;
+           rule5 = 15.0;
+           break;
+        case 9: // VERY_LONG_180
+           rule2 = 2.0;
+           rule3 = 2.5;
+           rule4 = 3.0;
+           rule1 = 4.0;
+           rule5 = 180.0;
+           break;
+        default: // STANDARD
+           rule2 = 0.8;
+           rule3 = 0.9;
+           rule4 = 1.0;
+           rule1 = 5.0;
+           rule5 = 7.0;
            break;
     }
-    KALDI_LOG << "Updating endpointer scale " << scale;
+    KALDI_LOG << "Updating endpointer timeouts to " << rule1 << "," << rule2 << "," << rule3 << "," << rule4 << "," << rule5;
     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;
+    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::SetEndpointerDelays(float t_start_max, float t_end, float t_max)
+void Recognizer::SetEndpointerDelays(int sct, int nit, int t)
 {
     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;
+    rule2 = sct / 1000.0;
+    if (sct < 500) {
+        rule3 = sct / 1000.0 * 1.5;
+        rule4 = sct / 1000.0 * 2;
+    } else  {
+        rule3 = sct / 1000.0 + 0.5;
+        rule4 = sct / 1000.0 + 1.0;
+    }
+    rule1 = nit / 1000.0;
+    rule5 = t / 1000.0;
 
-    KALDI_LOG << "Updating endpointer delays " << rule1 << "," << rule2 << "," << rule3 << "," << rule4 << "," << rule5;
+    KALDI_LOG << "Updating endpointer timeouts to " << rule1 << "," << rule2 << "," << rule3 << "," << rule4 << "," << rule5;
     endpoint_config_ = model_->endpoint_config_;
     endpoint_config_.rule1.min_trailing_silence = rule1;
     endpoint_config_.rule2.min_trailing_silence = rule2;

src/recognizer.h

@@ -53,7 +53,7 @@ class Recognizer {
         void SetPartialWords(bool partial_words);
         void SetNLSML(bool nlsml);
         void SetEndpointerMode(int mode);
-        void SetEndpointerDelays(float t_start_max, float t_end, float t_max);
+        void SetEndpointerDelays(int sct, int nit, int t);
         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

@@ -137,12 +137,12 @@ void vosk_recognizer_set_endpointer_mode(VoskRecognizer *recognizer, VoskEndpoin
     ((Recognizer *)recognizer)->SetEndpointerMode(mode);
 }
 
-void vosk_recognizer_set_endpointer_delays(VoskRecognizer *recognizer, float t_start_max, float t_end, float t_max)
+void vosk_recognizer_set_endpointer_delays(VoskRecognizer *recognizer, int sct, int nit, int t)
 {
     if (recognizer == nullptr) {
        return;
     }
-    ((Recognizer *)recognizer)->SetEndpointerDelays(t_start_max, t_end, t_max);
+    ((Recognizer *)recognizer)->SetEndpointerDelays(sct, nit, t);
 }
 
 int vosk_recognizer_accept_waveform(VoskRecognizer *recognizer, const char *data, int length)

src/vosk_api.h

@@ -217,11 +217,17 @@ void vosk_recognizer_set_partial_words(VoskRecognizer *recognizer, int partial_w
  */
 void vosk_recognizer_set_nlsml(VoskRecognizer *recognizer, int nlsml);
 
-typedef enum VoskEpMode {
-    VOSK_EP_ANSWER_DEFAULT = 0,
-    VOSK_EP_ANSWER_SHORT = 1,
-    VOSK_EP_ANSWER_LONG = 2,
-    VOSK_EP_ANSWER_VERY_LONG = 3,
+typedef enum VoskEndpointerMode {
+    VOSK_EP_DEFAULT = 0,
+    VOSK_EP_SINGLE_WORD = 1,
+    VOSK_EP_VERY_SHORT = 2,
+    VOSK_EP_SHORT = 3,
+    VOSK_EP_STANDARD = 4,
+    VOSK_EP_STANDARD_5 = 5,
+    VOSK_EP_STANDARD_180 = 6,
+    VOSK_EP_LONG = 7,
+    VOSK_EP_VERY_LONG = 8,
+    VOSK_EP_VERY_LONG_180 = 9
 } VoskEndpointerMode;
 
 /**
@@ -234,11 +240,12 @@ void vosk_recognizer_set_endpointer_mode(VoskRecognizer *recognizer,  VoskEndpoi
 /**
  * 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)
+ * @param sct   speech complete timeout
+ * @param sint  speech incomplete timeout
+ * @param nit   no input timeout
+ * @param t     recognition timeout
  **/
-void vosk_recognizer_set_endpointer_delays(VoskRecognizer *recognizer, float t_start_max, float t_end, float t_max);
+void vosk_recognizer_set_endpointer_delays(VoskRecognizer *recognizer, int sct, int nit, int t);
 
 /** Accept voice data
  *