Bump version to 0.3.32

are implemented, others on the way

android/lib/build-vosk.sh

@@ -105,7 +105,7 @@ make install
 
 # Kaldi itself
 cd $WORKDIR
-git clone -b android-mix --single-branch https://github.com/alphacep/kaldi
+git clone -b vosk-android --single-branch https://github.com/alphacep/kaldi
 cd $WORKDIR/kaldi/src
 CXX=$CXX CXXFLAGS="$ARCHFLAGS -O3 -DFST_NO_DYNAMIC_LINKING" ./configure --use-cuda=no \
     --mathlib=OPENBLAS_CLAPACK --shared \

csharp/demo/VoskDemo.csproj

@@ -11,7 +11,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Vosk" Version="0.3.30" />
+    <PackageReference Include="Vosk" Version="0.3.31" />
   </ItemGroup>
 
 </Project>

csharp/nuget/Vosk.nuspec

@@ -2,7 +2,7 @@
 <package>
   <metadata>
     <id>Vosk</id>
-    <version>0.3.30</version>
+    <version>0.3.32</version>
     <authors>Alpha Cephei Inc</authors>
     <owners>Alpha Cephei Inc</owners>
     <license type="expression">Apache-2.0</license>

go/COPYING

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. this License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

go/doc.go

@@ -0,0 +1,7 @@
+// Go bindings for Vosk speech recognition toolkit. Vosk is an offline
+// open source speech to text API for Android, iOS, Raspberry Pi and
+// servers. It enables speech recognition models for 18 languages and
+// dialects - English, Indian English, German, French, Spanish, Portuguese,
+// Chinese, Russian, Turkish, Vietnamese, Italian, Dutch, Catalan, Arabic,
+// Greek, Farsi, Filipino, Ukrainian.
+package vosk

go/example/doc.go

@@ -0,0 +1,2 @@
+// Example package for Vosk Go bindings.
+package test_simple

go/example/main.go

@@ -1,36 +0,0 @@
-package main
-
-import (
-    "flag"
-    "os"
-    ".."
-)
-
-func main() {
-    var filename string
-    flag.StringVar(&filename, "f", "", "file to transcribe")
-    flag.Parse()
-    model, err := vosk.NewModel("model")
-    rec, err := vosk.NewRecognizer(model)
-
-    file, err := os.Open(filename)
-    if err != nil {
-        panic(err)
-    }
-    defer file.Close()
-
-    fileinfo, err := file.Stat()
-    if err != nil {
-        panic(err)
-    }
-
-    filesize := fileinfo.Size()
-    buffer := make([]byte, filesize)
-
-    _, err = file.Read(buffer)
-    if err != nil {
-        panic(err)
-    }
-
-    println(vosk.VoskFinalResult(rec, buffer))
-}

go/example/test_simple.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+
+	vosk "github.com/alphacep/vosk-api/go"
+)
+
+func main() {
+	var filename string
+	flag.StringVar(&filename, "f", "", "file to transcribe")
+	flag.Parse()
+
+	model, err := vosk.NewModel("model")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	sampleRate := 16000.0
+	rec, err := vosk.NewRecognizer(model, sampleRate)
+	if err != nil {
+		log.Fatal(err)
+	}
+	rec.SetWords(1)
+
+	file, err := os.Open(filename)
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+
+	reader := bufio.NewReader(file)
+	buf := make([]byte, 4096)
+
+	for {
+		_, err := reader.Read(buf)
+		if err != nil {
+			if err != io.EOF {
+				log.Fatal(err)
+			}
+
+			break
+		}
+
+		if rec.AcceptWaveform(buf) != 0 {
+			fmt.Println(string(rec.Result()))
+		}
+	}
+
+	fmt.Println(string(rec.FinalResult()))
+}

go/go.mod

@@ -0,0 +1,7 @@
+module github.com/alphacep/vosk-api/go
+
+go 1.16
+
+replace (
+    github.com/alphacep/vosk-api/go => ./
+)

go/vosk.go

@@ -8,55 +8,145 @@ import "C"
 
 // VoskModel contains a reference to the C VoskModel
 type VoskModel struct {
-    model *C.struct_VoskModel
-}
-
-// VoskSpkModel contains a reference to the C VoskSpkModel
-type VoskSpkModel struct {
-    spkModel *C.struct_VoskSpkModel
-}
-
-// VoskRecognizer contains a reference to the C VoskRecognizer
-type VoskRecognizer struct {
-    rec *C.struct_VoskRecognizer
-}
-
-func VoskFinalResult(recognizer *VoskRecognizer, buffer []byte) string {
-    cbuf := C.CBytes(buffer)
-    defer C.free(cbuf)
-    _ = C.vosk_recognizer_accept_waveform(recognizer.rec, (*C.char)(cbuf), C.int(len(buffer)))
-    result := C.GoString(C.vosk_recognizer_final_result(recognizer.rec))
-    return result
+	model *C.struct_VoskModel
 }
 
 // NewModel creates a new VoskModel instance
 func NewModel(modelPath string) (*VoskModel, error) {
-    var internal *C.struct_VoskModel
-    internal = C.vosk_model_new(C.CString(modelPath))
-    model := &VoskModel{model: internal}
-    return model, nil
+	internal := C.vosk_model_new(C.CString(modelPath))
+	model := &VoskModel{model: internal}
+	return model, nil
 }
 
-// NewRecognizer creates a new VoskRecognizer instance
-func NewRecognizer(model *VoskModel) (*VoskRecognizer, error) {
-    var internal *C.struct_VoskRecognizer
-    internal = C.vosk_recognizer_new(model.model, 16000.0)
-    rec := &VoskRecognizer{rec: internal}
-    return rec, nil
+func (m *VoskModel) Free() {
+	C.vosk_model_free(m.model)
 }
 
 func freeModel(model *VoskModel) {
-    C.vosk_model_free(model.model)
+	C.vosk_model_free(model.model)
 }
 
-func freeRecognizer(recognizer *VoskRecognizer) {
-    C.vosk_recognizer_free(recognizer.rec)
+// FindWord checks if a word can be recognized by the model.
+// Returns the word symbol if the word exists inside the model or
+// -1 otherwise.
+func (m *VoskModel) FindWord(word []byte) int {
+	cbuf := C.CBytes(word)
+	defer C.free(cbuf)
+	i := C.vosk_model_find_word(m.model, (*C.char)(cbuf))
+	return int(i)
+}
+
+// VoskSpkModel contains a reference to the C VoskSpkModel
+type VoskSpkModel struct {
+	spkModel *C.struct_VoskSpkModel
 }
 
 // NewSpkModel creates a new VoskSpkModel instance
 func NewSpkModel(spkModelPath string) (*VoskSpkModel, error) {
-    var internal *C.struct_VoskSpkModel
-    internal = C.vosk_spk_model_new(C.CString(spkModelPath))
-    spkModel := &VoskSpkModel{spkModel: internal}
-    return spkModel, nil
+	internal := C.vosk_spk_model_new(C.CString(spkModelPath))
+	spkModel := &VoskSpkModel{spkModel: internal}
+	return spkModel, nil
+}
+
+func freeSpkModel(model *VoskSpkModel) {
+	C.vosk_spk_model_free(model.spkModel)
+}
+
+func(s *VoskSpkModel) Free() {
+	C.vosk_spk_model_free(s.spkModel)
+}
+
+// VoskRecognizer contains a reference to the C VoskRecognizer
+type VoskRecognizer struct {
+	rec *C.struct_VoskRecognizer
+}
+
+func freeRecognizer(recognizer *VoskRecognizer) {
+	C.vosk_recognizer_free(recognizer.rec)
+}
+
+func (r *VoskRecognizer) Free() {
+	C.vosk_recognizer_free(r.rec)
+}
+
+// NewRecognizer creates a new VoskRecognizer instance
+func NewRecognizer(model *VoskModel, sampleRate float64) (*VoskRecognizer, error) {
+	internal := C.vosk_recognizer_new(model.model, C.float(sampleRate))
+	rec := &VoskRecognizer{rec: internal}
+	return rec, nil
+}
+
+// NewRecognizerSpk creates a new VoskRecognizer instance with a speaker model.
+func NewRecognizerSpk(model *VoskModel, sampleRate float64, spkModel *VoskSpkModel) (*VoskRecognizer, error) {
+	internal := C.vosk_recognizer_new_spk(model.model, C.float(sampleRate), spkModel.spkModel)
+	rec := &VoskRecognizer{rec: internal}
+	return rec, nil
+}
+
+// NewRecognizerGrm creates a new VoskRecognizer instance with the phrase list.
+func NewRecognizerGrm(model *VoskModel, sampleRate float64, grammer []byte) (*VoskRecognizer, error) {
+	cbuf := C.CBytes(grammer)
+	defer C.free(cbuf)
+	internal := C.vosk_recognizer_new_grm(model.model, C.float(sampleRate), (*C.char)(cbuf))
+	rec := &VoskRecognizer{rec: internal}
+	return rec, nil
+}
+
+// SetSpkModel adds a speaker model to an already initialized recognizer.
+func (r *VoskRecognizer) SetSpkModel(spkModel *VoskSpkModel) {
+	C.vosk_recognizer_set_spk_model(r.rec, spkModel.spkModel)
+}
+
+// SetMaxAlternatives configures the recognizer to output n-best results.
+func (r *VoskRecognizer) SetMaxAlternatives(maxAlternatives int) {
+	C.vosk_recognizer_set_max_alternatives(r.rec, C.int(maxAlternatives))
+}
+
+// SetWords enables words with times in the ouput.
+func (r *VoskRecognizer) SetWords(words int) {
+	C.vosk_recognizer_set_words(r.rec, C.int(words))
+}
+
+// AcceptWaveform accepts and processes a new chunk of the voice data.
+func (r *VoskRecognizer) AcceptWaveform(buffer []byte) int {
+	cbuf := C.CBytes(buffer)
+	defer C.free(cbuf)
+	i := C.vosk_recognizer_accept_waveform(r.rec, (*C.char)(cbuf), C.int(len(buffer)))
+	return int(i)
+}
+
+// Result returns a speech recognition result.
+func (r *VoskRecognizer) Result() []byte {
+	return []byte(C.GoString(C.vosk_recognizer_result(r.rec)))
+}
+
+// PartialResult returns a partial speech recognition result.
+func (r *VoskRecognizer) PartialResult() []byte {
+	return []byte(C.GoString(C.vosk_recognizer_partial_result(r.rec)))
+}
+
+// FinalResult returns a speech recognition result. Same as result, but doesn't wait
+// for silence.
+func (r *VoskRecognizer) FinalResult() []byte {
+	return []byte(C.GoString(C.vosk_recognizer_final_result(r.rec)))
+}
+
+// Reset resets the recognizer.
+func (r *VoskRecognizer) Reset() {
+	C.vosk_recognizer_reset(r.rec)
+}
+
+// SetLogLevel sets the log level for Kaldi messages.
+func SetLogLevel(logLevel int) {
+	C.vosk_set_log_level(C.int(logLevel))
+}
+
+// GPUInit automatically selects a CUDA device and allows multithreading.
+func GPUInit() {
+	C.vosk_gpu_init()
+}
+
+// GPUThreadInit inits CUDA device in a multi-threaded environment.
+func GPUThreadInit() {
+	C.vosk_gpu_thread_init()
 }

java/demo/build.gradle

@@ -15,5 +15,5 @@ repositories {
 
 dependencies {
     implementation group: 'net.java.dev.jna', name: 'jna', version: '5.7.0'
-    implementation group: 'com.alphacephei', name: 'vosk', version: '0.3.30+'
+    implementation group: 'com.alphacephei', name: 'vosk', version: '0.3.32+'
 }

java/lib/build.gradle

@@ -5,7 +5,7 @@ plugins {
 
 archivesBaseName = 'vosk'
 group = 'com.alphacephei'
-version = '0.3.30'
+version = '0.3.32'
 
 repositories {
     mavenCentral()

java/lib/src/main/java/org/vosk/Model.java

@@ -1,13 +1,18 @@
 package org.vosk;
 
+import java.io.IOException;
 import com.sun.jna.PointerType;
 
 public class Model extends PointerType implements AutoCloseable {
     public Model() {
     }
 
-    public Model(String path) {
+    public Model(String path) throws IOException {
         super(LibVosk.vosk_model_new(path));
+
+        if (getPointer() == null) {
+            throw new IOException("Failed to create a model");
+        }
     }
 
     @Override

java/lib/src/main/java/org/vosk/Recognizer.java

@@ -1,10 +1,15 @@
 package org.vosk;
 
 import com.sun.jna.PointerType;
+import java.io.IOException;
 
 public class Recognizer extends PointerType implements AutoCloseable {
-    public Recognizer(Model model, float sampleRate) {
+    public Recognizer(Model model, float sampleRate) throws IOException {
         super(LibVosk.vosk_recognizer_new(model, sampleRate));
+
+        if (getPointer() == null) {
+            throw new IOException("Failed to create a recognizer");
+        }
     }
 
     public Recognizer(Model model, float sampleRate, SpeakerModel spkModel) {

java/lib/src/main/java/org/vosk/SpeakerModel.java

@@ -1,13 +1,18 @@
 package org.vosk;
 
 import com.sun.jna.PointerType;
+import java.io.IOException;
 
 public class SpeakerModel extends PointerType implements AutoCloseable {
     public SpeakerModel() {
     }
 
-    public SpeakerModel(String path) {
+    public SpeakerModel(String path) throws IOException {
         super(LibVosk.vosk_spk_model_new(path));
+
+        if (getPointer() == null) {
+            throw new IOException("Failed to create a speaker model");
+        }
     }
 
     @Override

java/lib/src/test/java/org/vosk/test/DecoderTest.java

@@ -93,4 +93,10 @@ public class DecoderTest {
         }
         Assert.assertTrue(true);
     }
+
+
+    @Test(expected = IOException.class)
+    public void decoderTestException() throws IOException {
+        Model model = new Model("model_missing");
+    }
 }

nodejs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vosk",
-  "version": "0.3.30",
+  "version": "0.3.32",
   "description": "Node binding for continuous offline voice recoginition with Vosk library.",
   "repository": {
     "type": "git",

python/setup.py

@@ -44,7 +44,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="vosk",
-    version="0.3.30",
+    version="0.3.32",
     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

@@ -25,6 +25,9 @@ class Model(object):
     def __init__(self, model_path):
         self._handle = _c.vosk_model_new(model_path.encode('utf-8'))
 
+        if self._handle == _ffi.NULL:
+            raise Exception("Failed to create a model")
+
     def __del__(self):
         _c.vosk_model_free(self._handle)
 
@@ -36,6 +39,9 @@ class SpkModel(object):
     def __init__(self, model_path):
         self._handle = _c.vosk_spk_model_new(model_path.encode('utf-8'))
 
+        if self._handle == _ffi.NULL:
+            raise Exception("Failed to create a speaker model")
+
     def __del__(self):
         _c.vosk_spk_model_free(self._handle)
 
@@ -51,6 +57,9 @@ class KaldiRecognizer(object):
         else:
             raise TypeError("Unknown arguments")
 
+        if self._handle == _ffi.NULL:
+            raise Exception("Failed to create a recognizer")
+
     def __del__(self):
         _c.vosk_recognizer_free(self._handle)
 
@@ -64,7 +73,10 @@ class KaldiRecognizer(object):
         _c.vosk_recognizer_set_spk_model(self._handle, spk_model._handle)
 
     def AcceptWaveform(self, data):
-        return _c.vosk_recognizer_accept_waveform(self._handle, data, len(data))
+        res = _c.vosk_recognizer_accept_waveform(self._handle, data, len(data))
+        if res < 0:
+            raise Exception("Failed to process waveform")
+        return res
 
     def Result(self):
         return _ffi.string(_c.vosk_recognizer_result(self._handle)).decode('utf-8')

src/Makefile

@@ -1,13 +1,19 @@
+# Locations of the dependencies
 KALDI_ROOT?=$(HOME)/travis/kaldi
 OPENFST_ROOT?=$(KALDI_ROOT)/tools/openfst
 OPENBLAS_ROOT?=$(KALDI_ROOT)/tools/OpenBLAS/install
-HAVE_CUDA?=0
+MKL_ROOT?=/opt/intel/mkl
 CUDA_ROOT?=/usr/local/cuda
-EXT?=so
-CXX?=g++
-HAVE_OPENBLAS_CLAPACK=1
+# Math libraries
+HAVE_OPENBLAS_CLAPACK?=1
+HAVE_MKL?=0
 HAVE_ACCELERATE=0
-EXTRA_CFLGAS?=
+HAVE_CUDA?=0
+# Compiler
+CXX?=g++
+EXT?=so
+# Extra
+EXTRA_CFLAGS?=
 EXTRA_LDFLAGS?=
 
 VOSK_SOURCES= \
@@ -17,8 +23,15 @@ VOSK_SOURCES= \
 	spk_model.cc \
 	vosk_api.cc
 
-CFLAGS=-g -O2 -std=c++17 -fPIC -DFST_NO_DYNAMIC_LINKING $(EXTRA_CFLAGS) \
-	-I. -I$(KALDI_ROOT)/src -I$(OPENFST_ROOT)/include -I$(OPENBLAS_ROOT)/include
+VOSK_HEADERS= \
+	kaldi_recognizer.h \
+	language_model.h \
+	model.h \
+	spk_model.h \
+	vosk_api.h
+
+CFLAGS=-g -O3 -std=c++17 -fPIC -DFST_NO_DYNAMIC_LINKING \
+	-I. -I$(KALDI_ROOT)/src -I$(OPENFST_ROOT)/include $(EXTRA_CFLAGS) 
 
 LIBS= \
 	$(KALDI_ROOT)/src/online2/kaldi-online2.a \
@@ -43,21 +56,26 @@ LIBS= \
 
 
 ifeq ($(HAVE_OPENBLAS_CLAPACK), 1)
-LIBS += \
-	$(OPENBLAS_ROOT)/lib/libopenblas.a \
-	$(OPENBLAS_ROOT)/lib/liblapack.a \
-	$(OPENBLAS_ROOT)/lib/libblas.a \
-	$(OPENBLAS_ROOT)/lib/libf2c.a
+    CFLAGS += -I$(OPENBLAS_ROOT)/include
+    LIBS += \
+        $(OPENBLAS_ROOT)/lib/libopenblas.a \
+        $(OPENBLAS_ROOT)/lib/liblapack.a \
+        $(OPENBLAS_ROOT)/lib/libblas.a \
+        $(OPENBLAS_ROOT)/lib/libf2c.a
+endif
+
+ifeq ($(HAVE_MKL), 1)
+    CFLAGS += -I$(MKL_ROOT)/include
+    LIBS += -L$(MKL_ROOT)/lib/intel64 -Wl,-rpath=$(MKL_ROOT)/lib/intel64 -lmkl_rt -lmkl_intel_lp64 -lmkl_core -lmkl_sequential
 endif
 
 ifeq ($(HAVE_ACCELERATE), 1)
-LIBS += \
-	-framework Accelerate
+    LIBS += -framework Accelerate
 endif
 
 ifeq ($(HAVE_CUDA), 1)
-CFLAGS+=-DHAVE_CUDA=1 -I$(CUDA_ROOT)/include
-LIBS+=-L$(CUDA_ROOT)/lib64 -lcublas -lcusparse -lcudart -lcurand -lcufft -lcusolver -lnvToolsExt
+    CFLAGS+=-DHAVE_CUDA=1 -I$(CUDA_ROOT)/include
+    LIBS+=-L$(CUDA_ROOT)/lib64 -lcublas -lcusparse -lcudart -lcurand -lcufft -lcusolver -lnvToolsExt
 endif
 
 all: libvosk.$(EXT)
@@ -65,7 +83,7 @@ all: libvosk.$(EXT)
 libvosk.$(EXT): $(VOSK_SOURCES:.cc=.o)
 	$(CXX) --shared -s -o $@ $^ $(LIBS) -lm -latomic $(EXTRA_LDFLAGS)
 
-%.o: %.cc
+%.o: %.cc $(VOSK_HEADERS)
 	$(CXX) $(CFLAGS) -c -o $@ $<
 
 clean:

src/kaldi_recognizer.cc

@@ -142,13 +142,13 @@ KaldiRecognizer::~KaldiRecognizer() {
     delete g_fst_;
     delete decode_fst_;
     delete spk_feature_;
-    delete lm_fst_;
 
-    delete info;
-    delete lm_to_subtract_det_backoff;
-    delete lm_to_subtract_det_scale;
-    delete lm_to_add_orig;
-    delete lm_to_add;
+    delete lm_to_subtract_;
+    delete carpa_to_add_;
+    delete carpa_to_add_scale_;
+    delete rnnlm_info_;
+    delete rnnlm_to_add_;
+    delete rnnlm_to_add_scale_;
 
     model_->Unref();
     if (spk_model_)
@@ -166,21 +166,22 @@ void KaldiRecognizer::InitState()
 
 void KaldiRecognizer::InitRescoring()
 {
-    if (model_->rnnlm_lm_fst_) {
-        float lm_scale = 0.5;
-        int lm_order = 4;
+    if (model_->graph_lm_fst_) {
 
-        info = new kaldi::rnnlm::RnnlmComputeStateInfo(model_->rnnlm_compute_opts, model_->rnnlm, model_->word_embedding_mat);
-        lm_to_subtract_det_backoff = new fst::BackoffDeterministicOnDemandFst<fst::StdArc>(*model_->rnnlm_lm_fst_);
-        lm_to_subtract_det_scale = new fst::ScaleDeterministicOnDemandFst(-lm_scale, lm_to_subtract_det_backoff);
-        lm_to_add_orig = new kaldi::rnnlm::KaldiRnnlmDeterministicFst(lm_order, *info);
-        lm_to_add = new fst::ScaleDeterministicOnDemandFst(lm_scale, lm_to_add_orig);
-
-    } else if (model_->std_lm_fst_) {
-        fst::CacheOptions cache_opts(true, 50000);
+        fst::CacheOptions cache_opts(true, -1);
         fst::ArcMapFstOptions mapfst_opts(cache_opts);
-        fst::StdToLatticeMapper<kaldi::BaseFloat> mapper;
-        lm_fst_ = new fst::ArcMapFst<fst::StdArc, kaldi::LatticeArc, fst::StdToLatticeMapper<kaldi::BaseFloat> >(*model_->std_lm_fst_, mapper, mapfst_opts);
+        fst::StdToLatticeMapper<BaseFloat> mapper;
+
+        lm_to_subtract_ = new fst::ArcMapFst<fst::StdArc, LatticeArc, fst::StdToLatticeMapper<BaseFloat> >(*model_->graph_lm_fst_, mapper, mapfst_opts);
+        carpa_to_add_ = new ConstArpaLmDeterministicFst(model_->const_arpa_);
+
+        if (model_->rnnlm_enabled_) {
+           int lm_order = 4;
+           rnnlm_info_ = new kaldi::rnnlm::RnnlmComputeStateInfo(model_->rnnlm_compute_opts, model_->rnnlm, model_->word_embedding_mat);
+           rnnlm_to_add_ = new kaldi::rnnlm::KaldiRnnlmDeterministicFst(lm_order, *rnnlm_info_);
+           rnnlm_to_add_scale_ = new fst::ScaleDeterministicOnDemandFst(0.5, rnnlm_to_add_);
+           carpa_to_add_scale_ = new fst::ScaleDeterministicOnDemandFst(-0.5, carpa_to_add_);
+        }
     }
 }
 
@@ -537,11 +538,12 @@ const char *KaldiRecognizer::NbestResult(CompactLattice &clat)
     for (int k = 0; k < nbest_lats.size(); k++) {
 
       Lattice nlat = nbest_lats[k];
-      RmEpsilon(&nlat);
-      CompactLattice nclat;
-      CompactLattice aligned_nclat;
-      ConvertLattice(nlat, &nclat);
 
+      CompactLattice nclat;
+      fst::Invert(&nlat);
+      DeterminizeLattice(nlat, &nclat);
+
+      CompactLattice aligned_nclat;
       if (model_->winfo_) {
           WordAlignLattice(nclat, *model_->trans_model_, *model_->winfo_, 0, &aligned_nclat);
       } else {
@@ -588,42 +590,40 @@ const char* KaldiRecognizer::GetResult()
         return StoreEmptyReturn();
     }
 
-    kaldi::CompactLattice clat;
-    kaldi::CompactLattice rlat;
+    // Original from decoder, subtracted graph weight, rescored with carpa, rescored with rnnlm
+    CompactLattice clat, slat, tlat, rlat;
+
     decoder_->GetLattice(true, &clat);
 
-    if (model_->rnnlm_lm_fst_) {
-        kaldi::ComposeLatticePrunedOptions compose_opts;
-        compose_opts.lattice_compose_beam = 3.0;
-        compose_opts.max_arcs = 3000;
+    if (lm_to_subtract_ && carpa_to_add_) {
+        Lattice lat, composed_lat;
 
-        TopSortCompactLatticeIfNeeded(&clat);
-        fst::ComposeDeterministicOnDemandFst<fst::StdArc> combined_lms(lm_to_subtract_det_scale, lm_to_add);
-        CompactLattice composed_clat;
-        ComposeCompactLatticePruned(compose_opts, clat,
-                                    &combined_lms, &rlat);
-        lm_to_add_orig->Clear();
-    } else if (model_->std_lm_fst_) {
-        Lattice lat1;
-
-        ConvertLattice(clat, &lat1);
-        fst::ScaleLattice(fst::GraphLatticeScale(-1.0), &lat1);
-        fst::ArcSort(&lat1, fst::OLabelCompare<kaldi::LatticeArc>());
-        kaldi::Lattice composed_lat;
-        fst::Compose(lat1, *lm_fst_, &composed_lat);
+        // Delete old score
+        ConvertLattice(clat, &lat);
+        fst::ScaleLattice(fst::GraphLatticeScale(-1.0), &lat);
+        fst::Compose(lat, *lm_to_subtract_, &composed_lat);
         fst::Invert(&composed_lat);
-        kaldi::CompactLattice determinized_lat;
-        DeterminizeLattice(composed_lat, &determinized_lat);
-        fst::ScaleLattice(fst::GraphLatticeScale(-1), &determinized_lat);
-        fst::ArcSort(&determinized_lat, fst::OLabelCompare<kaldi::CompactLatticeArc>());
+        DeterminizeLattice(composed_lat, &slat);
+        fst::ScaleLattice(fst::GraphLatticeScale(-1.0), &slat);
 
-        kaldi::ConstArpaLmDeterministicFst const_arpa_fst(model_->const_arpa_);
-        kaldi::CompactLattice composed_clat;
-        kaldi::ComposeCompactLatticeDeterministic(determinized_lat, &const_arpa_fst, &composed_clat);
-        kaldi::Lattice composed_lat1;
-        ConvertLattice(composed_clat, &composed_lat1);
-        fst::Invert(&composed_lat1);
-        DeterminizeLattice(composed_lat1, &rlat);
+        // Add CARPA score
+        TopSortCompactLatticeIfNeeded(&slat);
+        ComposeCompactLatticeDeterministic(slat, carpa_to_add_, &tlat);
+
+        // Rescore with RNNLM score on top if needed
+        if (rnnlm_to_add_scale_) {
+             ComposeLatticePrunedOptions compose_opts;
+             compose_opts.lattice_compose_beam = 3.0;
+             compose_opts.max_arcs = 3000;
+             fst::ComposeDeterministicOnDemandFst<StdArc> combined_rnnlm(carpa_to_add_scale_, rnnlm_to_add_scale_);
+
+             TopSortCompactLatticeIfNeeded(&tlat);
+             ComposeCompactLatticePruned(compose_opts, tlat,
+                                         &combined_rnnlm, &rlat);
+             rnnlm_to_add_->Clear();
+        } else {
+             rlat = tlat;
+        }
     } else {
         rlat = clat;
     }
@@ -652,7 +652,7 @@ const char* KaldiRecognizer::PartialResult()
         return StoreReturn(res.dump());
     }
 
-    kaldi::Lattice lat;
+    Lattice lat;
     decoder_->GetBestPath(false, &lat);
     vector<kaldi::int32> alignment, words;
     LatticeWeight weight;

src/kaldi_recognizer.h

@@ -82,15 +82,16 @@ class KaldiRecognizer {
         OnlineBaseFeature *spk_feature_ = nullptr;
 
         // Rescoring
-        fst::ArcMapFst<fst::StdArc, kaldi::LatticeArc, fst::StdToLatticeMapper<kaldi::BaseFloat> > *lm_fst_ = nullptr;
-
+        fst::ArcMapFst<fst::StdArc, LatticeArc, fst::StdToLatticeMapper<BaseFloat> > *lm_to_subtract_ = nullptr;
+        kaldi::ConstArpaLmDeterministicFst *carpa_to_add_ = nullptr;
+        fst::ScaleDeterministicOnDemandFst *carpa_to_add_scale_ = nullptr;
         // RNNLM rescoring
-        kaldi::rnnlm::RnnlmComputeStateInfo *info = nullptr;
-        fst::ScaleDeterministicOnDemandFst *lm_to_subtract_det_scale = nullptr;
-        fst::BackoffDeterministicOnDemandFst<fst::StdArc> *lm_to_subtract_det_backoff = nullptr;
-        kaldi::rnnlm::KaldiRnnlmDeterministicFst* lm_to_add_orig = nullptr;
-        fst::DeterministicOnDemandFst<fst::StdArc> *lm_to_add = nullptr;
+        kaldi::rnnlm::KaldiRnnlmDeterministicFst* rnnlm_to_add_ = nullptr;
+        fst::DeterministicOnDemandFst<fst::StdArc> *rnnlm_to_add_scale_ = nullptr;
+        kaldi::rnnlm::RnnlmComputeStateInfo *rnnlm_info_ = nullptr;
 
+
+        // Other
         int max_alternatives_ = 0; // Disable alternatives by default
         bool words_ = false;
 

src/model.cc

@@ -109,10 +109,10 @@ Model::Model(const char *model_path) : model_path_str_(model_path) {
 
     struct stat buffer;
     string am_v2_path = model_path_str_ + "/am/final.mdl";
-    string mfcc_v2_path = model_path_str_ + "/conf/mfcc.conf";
+    string model_conf_v2_path = model_path_str_ + "/conf/model.conf";
     string am_v1_path = model_path_str_ + "/final.mdl";
     string mfcc_v1_path = model_path_str_ + "/mfcc.conf";
-    if (stat(am_v2_path.c_str(), &buffer) == 0 && stat(mfcc_v2_path.c_str(), &buffer) == 0) {
+    if (stat(am_v2_path.c_str(), &buffer) == 0 && stat(model_conf_v2_path.c_str(), &buffer) == 0) {
         ConfigureV2();
         ReadDataFiles();
     } else if (stat(am_v1_path.c_str(), &buffer) == 0 && stat(mfcc_v1_path.c_str(), &buffer) == 0) {
@@ -168,13 +168,13 @@ void Model::ConfigureV1()
     std_fst_rxfilename_ = model_path_str_ + "/rescore/G.fst";
     final_ie_rxfilename_ = model_path_str_ + "/ivector/final.ie";
     mfcc_conf_rxfilename_ = model_path_str_ + "/mfcc.conf";
+    fbank_conf_rxfilename_ = model_path_str_ + "/fbank.conf";
     global_cmvn_stats_rxfilename_ = model_path_str_ + "/global_cmvn.stats";
     pitch_conf_rxfilename_ = model_path_str_ + "/pitch.conf";
     rnnlm_word_feats_rxfilename_ = model_path_str_ + "/rnnlm/word_feats.txt";
     rnnlm_feat_embedding_rxfilename_ = model_path_str_ + "/rnnlm/feat_embedding.final.mat";
     rnnlm_config_rxfilename_ = model_path_str_ + "/rnnlm/special_symbol_opts.conf";
     rnnlm_lm_rxfilename_ = model_path_str_ + "/rnnlm/final.raw";
-    rnnlm_lm_fst_rxfilename_ = model_path_str_ + "/rescore/G.fst";
 }
 
 void Model::ConfigureV2()
@@ -197,13 +197,13 @@ void Model::ConfigureV2()
     std_fst_rxfilename_ = model_path_str_ + "/rescore/G.fst";
     final_ie_rxfilename_ = model_path_str_ + "/ivector/final.ie";
     mfcc_conf_rxfilename_ = model_path_str_ + "/conf/mfcc.conf";
+    fbank_conf_rxfilename_ = model_path_str_ + "/conf/fbank.conf";
     global_cmvn_stats_rxfilename_ = model_path_str_ + "/am/global_cmvn.stats";
     pitch_conf_rxfilename_ = model_path_str_ + "/conf/pitch.conf";
     rnnlm_word_feats_rxfilename_ = model_path_str_ + "/rnnlm/word_feats.txt";
     rnnlm_feat_embedding_rxfilename_ = model_path_str_ + "/rnnlm/feat_embedding.final.mat";
     rnnlm_config_rxfilename_ = model_path_str_ + "/rnnlm/special_symbol_opts.conf";
     rnnlm_lm_rxfilename_ = model_path_str_ + "/rnnlm/final.raw";
-    rnnlm_lm_fst_rxfilename_ = model_path_str_ + "/rescore/G.fst";
 }
 
 void Model::ReadDataFiles()
@@ -215,9 +215,17 @@ void Model::ReadDataFiles()
          " lattice-beam=" << nnet3_decoding_config_.lattice_beam;
     KALDI_LOG << "Silence phones " << endpoint_config_.silence_phones;
 
-    feature_info_.feature_type = "mfcc";
-    ReadConfigFromFile(mfcc_conf_rxfilename_, &feature_info_.mfcc_opts);
-    feature_info_.mfcc_opts.frame_opts.allow_downsample = true; // It is safe to downsample
+    if (stat(mfcc_conf_rxfilename_.c_str(), &buffer) == 0) {
+        feature_info_.feature_type = "mfcc";
+        ReadConfigFromFile(mfcc_conf_rxfilename_, &feature_info_.mfcc_opts);
+        feature_info_.mfcc_opts.frame_opts.allow_downsample = true; // It is safe to downsample
+    } else if (stat(fbank_conf_rxfilename_.c_str(), &buffer) == 0) {
+        feature_info_.feature_type = "fbank";
+        ReadConfigFromFile(fbank_conf_rxfilename_, &feature_info_.fbank_opts);
+        feature_info_.fbank_opts.frame_opts.allow_downsample = true; // It is safe to downsample
+    } else {
+        KALDI_ERR << "Failed to find feature config file";
+    }
 
     feature_info_.silence_weighting_config.silence_weight = 1e-3;
     feature_info_.silence_weighting_config.silence_phones_str = endpoint_config_.silence_phones;
@@ -296,12 +304,19 @@ void Model::ReadDataFiles()
         winfo_ = new kaldi::WordBoundaryInfo(opts, winfo_rxfilename_);
     }
 
+    if (stat(carpa_rxfilename_.c_str(), &buffer) == 0) {
+
+        KALDI_LOG << "Loading subtract G.fst model from " << std_fst_rxfilename_;
+        graph_lm_fst_ = fst::ReadAndPrepareLmFst(std_fst_rxfilename_);
+        KALDI_LOG << "Loading CARPA model from " << carpa_rxfilename_;
+        ReadKaldiObject(carpa_rxfilename_, &const_arpa_);
+    }
+
     // RNNLM Rescoring
     if (stat(rnnlm_lm_rxfilename_.c_str(), &buffer) == 0) {
         KALDI_LOG << "Loading RNNLM model from " << rnnlm_lm_rxfilename_;
 
         ReadKaldiObject(rnnlm_lm_rxfilename_, &rnnlm);
-        rnnlm_lm_fst_ = fst::ReadAndPrepareLmFst(rnnlm_lm_fst_rxfilename_);
         Matrix<BaseFloat> feature_embedding_mat;
         ReadKaldiObject(rnnlm_feat_embedding_rxfilename_, &feature_embedding_mat);
         SparseMatrix<BaseFloat> word_feature_mat;
@@ -319,17 +334,9 @@ void Model::ReadDataFiles()
 
         ReadConfigFromFile(rnnlm_config_rxfilename_, &rnnlm_compute_opts);
 
-    } else if (stat(carpa_rxfilename_.c_str(), &buffer) == 0) {
-
-        KALDI_LOG << "Loading CARPA model from " << carpa_rxfilename_;
-        std_lm_fst_ = fst::ReadFstKaldi(std_fst_rxfilename_);
-        fst::Project(std_lm_fst_, fst::ProjectType::OUTPUT);
-        if (std_lm_fst_->Properties(fst::kILabelSorted, true) == 0) {
-            fst::ILabelCompare<fst::StdArc> ilabel_comp;
-            fst::ArcSort(std_lm_fst_, ilabel_comp);
-        }
-        ReadKaldiObject(carpa_rxfilename_, &const_arpa_);
+        rnnlm_enabled_ = true;
     }
+
 }
 
 void Model::Ref() 
@@ -363,5 +370,5 @@ Model::~Model() {
     delete hclg_fst_;
     delete hcl_fst_;
     delete g_fst_;
-    delete std_lm_fst_;
+    delete graph_lm_fst_;
 }

src/model.h

@@ -66,13 +66,13 @@ protected:
     string std_fst_rxfilename_;
     string final_ie_rxfilename_;
     string mfcc_conf_rxfilename_;
+    string fbank_conf_rxfilename_;
     string global_cmvn_stats_rxfilename_;
     string pitch_conf_rxfilename_;
 
     string rnnlm_word_feats_rxfilename_;
     string rnnlm_feat_embedding_rxfilename_;
     string rnnlm_config_rxfilename_;
-    string rnnlm_lm_fst_rxfilename_;
     string rnnlm_lm_rxfilename_;
 
     kaldi::OnlineEndpointConfig endpoint_config_;
@@ -92,13 +92,13 @@ protected:
     fst::Fst<fst::StdArc> *hcl_fst_ = nullptr;
     fst::Fst<fst::StdArc> *g_fst_ = nullptr;
 
-    fst::VectorFst<fst::StdArc> *std_lm_fst_ = nullptr;
+    fst::VectorFst<fst::StdArc> *graph_lm_fst_ = nullptr;
     kaldi::ConstArpaLm const_arpa_;
 
     kaldi::rnnlm::RnnlmComputeStateComputationOptions rnnlm_compute_opts;
     CuMatrix<BaseFloat> word_embedding_mat;
-    fst::VectorFst<fst::StdArc> *rnnlm_lm_fst_ = NULL;
     kaldi::nnet3::Nnet rnnlm;
+    bool rnnlm_enabled_ = false;
 
     std::atomic<int> ref_cnt_;
 };

src/vosk_api.cc

@@ -27,11 +27,18 @@ using namespace kaldi;
 
 VoskModel *vosk_model_new(const char *model_path)
 {
-    return (VoskModel *)new Model(model_path);
+    try {
+        return (VoskModel *)new Model(model_path);
+    } catch (...) {
+        return nullptr;
+    }
 }
 
 void vosk_model_free(VoskModel *model)
 {
+    if (model == nullptr) {
+       return;
+    }
     ((Model *)model)->Unref();
 }
 
@@ -42,27 +49,46 @@ int vosk_model_find_word(VoskModel *model, const char *word)
 
 VoskSpkModel *vosk_spk_model_new(const char *model_path)
 {
-    return (VoskSpkModel *)new SpkModel(model_path);
+    try {
+        return (VoskSpkModel *)new SpkModel(model_path);
+    } catch (...) {
+        return nullptr;
+    }
 }
 
 void vosk_spk_model_free(VoskSpkModel *model)
 {
+    if (model == nullptr) {
+       return;
+    }
     ((SpkModel *)model)->Unref();
 }
 
 VoskRecognizer *vosk_recognizer_new(VoskModel *model, float sample_rate)
 {
-    return (VoskRecognizer *)new KaldiRecognizer((Model *)model, sample_rate);
+    try {
+        return (VoskRecognizer *)new KaldiRecognizer((Model *)model, sample_rate);
+    } catch (...) {
+        return nullptr;
+    }
 }
 
 VoskRecognizer *vosk_recognizer_new_spk(VoskModel *model, float sample_rate, VoskSpkModel *spk_model)
 {
-    return (VoskRecognizer *)new KaldiRecognizer((Model *)model, sample_rate, (SpkModel *)spk_model);
+    try {
+        return (VoskRecognizer *)new KaldiRecognizer((Model *)model, sample_rate, (SpkModel *)spk_model);
+    } catch (...) {
+        return nullptr;
+    }
 }
 
 VoskRecognizer *vosk_recognizer_new_grm(VoskModel *model, float sample_rate, const char *grammar)
 {
-    return (VoskRecognizer *)new KaldiRecognizer((Model *)model, sample_rate, grammar);
+    try {
+        return (VoskRecognizer *)new KaldiRecognizer((Model *)model, sample_rate, grammar);
+    } catch (...) {
+        return nullptr;
+    }
 }
 
 void vosk_recognizer_set_max_alternatives(VoskRecognizer *recognizer, int max_alternatives)
@@ -77,22 +103,37 @@ void vosk_recognizer_set_words(VoskRecognizer *recognizer, int words)
 
 void vosk_recognizer_set_spk_model(VoskRecognizer *recognizer, VoskSpkModel *spk_model)
 {
+    if (recognizer == nullptr || spk_model == nullptr) {
+       return;
+    }
     ((KaldiRecognizer *)recognizer)->SetSpkModel((SpkModel *)spk_model);
 }
 
 int vosk_recognizer_accept_waveform(VoskRecognizer *recognizer, const char *data, int length)
 {
-    return ((KaldiRecognizer *)(recognizer))->AcceptWaveform(data, length);
+    try {
+        return ((KaldiRecognizer *)(recognizer))->AcceptWaveform(data, length);
+    } catch (...) {
+        return -1;
+    }
 }
 
 int vosk_recognizer_accept_waveform_s(VoskRecognizer *recognizer, const short *data, int length)
 {
-    return ((KaldiRecognizer *)(recognizer))->AcceptWaveform(data, length);
+    try {
+        return ((KaldiRecognizer *)(recognizer))->AcceptWaveform(data, length);
+    } catch (...) {
+        return -1;
+    }
 }
 
 int vosk_recognizer_accept_waveform_f(VoskRecognizer *recognizer, const float *data, int length)
 {
-    return ((KaldiRecognizer *)(recognizer))->AcceptWaveform(data, length);
+    try {
+        return ((KaldiRecognizer *)(recognizer))->AcceptWaveform(data, length);
+    } catch (...) {
+        return -1;
+    }
 }
 
 const char *vosk_recognizer_result(VoskRecognizer *recognizer)

src/vosk_api.h

@@ -43,7 +43,7 @@ typedef struct VoskRecognizer VoskRecognizer;
 /** Loads model data from the file and returns the model object
  *
  * @param model_path: the path of the model on the filesystem
- @ @returns model object */
+ * @returns model object or NULL if problem occured */
 VoskModel *vosk_model_new(const char *model_path);
 
 
@@ -66,7 +66,7 @@ int vosk_model_find_word(VoskModel *model, const char *word);
 /** Loads speaker model data from the file and returns the model object
  *
  * @param model_path: the path of the model on the filesystem
- * @returns model object */
+ * @returns model object or NULL if problem occured */
 VoskSpkModel *vosk_spk_model_new(const char *model_path);
 
 
@@ -79,9 +79,13 @@ void vosk_spk_model_free(VoskSpkModel *model);
 
 /** Creates the recognizer object
  *
- *  The recognizers process the speech and return text using shared model data 
- *  @param sample_rate The sample rate of the audio you going to feed into the recognizer
- *  @returns recognizer object */
+ *  The recognizers process the speech and return text using shared model data
+ *  @param model       VoskModel containing static data for recognizer. Model can be
+ *                     shared across recognizers, even running in different threads.
+ *  @param sample_rate The sample rate of the audio you going to feed into the recognizer.
+ *                     Make sure this rate matches the audio content, it is a common
+ *                     issue causing accuracy problems.
+ *  @returns recognizer object or NULL if problem occured */
 VoskRecognizer *vosk_recognizer_new(VoskModel *model, float sample_rate);
 
 
@@ -90,9 +94,13 @@ VoskRecognizer *vosk_recognizer_new(VoskModel *model, float sample_rate);
  *  With the speaker recognition mode the recognizer not just recognize
  *  text but also return speaker vectors one can use for speaker identification
  *
- *  @param sample_rate The sample rate of the audio you going to feed into the recognizer
+ *  @param model       VoskModel containing static data for recognizer. Model can be
+ *                     shared across recognizers, even running in different threads.
+ *  @param sample_rate The sample rate of the audio you going to feed into the recognizer.
+ *                     Make sure this rate matches the audio content, it is a common
+ *                     issue causing accuracy problems.
  *  @param spk_model speaker model for speaker identification
- *  @returns recognizer object */
+ *  @returns recognizer object or NULL if problem occured */
 VoskRecognizer *vosk_recognizer_new_spk(VoskModel *model, float sample_rate, VoskSpkModel *spk_model);
 
 
@@ -106,11 +114,15 @@ VoskRecognizer *vosk_recognizer_new_spk(VoskModel *model, float sample_rate, Vos
  *  Only recognizers with lookahead models support this type of quick configuration.
  *  Precompiled HCLG graph models are not supported.
  *
- *  @param sample_rate The sample rate of the audio you going to feed into the recognizer
+ *  @param model       VoskModel containing static data for recognizer. Model can be
+ *                     shared across recognizers, even running in different threads.
+ *  @param sample_rate The sample rate of the audio you going to feed into the recognizer.
+ *                     Make sure this rate matches the audio content, it is a common
+ *                     issue causing accuracy problems.
  *  @param grammar The string with the list of phrases to recognize as JSON array of strings,
  *                 for example "["one two three four five", "[unk]"]".
  *
- *  @returns recognizer object */
+ *  @returns recognizer object or NULL if problem occured */
 VoskRecognizer *vosk_recognizer_new_grm(VoskModel *model, float sample_rate, const char *grammar);
 
 
@@ -181,7 +193,9 @@ void vosk_recognizer_set_words(VoskRecognizer *recognizer, int words);
  *
  *  @param data - audio data in PCM 16-bit mono format
  *  @param length - length of the audio data
- *  @returns true if silence is occured and you can retrieve a new utterance with result method */
+ *  @returns 1 if silence is occured and you can retrieve a new utterance with result method 
+ *           0 if decoding continues
+ *           -1 if exception occured */
 int vosk_recognizer_accept_waveform(VoskRecognizer *recognizer, const char *data, int length);
 
 

travis/Dockerfile.dockcross

@@ -24,7 +24,7 @@ RUN apt-get update && \
 ARG OPENBLAS_ARCH=ARMV7
 ARG ARM_HARDWARE_OPTS="-mfloat-abi=hard -mfpu=neon"
 RUN cd /opt \
-    && git clone -b lookahead-1.8.0 --single-branch https://github.com/alphacep/kaldi \
+    && git clone -b vosk --single-branch https://github.com/alphacep/kaldi \
     && cd kaldi/tools \
     && git clone -b v0.3.13 --single-branch https://github.com/xianyi/OpenBLAS \
     && git clone -b v3.2.1  --single-branch https://github.com/alphacep/clapack \

travis/Dockerfile.manylinux

@@ -12,7 +12,7 @@ RUN yum -y update && yum -y install \
     && yum clean all
 
 RUN cd /opt \
-    && git clone -b lookahead-1.8.0 --single-branch https://github.com/alphacep/kaldi \
+    && git clone -b vosk --single-branch https://github.com/alphacep/kaldi \
     && cd /opt/kaldi/tools \
     && git clone -b v0.3.13 --single-branch https://github.com/xianyi/OpenBLAS \
     && git clone -b v3.2.1  --single-branch https://github.com/alphacep/clapack \