We create universal binary on OSX

Using `=` for linker options is a GNU extension which doesn't work with
clang.

Using `,` should work for both gcc and clang.

.gitignore

@@ -1,22 +1,25 @@
-# Built application files
-*.apk
-*.ap_
-
-# Java class files
-*.class
-
 # Object files
 *.o
 
+# Temp files
+nohup.out
+
 # Gradle files
 .gradle/
-android/build/
 gradlew
 gradlew.bat
 gradle
-
-# Local configuration file (sdk path, etc)
 local.properties
+gradle.properties
+
+# Android
+android/build
+android/lib/build
+android/model-en/build
+android/model-en/src/main/assets/model-en-us
+android/repo
+*.apk
+*.ap_
 
 # Cmake
 .cxx
@@ -37,15 +40,16 @@ python/test/result.txt
 python/test/wav.scp
 
 # Java
-*.so
-java/org
-java/*.cc
-java/model-spk/
-java/model/
+*.class
+java/lib/model
+java/demo/model
+java/lib/build
+java/demo/build
 
 # CSharp
 *.dll
 *.so
+*.dylib
 *.nupkg
 csharp/demo/model
 csharp/demo/test.wav

README.md

@@ -1,9 +1,10 @@
-# About
+# Vosk Speech Recognition Toolkit
 
 Vosk is an offline open source speech recognition toolkit. It enables
-speech recognition models for 17 languages and dialects - English, Indian
+speech recognition for 20+ languages and dialects - English, Indian
 English, German, French, Spanish, Portuguese, Chinese, Russian, Turkish,
-Vietnamese, Italian, Dutch, Catalan, Arabic, Greek, Farsi, Filipino.
+Vietnamese, Italian, Dutch, Catalan, Arabic, Greek, Farsi, Filipino,
+Ukrainian, Kazakh, Swedish, Japanese, Esperanto, Hindi, Czech. More to come.
 
 Vosk models are small (50 Mb) but provide continuous large vocabulary
 transcription, zero-latency response with streaming API, reconfigurable

android/CMakeLists.txt

@@ -1,69 +0,0 @@
-# Vosk CMake File
-
-cmake_minimum_required(VERSION 3.4.1)
-
-if ("x${ANDROID_ABI}" STREQUAL "xarmeabi-v7a")
-set(OPENBLAS_ARCH "armv7")
-set(KALDI_SUFFIX "arm_32")
-elseif ("x${ANDROID_ABI}" STREQUAL "xarm64-v8a")
-set(OPENBLAS_ARCH "armv8")
-set(KALDI_SUFFIX "arm_64")
-elseif ("x${ANDROID_ABI}" STREQUAL "xx86")
-set(OPENBLAS_ARCH "atom")
-set(KALDI_SUFFIX "x86")
-else ("x${ANDROID_ABI}" STREQUAL "xarmeabi-v7a")
-set(OPENBLAS_ARCH "atom")
-set(KALDI_SUFFIX "x86_64")
-endif ("x${ANDROID_ABI}" STREQUAL "xarmeabi-v7a")
-
-set(KALDI_ROOT "${PROJECT_SOURCE_DIR}/build/kaldi_${KALDI_SUFFIX}/kaldi")
-set(LIB_ROOT "${PROJECT_SOURCE_DIR}/build/kaldi_${KALDI_SUFFIX}/local")
-
-set(API_SOURCES
-"${PROJECT_SOURCE_DIR}/../src/kaldi_recognizer.cc"
-"${PROJECT_SOURCE_DIR}/../src/kaldi_recognizer.h"
-"${PROJECT_SOURCE_DIR}/../src/language_model.cc"
-"${PROJECT_SOURCE_DIR}/../src/language_model.h"
-"${PROJECT_SOURCE_DIR}/../src/model.cc"
-"${PROJECT_SOURCE_DIR}/../src/model.h"
-"${PROJECT_SOURCE_DIR}/../src/spk_model.cc"
-"${PROJECT_SOURCE_DIR}/../src/spk_model.h"
-"${PROJECT_SOURCE_DIR}/../src/vosk_api.cc"
-"${PROJECT_SOURCE_DIR}/../src/vosk_api.h"
-)
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -O3 -DFST_NO_DYNAMIC_LINKING")
-
-add_library( vosk_jni SHARED
-             build/generated-src/cpp/vosk_wrap.cc
-             ${API_SOURCES}
-)
-
-include_directories("${PROJECT_SOURCE_DIR}/../src" "build/kaldi_${KALDI_SUFFIX}/kaldi/src" "build/kaldi_${KALDI_SUFFIX}/local/include")
-
-target_link_libraries( vosk_jni
-             ${KALDI_ROOT}/src/online2/kaldi-online2.a
-             ${KALDI_ROOT}/src/decoder/kaldi-decoder.a
-             ${KALDI_ROOT}/src/ivector/kaldi-ivector.a
-             ${KALDI_ROOT}/src/gmm/kaldi-gmm.a
-             ${KALDI_ROOT}/src/nnet3/kaldi-nnet3.a
-             ${KALDI_ROOT}/src/tree/kaldi-tree.a
-             ${KALDI_ROOT}/src/feat/kaldi-feat.a
-             ${KALDI_ROOT}/src/lat/kaldi-lat.a
-             ${KALDI_ROOT}/src/lm/kaldi-lm.a
-             ${KALDI_ROOT}/src/hmm/kaldi-hmm.a
-             ${KALDI_ROOT}/src/transform/kaldi-transform.a
-             ${KALDI_ROOT}/src/cudamatrix/kaldi-cudamatrix.a
-             ${KALDI_ROOT}/src/matrix/kaldi-matrix.a
-             ${KALDI_ROOT}/src/fstext/kaldi-fstext.a
-             ${KALDI_ROOT}/src/util/kaldi-util.a
-             ${KALDI_ROOT}/src/base/kaldi-base.a
-             ${LIB_ROOT}/lib/libfst.a
-             ${LIB_ROOT}/lib/libfstngram.a
-             ${LIB_ROOT}/lib/libopenblas.a
-             ${LIB_ROOT}/lib/libclapack.a
-             ${LIB_ROOT}/lib/liblapack.a
-             ${LIB_ROOT}/lib/libblas.a
-             ${LIB_ROOT}/lib/libf2c.a
-             log
-             )

android/build.gradle

@@ -1,110 +1,65 @@
 buildscript {
     repositories {
         google()
-        jcenter()
+        mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.5.3'
-        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.5'
+        classpath 'com.android.tools.build:gradle:4.2.0'
+        classpath 'com.vanniktech:gradle-maven-publish-plugin:0.18.0'
     }
 }
 
-plugins {
-    id "com.jfrog.bintray" version "1.8.5"
-}
-
-def archiveName = "vosk-android"
-def libVersion = "0.3.17"
-
 allprojects {
-  repositories {
-      google()
-      jcenter()
-  }
+    version = '0.3.38'
 }
 
-apply plugin: 'com.android.library'
-apply plugin: 'maven-publish'
+subprojects {
 
-android {
-    compileSdkVersion 29
-    defaultConfig {
-        minSdkVersion 21
-        targetSdkVersion 29
-        versionCode 6
-        versionName = libVersion
-        archivesBaseName = archiveName
-        externalNativeBuild {
-            cmake {
-                arguments "-DCMAKE_VERBOSE_MAKEFILE=ON", "-DANDROID_ARM_NEON=TRUE", "-DCMAKE_CXX_FLAGS_RELEASE=-O3"
+    apply plugin: 'com.android.library'
+    apply plugin: 'maven-publish'
+    apply plugin: 'com.vanniktech.maven.publish'
+
+    plugins.withId('com.vanniktech.maven.publish') {
+        mavenPublish {
+            group = 'com.alphacephei'
+            version = version
+            sonatypeHost = 's01'
+            androidVariantToPublish = 'release'
+        }
+    }
+
+    repositories {
+        google()
+        mavenCentral()
+    }
+
+    publishing {
+        publications {
+            aar(MavenPublication) {
+                groupId 'com.alphacephei'
+                version version
+                pom {
+                    url = 'http://www.alphacephei.com.com/vosk/'
+                    licenses {
+                        license {
+                            name = 'The Apache License, Version 2.0'
+                            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                        }
+                    }
+                    developers {
+                        developer {
+                            id = 'com.alphacephei'
+                            name = 'Alpha Cephei Inc'
+                            email = 'contact@alphacephei.com'
+                        }
+                    }
+                    scm {
+                        connection = 'scm:git:git://github.com/alphacep/vosk-api.git'
+                        url = 'https://github.com/alphacep/vosk-api/'
+                    }
+                }
             }
         }
-        ndk {
-            abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86_64', 'x86'
-        }
-    }
-    sourceSets {
-         main {
-              java.srcDirs = ['src/main/java', 'build/generated-src']
-         }
-    }
-    externalNativeBuild {
-       cmake {
-           path "CMakeLists.txt"
-       }
     }
+
 }
-
-Properties properties = new Properties()
-properties.load(project.rootProject.file('local.properties').newDataInputStream())
-
-bintray {
-    user = properties.getProperty("bintray.user")
-    key = properties.getProperty("bintray.apikey")
-    pkg {
-        repo = 'vosk'
-        name = 'vosk-android'
-        userOrg = "alphacep"
-        licenses = ['Apache2.0']
-        websiteUrl = 'https://github.com/alphacep/vosk-api'
-        issueTrackerUrl = 'https://github.com/alphacep/vosk-api/issues'
-        vcsUrl = 'https://github.com/alphacep/vosk-api'
-        version {
-            name = libVersion
-            vcsTag = libVersion
-        }
-    }
-    publications = ['aar']
-}
-
-publishing {
-    publications {
-        aar(MavenPublication) {
-            groupId 'com.alphacep'
-            artifactId archiveName
-            version libVersion
-            artifact("$buildDir/outputs/aar/$archiveName-release.aar")
-        }
-    }
-}
-
-task swig {
-    doLast {
-        mkdir 'build/generated-src/java'
-        mkdir 'build/generated-src/cpp'
-        exec {
-            commandLine 'swig',
-            "-c++",
-            "-java", "-package", "org.kaldi",
-            "-outdir", "build/generated-src/java", "-o", "build/generated-src/cpp/vosk_wrap.cc",
-            "../src/vosk.i"
-        }
-    }
-}
-
-task kaldi(type: Exec) {
-    commandLine './build-kaldi.sh'
-    environment ANDROID_SDK_HOME: android.getSdkDirectory()
-}
-
-preBuild.dependsOn kaldi, swig

android/lib/build-vosk.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-# Copyright 2019 Alpha Cephei Inc.
+# Copyright 2019-2021 Alpha Cephei Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,102 +14,88 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-if [ "x$ANDROID_SDK_HOME" == "x" ]; then
-    echo "ANDROID_SDK_HOME environment variable is undefined, define it with local.properties or with export"
+if [ "x$ANDROID_NDK_HOME" == "x" ]; then
+    echo "ANDROID_NDK_HOME environment variable is undefined, define it with local.properties or with export"
     exit 1
 fi
 
-if [ ! -d "$ANDROID_SDK_HOME" ]; then
-    echo "ANDROID_SDK_HOME ($ANDROID_SDK_HOME) is missing. Make sure you have sdk installed"
-    exit 1
-fi
-
-if [ ! -d "$ANDROID_SDK_HOME/ndk-bundle" ]; then
-    echo "$ANDROID_SDK_HOME/ndk-bundle is missing. Make sure you have ndk installed within sdk"
+if [ ! -d "$ANDROID_NDK_HOME" ]; then
+    echo "ANDROID_NDK_HOME ($ANDROID_NDK_HOME) is missing. Make sure you have ndk installed"
     exit 1
 fi
 
 set -x
 
 OS_NAME=`echo $(uname -s) | tr '[:upper:]' '[:lower:]'`
-ANDROID_NDK_HOME=$ANDROID_SDK_HOME/ndk-bundle
 ANDROID_TOOLCHAIN_PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/${OS_NAME}-x86_64
-WORKDIR_X86=`pwd`/build/kaldi_x86
-WORKDIR_X86_64=`pwd`/build/kaldi_x86_64
-WORKDIR_ARM32=`pwd`/build/kaldi_arm_32
-WORKDIR_ARM64=`pwd`/build/kaldi_arm_64
-PATH=$PATH:$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/${OS_NAME}-x86_64/bin
+WORKDIR_BASE=`pwd`/build
+PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/${OS_NAME}-x86_64/bin:$PATH
 OPENFST_VERSION=1.8.0
 
-mkdir -p $WORKDIR_ARM64/local/lib $WORKDIR_ARM32/local/lib $WORKDIR_X86_64/local/lib $WORKDIR_X86/local/lib
+for arch in armeabi-v7a arm64-v8a x86_64 x86; do
 
-# Build standalone CLAPACK since gfortran is missing
-cd build
-git clone https://github.com/simonlynen/android_libs
-cd android_libs/lapack
-sed -i.bak -e 's/APP_STL := gnustl_static/APP_STL := c++_static/g' jni/Application.mk && \
-sed -i.bak -e 's/android-10/android-21/g' project.properties && \
-sed -i.bak -e 's/APP_ABI := armeabi armeabi-v7a/APP_ABI := armeabi-v7a arm64-v8a x86_64 x86/g' jni/Application.mk && \
-sed -i.bak -e 's/LOCAL_MODULE:= testlapack/#LOCAL_MODULE:= testlapack/g' jni/Android.mk && \
-sed -i.bak -e 's/LOCAL_SRC_FILES:= testclapack.cpp/#LOCAL_SRC_FILES:= testclapack.cpp/g' jni/Android.mk && \
-sed -i.bak -e 's/LOCAL_STATIC_LIBRARIES := lapack/#LOCAL_STATIC_LIBRARIES := lapack/g' jni/Android.mk && \
-sed -i.bak -e 's/include $(BUILD_SHARED_LIBRARY)/#include $(BUILD_SHARED_LIBRARY)/g' jni/Android.mk && \
-${ANDROID_NDK_HOME}/ndk-build && \
-cp obj/local/armeabi-v7a/*.a ${WORKDIR_ARM32}/local/lib && \
-cp obj/local/arm64-v8a/*.a ${WORKDIR_ARM64}/local/lib
-cp obj/local/x86_64/*.a ${WORKDIR_X86_64}/local/lib
-cp obj/local/x86/*.a ${WORKDIR_X86}/local/lib
-
-# Architecture-specific part
-
-for arch in arm32 arm64 x86_64 x86; do
-#for arch in x86_64; do
+WORKDIR=${WORKDIR_BASE}/kaldi_${arch}
 
 case $arch in
-    arm32)
+    armeabi-v7a)
           BLAS_ARCH=ARMV7
-          WORKDIR=$WORKDIR_ARM32
           HOST=arm-linux-androideabi
-          AR=arm-linux-androideabi-ar
+          AR=llvm-ar
+          RANLIB=llvm-ranlib
           CC=armv7a-linux-androideabi21-clang
           CXX=armv7a-linux-androideabi21-clang++
           ARCHFLAGS="-mfloat-abi=softfp -mfpu=neon"
           ;;
-    arm64)
+    arm64-v8a)
           BLAS_ARCH=ARMV8
-          WORKDIR=$WORKDIR_ARM64
           HOST=aarch64-linux-android
-          AR=aarch64-linux-android-ar
+          AR=llvm-ar
+          RANLIB=llvm-ranlib
           CC=aarch64-linux-android21-clang
           CXX=aarch64-linux-android21-clang++
           ARCHFLAGS=""
           ;;
     x86_64)
           BLAS_ARCH=ATOM
-          WORKDIR=$WORKDIR_X86_64
           HOST=x86_64-linux-android
-          AR=x86_64-linux-android-ar
+          AR=llvm-ar
+          RANLIB=llvm-ranlib
           CC=x86_64-linux-android21-clang
           CXX=x86_64-linux-android21-clang++
           ARCHFLAGS=""
           ;;
     x86)
           BLAS_ARCH=ATOM
-          WORKDIR=$WORKDIR_X86
           HOST=i686-linux-android
-          AR=i686-linux-android-ar
+          AR=llvm-ar
+          RANLIB=llvm-ranlib
           CC=i686-linux-android21-clang
           CXX=i686-linux-android21-clang++
           ARCHFLAGS=""
           ;;
 esac
 
+mkdir -p $WORKDIR/local/lib
+
 # openblas first
 cd $WORKDIR
 git clone -b v0.3.13 --single-branch https://github.com/xianyi/OpenBLAS
 make -C OpenBLAS TARGET=$BLAS_ARCH ONLY_CBLAS=1 AR=$AR CC=$CC HOSTCC=gcc ARM_SOFTFP_ABI=1 USE_THREAD=0 NUM_THREADS=1 -j4
 make -C OpenBLAS install PREFIX=$WORKDIR/local
 
+# CLAPACK
+cd $WORKDIR
+git clone -b v3.2.1  --single-branch https://github.com/alphacep/clapack
+mkdir -p clapack/BUILD && cd clapack/BUILD
+cmake -DCMAKE_C_FLAGS=$ARCHFLAGS -DCMAKE_C_COMPILER_TARGET=$HOST \
+    -DCMAKE_C_COMPILER=$CC -DCMAKE_SYSTEM_NAME=Generic -DCMAKE_AR=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/${OS_NAME}-x86_64/bin/$AR \
+    -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY \
+    -DCMAKE_CROSSCOMPILING=True ..
+make -j 8 -C F2CLIBS/libf2c
+make -j 8 -C BLAS/SRC
+make -j 8 -C SRC
+find . -name "*.a" | xargs cp -t $WORKDIR/local/lib
+
 # tools directory --> we'll only compile OpenFST
 cd $WORKDIR
 git clone https://github.com/alphacep/openfst
@@ -123,19 +109,27 @@ 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
-if [ "`uname`" == "Darwin"  ]; then
-  sed -i.bak -e 's/libfst.dylib/libfst.a/' configure
-fi
-
-CXX=$CXX CXXFLAGS="$ARCHFLAGS -O3 -DFST_NO_DYNAMIC_LINKING" ./configure --use-cuda=no \
+CXX=$CXX AR=$AR RANLIB=$RANLIB CXXFLAGS="$ARCHFLAGS -O3 -DFST_NO_DYNAMIC_LINKING" ./configure --use-cuda=no \
     --mathlib=OPENBLAS_CLAPACK --shared \
     --android-incdir=${ANDROID_TOOLCHAIN_PATH}/sysroot/usr/include \
     --host=$HOST --openblas-root=${WORKDIR}/local \
     --fst-root=${WORKDIR}/local --fst-version=${OPENFST_VERSION}
-
 make -j 8 depend
-make -j 8 online2 lm
+cd $WORKDIR/kaldi/src
+make -j 8 online2 lm rnnlm
+
+# Vosk-api
+cd $WORKDIR
+mkdir -p $WORKDIR/vosk
+make -j 8 -C ${WORKDIR_BASE}/../../../src \
+    OUTDIR=$WORKDIR/vosk \
+    KALDI_ROOT=${WORKDIR}/kaldi \
+    OPENFST_ROOT=${WORKDIR}/local \
+    OPENBLAS_ROOT=${WORKDIR}/local \
+    CXX=$CXX \
+    EXTRA_LDFLAGS="-llog -static-libstdc++ -Wl,-soname,libvosk.so"
+cp $WORKDIR/vosk/libvosk.so $WORKDIR/../../src/main/jniLibs/$arch/libvosk.so
 
 done

android/lib/build.gradle

@@ -0,0 +1,55 @@
+def archiveName = "vosk-android"
+def pomName = "Vosk Android"
+def pomDescription = "Vosk speech recognition library for Android"
+
+android {
+    compileSdkVersion 29
+    defaultConfig {
+        minSdkVersion 21
+        targetSdkVersion 29
+        versionCode 6
+        versionName = version
+        archivesBaseName = archiveName
+        ndkVersion = "22.1.7171670"
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+task buildVosk(type: Exec) {
+    commandLine './build-vosk.sh'
+    environment ANDROID_NDK_HOME: android.getNdkDirectory()
+}
+
+dependencies {
+    api 'net.java.dev.jna:jna:4.4.0@aar'
+}
+
+//preBuild.dependsOn buildVosk
+
+publishing {
+    publications {
+        aar(MavenPublication) {
+            artifactId = archiveName
+            artifact("$buildDir/outputs/aar/$archiveName-release.aar")
+            pom {
+                name = pomName
+                description = pomDescription
+            }
+            //generate pom nodes for dependencies
+            pom.withXml {
+                def dependenciesNode = asNode().appendNode('dependencies')
+                configurations.implementation.allDependencies.each { dependency ->
+                    if (dependency.name != 'unspecified') {
+                        def dependencyNode = dependenciesNode.appendNode('dependency')
+                        dependencyNode.appendNode('groupId', dependency.group)
+                        dependencyNode.appendNode('artifactId', dependency.name)
+                        dependencyNode.appendNode('version', dependency.version)
+                    }
+                }
+            }
+        }
+    }
+}

android/lib/src/main/AndroidManifest.xml

@@ -1,3 +1,3 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="org.kaldi">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="org.vosk">
 </manifest>

android/lib/src/main/java/org/vosk/LibVosk.java

@@ -0,0 +1,62 @@
+package org.vosk;
+
+import com.sun.jna.Native;
+import com.sun.jna.Library;
+import com.sun.jna.Platform;
+import com.sun.jna.Pointer;
+import java.io.File;
+import java.io.InputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+
+public class LibVosk {
+
+    static {
+        Native.register(LibVosk.class, "vosk");
+    }
+
+    public static native void vosk_set_log_level(int level);
+
+    public static native Pointer vosk_model_new(String path);
+
+    public static native void vosk_model_free(Pointer model);
+
+    public static native Pointer vosk_spk_model_new(String path);
+
+    public static native void vosk_spk_model_free(Pointer model);
+
+    public static native Pointer vosk_recognizer_new(Model model, float sample_rate);
+
+    public static native Pointer vosk_recognizer_new_spk(Pointer model, float sample_rate, Pointer spk_model);
+
+    public static native Pointer vosk_recognizer_new_grm(Pointer model, float sample_rate, String grammar);
+
+    public static native void vosk_recognizer_set_max_alternatives(Pointer recognizer, int max_alternatives);
+
+    public static native void vosk_recognizer_set_words(Pointer recognizer, boolean words);
+
+    public static native void vosk_recognizer_set_partial_words(Pointer recognizer, boolean partial_words);
+
+    public static native void vosk_recognizer_set_spk_model(Pointer recognizer, Pointer spk_model);
+
+    public static native boolean vosk_recognizer_accept_waveform(Pointer recognizer, byte[] data, int len);
+
+    public static native boolean vosk_recognizer_accept_waveform_s(Pointer recognizer, short[] data, int len);
+
+    public static native boolean vosk_recognizer_accept_waveform_f(Pointer recognizer, float[] data, int len);
+
+    public static native String vosk_recognizer_result(Pointer recognizer);
+
+    public static native String vosk_recognizer_final_result(Pointer recognizer);
+
+    public static native String vosk_recognizer_partial_result(Pointer recognizer);
+
+    public static native void vosk_recognizer_reset(Pointer recognizer);
+
+    public static native void vosk_recognizer_free(Pointer recognizer);
+
+    public static void setLogLevel(LogLevel loglevel) {
+        vosk_set_log_level(loglevel.getValue());
+    }
+}

android/lib/src/main/java/org/vosk/LogLevel.java

@@ -0,0 +1,17 @@
+package org.vosk;
+
+public enum LogLevel {
+    WARNINGS(-1),  // Print warning and errors
+    INFO(0),       // Print info, along with warning and error messages, but no debug
+    DEBUG(1);      // Print debug info
+
+    private final int value;
+
+    LogLevel(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return this.value;
+    }
+}

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

@@ -0,0 +1,17 @@
+package org.vosk;
+
+import com.sun.jna.PointerType;
+
+public class Model extends PointerType implements AutoCloseable {
+    public Model() {
+    }
+
+    public Model(String path) {
+        super(LibVosk.vosk_model_new(path));
+    }
+
+    @Override
+    public void close() {
+        LibVosk.vosk_model_free(this.getPointer());
+    }
+}

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

@@ -0,0 +1,66 @@
+package org.vosk;
+
+import com.sun.jna.PointerType;
+
+public class Recognizer extends PointerType implements AutoCloseable {
+    public Recognizer(Model model, float sampleRate) {
+        super(LibVosk.vosk_recognizer_new(model, sampleRate));
+    }
+
+    public Recognizer(Model model, float sampleRate, SpeakerModel spkModel) {
+        super(LibVosk.vosk_recognizer_new_spk(model.getPointer(), sampleRate, spkModel.getPointer()));
+    }
+
+    public Recognizer(Model model, float sampleRate, String grammar) {
+        super(LibVosk.vosk_recognizer_new_grm(model.getPointer(), sampleRate, grammar));
+    }
+
+    public void setMaxAlternatives(int maxAlternatives) {
+        LibVosk.vosk_recognizer_set_max_alternatives(this.getPointer(), maxAlternatives);
+    }
+
+    public void setWords(boolean words) {
+        LibVosk.vosk_recognizer_set_words(this.getPointer(), words);
+    }
+
+    public void setPartialWords(boolean partial_words) {
+        LibVosk.vosk_recognizer_set_partial_words(this.getPointer(), partial_words);
+    }
+
+    public void setSpeakerModel(SpeakerModel spkModel) {
+        LibVosk.vosk_recognizer_set_spk_model(this.getPointer(), spkModel.getPointer());
+    }
+
+    public boolean acceptWaveForm(byte[] data, int len) {
+        return LibVosk.vosk_recognizer_accept_waveform(this.getPointer(), data, len);
+    }
+
+    public boolean acceptWaveForm(short[] data, int len) {
+        return LibVosk.vosk_recognizer_accept_waveform_s(this.getPointer(), data, len);
+    }
+
+    public boolean acceptWaveForm(float[] data, int len) {
+        return LibVosk.vosk_recognizer_accept_waveform_f(this.getPointer(), data, len);
+    }
+
+    public String getResult() {
+        return LibVosk.vosk_recognizer_result(this.getPointer());
+    }
+
+    public String getPartialResult() {
+        return LibVosk.vosk_recognizer_partial_result(this.getPointer());
+    }
+
+    public String getFinalResult() {
+        return LibVosk.vosk_recognizer_final_result(this.getPointer());
+    }
+
+    public void reset() {
+        LibVosk.vosk_recognizer_reset(this.getPointer());
+    }
+
+    @Override
+    public void close() {
+        LibVosk.vosk_recognizer_free(this.getPointer());
+    }
+}

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

@@ -0,0 +1,17 @@
+package org.vosk;
+
+import com.sun.jna.PointerType;
+
+public class SpeakerModel extends PointerType implements AutoCloseable {
+    public SpeakerModel() {
+    }
+
+    public SpeakerModel(String path) {
+        super(LibVosk.vosk_spk_model_new(path));
+    }
+
+    @Override
+    public void close() {
+        LibVosk.vosk_spk_model_free(this.getPointer());
+    }
+}

android/lib/src/main/java/org/vosk/android/RecognitionListener.java

@@ -12,28 +12,35 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package org.kaldi;
+package org.vosk.android;
 
-/** Interface to receive recognition results */
+/**
+ * Interface to receive recognition results
+ */
 public interface RecognitionListener {
 
     /**
      * Called when partial recognition result is available.
      */
-    public void onPartialResult(String hypothesis);
+    void onPartialResult(String hypothesis);
 
     /**
-     * Called after the recognition is ended.
+     * Called after silence occured.
      */
-    public void onResult(String hypothesis);
+    void onResult(String hypothesis);
+
+    /**
+     * Called after stream end.
+     */
+    void onFinalResult(String hypothesis);
 
     /**
      * Called when an error occurs.
      */
-    public void onError(Exception exception);
+    void onError(Exception exception);
 
     /**
      * Called after timeout expired
      */
-    public void onTimeout();
+    void onTimeout();
 }

android/lib/src/main/java/org/vosk/android/SpeechService.java

@@ -12,54 +12,45 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package org.kaldi;
-
-import static java.lang.String.format;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Collection;
-import java.util.HashSet;
+package org.vosk.android;
 
 import android.media.AudioFormat;
 import android.media.AudioRecord;
 import android.media.MediaRecorder.AudioSource;
 import android.os.Handler;
 import android.os.Looper;
-import android.util.Log;
+
+import org.vosk.Recognizer;
+
+import java.io.IOException;
 
 /**
- * Service that records audio in a thread, passes it to a recognizer and emits 
+ * Service that records audio in a thread, passes it to a recognizer and emits
  * recognition results. Recognition events are passed to a client using
  * {@link RecognitionListener}
- *
  */
 public class SpeechService {
 
-    protected static final String TAG = SpeechService.class.getSimpleName();
-
-    private final KaldiRecognizer recognizer;
+    private final Recognizer recognizer;
 
     private final int sampleRate;
-    private final static float BUFFER_SIZE_SECONDS = 0.4f;
-    private int bufferSize;
+    private final static float BUFFER_SIZE_SECONDS = 0.2f;
+    private final int bufferSize;
     private final AudioRecord recorder;
-    
-    private Thread recognizerThread;
+
+    private RecognizerThread recognizerThread;
 
     private final Handler mainHandler = new Handler(Looper.getMainLooper());
-    
-    private final Collection<RecognitionListener> listeners = new HashSet<RecognitionListener>();
-    
+
     /**
-     * Creates speech service. Service holds the AudioRecord object, so you 
-     * need to call {@link release} in order to properly finalize it.
-     * 
+     * Creates speech service. Service holds the AudioRecord object, so you
+     * need to call {@link #shutdown()} in order to properly finalize it.
+     *
      * @throws IOException thrown if audio recorder can not be created for some reason.
      */
-    public SpeechService(KaldiRecognizer recognizer, float sampleRate) throws IOException {
+    public SpeechService(Recognizer recognizer, float sampleRate) throws IOException {
         this.recognizer = recognizer;
-        this.sampleRate = (int)sampleRate;
+        this.sampleRate = (int) sampleRate;
 
         bufferSize = Math.round(this.sampleRate * BUFFER_SIZE_SECONDS);
         recorder = new AudioRecord(
@@ -74,34 +65,17 @@ public class SpeechService {
         }
     }
 
-    /**
-     * Adds listener.
-     */
-    public void addListener(RecognitionListener listener) {
-        synchronized (listeners) {
-            listeners.add(listener);
-        }
-    }
-
-    /**
-     * Removes listener.
-     */
-    public void removeListener(RecognitionListener listener) {
-        synchronized (listeners) {
-            listeners.remove(listener);
-        }
-    }
 
     /**
      * Starts recognition. Does nothing if recognition is active.
-     * 
+     *
      * @return true if recognition was actually started
      */
-    public boolean startListening() {
+    public boolean startListening(RecognitionListener listener) {
         if (null != recognizerThread)
             return false;
 
-        recognizerThread = new RecognizerThread();
+        recognizerThread = new RecognizerThread(listener);
         recognizerThread.start();
         return true;
     }
@@ -109,16 +83,16 @@ public class SpeechService {
     /**
      * Starts recognition. After specified timeout listening stops and the
      * endOfSpeech signals about that. Does nothing if recognition is active.
-     * 
-     * @timeout - timeout in milliseconds to listen.
-     * 
+     * <p>
+     * timeout - timeout in milliseconds to listen.
+     *
      * @return true if recognition was actually started
      */
-    public boolean startListening(int timeout) {
+    public boolean startListening(RecognitionListener listener, int timeout) {
         if (null != recognizerThread)
             return false;
 
-        recognizerThread = new RecognizerThread(timeout);
+        recognizerThread = new RecognizerThread(listener, timeout);
         recognizerThread.start();
         return true;
     }
@@ -140,31 +114,28 @@ public class SpeechService {
     }
 
     /**
-     * Stops recognition. All listeners should receive final result if there is
+     * Stops recognition. Listener should receive final result if there is
      * any. Does nothing if recognition is not active.
-     * 
+     *
      * @return true if recognition was actually stopped
      */
     public boolean stop() {
-        boolean result = stopRecognizerThread();
-        if (result) {
-            mainHandler.post(new ResultEvent(recognizer.Result(), true));
-        }
-        return result;
+        return stopRecognizerThread();
     }
 
     /**
-     * Cancels recognition. Listeners do not receive final result. Does nothing
-     * if recognition is not active.
-     * 
-     * @return true if recognition was actually canceled
+     * Cancel recognition. Do not post any new events, simply cancel processing.
+     * Does nothing if recognition is not active.
+     *
+     * @return true if recognition was actually stopped
      */
     public boolean cancel() {
-        boolean result = stopRecognizerThread();
-        recognizer.Result(); // Reset recognizer state
-        return result;
+        if (recognizerThread != null) {
+            recognizerThread.setPause(true);
+        }
+        return stopRecognizerThread();
     }
-    
+
     /**
      * Shutdown the recognizer and release the recorder
      */
@@ -172,13 +143,33 @@ public class SpeechService {
         recorder.release();
     }
 
+    public void setPause(boolean paused) {
+        if (recognizerThread != null) {
+            recognizerThread.setPause(paused);
+        }
+    }
+
+    /**
+     * Resets recognizer in a thread, starts recognition over again
+     */
+    public void reset() {
+        if (recognizerThread != null) {
+            recognizerThread.reset();
+        }
+    }
+
     private final class RecognizerThread extends Thread {
 
         private int remainingSamples;
-        private int timeoutSamples;
+        private final int timeoutSamples;
         private final static int NO_TIMEOUT = -1;
+        private volatile boolean paused = false;
+        private volatile boolean reset = false;
 
-        public RecognizerThread(int timeout) {
+        RecognitionListener listener;
+
+        public RecognizerThread(RecognitionListener listener, int timeout) {
+            this.listener = listener;
             if (timeout != NO_TIMEOUT)
                 this.timeoutSamples = timeout * sampleRate / 1000;
             else
@@ -186,8 +177,25 @@ public class SpeechService {
             this.remainingSamples = this.timeoutSamples;
         }
 
-        public RecognizerThread() {
-            this(NO_TIMEOUT);
+        public RecognizerThread(RecognitionListener listener) {
+            this(listener, NO_TIMEOUT);
+        }
+
+        /**
+         * When we are paused, don't process audio by the recognizer and don't emit
+         * any listener results
+         *
+         * @param paused the status of pause
+         */
+        public void setPause(boolean paused) {
+            this.paused = paused;
+        }
+
+        /**
+         * Set reset state to signal reset of the recognizer and start over
+         */
+        public void reset() {
+            this.reset = true;
         }
 
         @Override
@@ -198,8 +206,7 @@ public class SpeechService {
                 recorder.stop();
                 IOException ioe = new IOException(
                         "Failed to start recording. Microphone might be already in use.");
-                mainHandler.post(new OnErrorEvent(ioe));
-                return;
+                mainHandler.post(() -> listener.onError(ioe));
             }
 
             short[] buffer = new short[bufferSize];
@@ -208,15 +215,24 @@ public class SpeechService {
                     && ((timeoutSamples == NO_TIMEOUT) || (remainingSamples > 0))) {
                 int nread = recorder.read(buffer, 0, buffer.length);
 
-                if (nread < 0) {
+                if (paused) {
+                    continue;
+                }
+
+                if (reset) {
+                    recognizer.reset();
+                    reset = false;
+                }
+
+                if (nread < 0)
                     throw new RuntimeException("error reading audio buffer");
+
+                if (recognizer.acceptWaveForm(buffer, nread)) {
+                    final String result = recognizer.getResult();
+                    mainHandler.post(() -> listener.onResult(result));
                 } else {
-                    boolean isFinal = recognizer.AcceptWaveform(buffer, nread);
-                    if (isFinal) {
-                        mainHandler.post(new ResultEvent(recognizer.Result(), true));
-                    } else {
-                        mainHandler.post(new ResultEvent(recognizer.PartialResult(), false));
-                    }
+                    final String partialResult = recognizer.getPartialResult();
+                    mainHandler.post(() -> listener.onPartialResult(partialResult));
                 }
 
                 if (timeoutSamples != NO_TIMEOUT) {
@@ -226,61 +242,16 @@ public class SpeechService {
 
             recorder.stop();
 
-            // Remove all pending notifications.
-            mainHandler.removeCallbacksAndMessages(null);
-
-            // If we met timeout signal that speech ended
-            if (timeoutSamples != NO_TIMEOUT && remainingSamples <= 0) {
-                mainHandler.post(new TimeoutEvent());
+            if (!paused) {
+                // If we met timeout signal that speech ended
+                if (timeoutSamples != NO_TIMEOUT && remainingSamples <= 0) {
+                    mainHandler.post(() -> listener.onTimeout());
+                } else {
+                    final String finalResult = recognizer.getFinalResult();
+                    mainHandler.post(() -> listener.onFinalResult(finalResult));
+                }
             }
-        }
-    }
 
-    private abstract class RecognitionEvent implements Runnable {
-        public void run() {
-            RecognitionListener[] emptyArray = new RecognitionListener[0];
-            for (RecognitionListener listener : listeners.toArray(emptyArray))
-                execute(listener);
-        }
-
-        protected abstract void execute(RecognitionListener listener);
-    }
-
-    private class ResultEvent extends RecognitionEvent {
-        protected final String hypothesis;
-        private final boolean finalResult;
-
-        ResultEvent(String hypothesis, boolean finalResult) {
-            this.hypothesis = hypothesis;
-            this.finalResult = finalResult;
-        }
-
-        @Override
-        protected void execute(RecognitionListener listener) {
-            if (finalResult)
-                listener.onResult(hypothesis);
-            else
-                listener.onPartialResult(hypothesis);
-        }
-    }
-
-    private class OnErrorEvent extends RecognitionEvent {
-        private final Exception exception;
-
-        OnErrorEvent(Exception exception) {
-            this.exception = exception;
-        }
-
-        @Override
-        protected void execute(RecognitionListener listener) {
-            listener.onError(exception);
-        }
-    }
-
-    private class TimeoutEvent extends RecognitionEvent {
-        @Override
-        protected void execute(RecognitionListener listener) {
-            listener.onTimeout();
         }
     }
 }

android/lib/src/main/java/org/vosk/android/SpeechStreamService.java

@@ -0,0 +1,165 @@
+// Copyright 2019 Alpha Cephei Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package org.vosk.android;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import org.vosk.Recognizer;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Service that recognizes stream audio in a  thread, passes it to a recognizer and emits
+ * recognition results. Recognition events are passed to a client using
+ * {@link RecognitionListener}
+ */
+public class SpeechStreamService {
+
+    private final Recognizer recognizer;
+    private final InputStream inputStream;
+    private final int sampleRate;
+    private final static float BUFFER_SIZE_SECONDS = 0.2f;
+    private final int bufferSize;
+
+    private Thread recognizerThread;
+
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    /**
+     * Creates speech service.
+     **/
+    public SpeechStreamService(Recognizer recognizer, InputStream inputStream, float sampleRate) {
+        this.recognizer = recognizer;
+        this.sampleRate = (int) sampleRate;
+        this.inputStream = inputStream;
+        bufferSize = Math.round(this.sampleRate * BUFFER_SIZE_SECONDS * 2);
+    }
+
+    /**
+     * Starts recognition. Does nothing if recognition is active.
+     *
+     * @return true if recognition was actually started
+     */
+    public boolean start(RecognitionListener listener) {
+        if (null != recognizerThread)
+            return false;
+
+        recognizerThread = new RecognizerThread(listener);
+        recognizerThread.start();
+        return true;
+    }
+
+    /**
+     * Starts recognition. After specified timeout listening stops and the
+     * endOfSpeech signals about that. Does nothing if recognition is active.
+     * <p>
+     * timeout - timeout in milliseconds to listen.
+     *
+     * @return true if recognition was actually started
+     */
+    public boolean start(RecognitionListener listener, int timeout) {
+        if (null != recognizerThread)
+            return false;
+
+        recognizerThread = new RecognizerThread(listener, timeout);
+        recognizerThread.start();
+        return true;
+    }
+
+    /**
+     * Stops recognition. All listeners should receive final result if there is
+     * any. Does nothing if recognition is not active.
+     *
+     * @return true if recognition was actually stopped
+     */
+    public boolean stop() {
+        if (null == recognizerThread)
+            return false;
+
+        try {
+            recognizerThread.interrupt();
+            recognizerThread.join();
+        } catch (InterruptedException e) {
+            // Restore the interrupted status.
+            Thread.currentThread().interrupt();
+        }
+
+        recognizerThread = null;
+        return true;
+    }
+
+    private final class RecognizerThread extends Thread {
+
+        private int remainingSamples;
+        private final int timeoutSamples;
+        private final static int NO_TIMEOUT = -1;
+        RecognitionListener listener;
+
+        public RecognizerThread(RecognitionListener listener, int timeout) {
+            this.listener = listener;
+            if (timeout != NO_TIMEOUT)
+                this.timeoutSamples = timeout * sampleRate / 1000;
+            else
+                this.timeoutSamples = NO_TIMEOUT;
+            this.remainingSamples = this.timeoutSamples;
+        }
+
+        public RecognizerThread(RecognitionListener listener) {
+            this(listener, NO_TIMEOUT);
+        }
+
+        @Override
+        public void run() {
+
+            byte[] buffer = new byte[bufferSize];
+
+            while (!interrupted()
+                    && ((timeoutSamples == NO_TIMEOUT) || (remainingSamples > 0))) {
+                try {
+                    int nread = inputStream.read(buffer, 0, buffer.length);
+                    if (nread < 0) {
+                        break;
+                    } else {
+                        boolean isSilence = recognizer.acceptWaveForm(buffer, nread);
+                        if (isSilence) {
+                            final String result = recognizer.getResult();
+                            mainHandler.post(() -> listener.onResult(result));
+                        } else {
+                            final String partialResult = recognizer.getPartialResult();
+                            mainHandler.post(() -> listener.onPartialResult(partialResult));
+                        }
+                    }
+
+                    if (timeoutSamples != NO_TIMEOUT) {
+                        remainingSamples = remainingSamples - nread;
+                    }
+
+                } catch (IOException e) {
+                    mainHandler.post(() -> listener.onError(e));
+                }
+            }
+
+            // If we met timeout signal that speech ended
+            if (timeoutSamples != NO_TIMEOUT && remainingSamples <= 0) {
+                mainHandler.post(() -> listener.onTimeout());
+            } else {
+                final String finalResult = recognizer.getFinalResult();
+                mainHandler.post(() -> listener.onFinalResult(finalResult));
+            }
+        }
+    }
+}

android/lib/src/main/java/org/vosk/android/StorageService.java

@@ -0,0 +1,150 @@
+// Copyright 2019 Alpha Cephei Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package org.vosk.android;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.os.Environment;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import org.vosk.Model;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+/**
+ * Provides utility methods to sync model files to external storage to allow
+ * C++ code access them. Relies on file named "uuid" to track updates.
+ */
+public class StorageService {
+
+    protected static final String TAG = StorageService.class.getSimpleName();
+
+    public interface Callback<R> {
+        void onComplete(R result);
+    }
+
+    public static void unpack(Context context, String sourcePath, final String targetPath, final Callback<Model> completeCallback, final Callback<IOException> errorCallback) {
+        Executor executor = Executors.newSingleThreadExecutor(); // change according to your requirements
+        Handler handler = new Handler(Looper.getMainLooper());
+        executor.execute(() -> {
+            try {
+                final String outputPath = sync(context, sourcePath, targetPath);
+                Model model = new Model(outputPath);
+                handler.post(() -> completeCallback.onComplete(model));
+            } catch (final IOException e) {
+                handler.post(() -> errorCallback.onComplete(e));
+            }
+        });
+    }
+
+    public static String sync(Context context, String sourcePath, String targetPath) throws IOException {
+
+        AssetManager assetManager = context.getAssets();
+
+        File externalFilesDir = context.getExternalFilesDir(null);
+        if (externalFilesDir == null) {
+            throw new IOException("cannot get external files dir, "
+                    + "external storage state is " + Environment.getExternalStorageState());
+        }
+
+        File targetDir = new File(externalFilesDir, targetPath);
+        String resultPath = new File(targetDir, sourcePath).getAbsolutePath();
+        String sourceUUID = readLine(assetManager.open(sourcePath + "/uuid"));
+        try {
+            String targetUUID = readLine(new FileInputStream(new File(targetDir, sourcePath + "/uuid")));
+            if (targetUUID.equals(sourceUUID)) return resultPath;
+        } catch (FileNotFoundException e) {
+            // ignore
+        }
+        deleteContents(targetDir);
+
+        copyAssets(assetManager, sourcePath, targetDir);
+
+        // Copy uuid
+        copyFile(assetManager, sourcePath + "/uuid", targetDir);
+
+        return resultPath;
+    }
+
+    private static String readLine(InputStream is) throws IOException {
+        return new BufferedReader(new InputStreamReader(is)).readLine();
+    }
+
+    private static boolean deleteContents(File dir) {
+        File[] files = dir.listFiles();
+        boolean success = true;
+        if (files != null) {
+            for (File file : files) {
+                if (file.isDirectory()) {
+                    success &= deleteContents(file);
+                }
+                if (!file.delete()) {
+                    success = false;
+                }
+            }
+        }
+        return success;
+    }
+
+    private static void copyAssets(AssetManager assetManager, String path, File outPath) throws IOException {
+        String[] assets = assetManager.list(path);
+        if (assets == null) {
+            return;
+        }
+        if (assets.length == 0) {
+            if (!path.endsWith("uuid"))
+                copyFile(assetManager, path, outPath);
+        } else {
+            File dir = new File(outPath, path);
+            if (!dir.exists()) {
+                Log.v(TAG, "Making directory " + dir.getAbsolutePath());
+                if (!dir.mkdirs()) {
+                    Log.v(TAG, "Failed to create directory " + dir.getAbsolutePath());
+                }
+            }
+            for (String asset : assets) {
+                copyAssets(assetManager, path + "/" + asset, outPath);
+            }
+        }
+    }
+
+    private static void copyFile(AssetManager assetManager, String fileName, File outPath) throws IOException {
+        InputStream in;
+
+        Log.v(TAG, "Copy " + fileName + " to " + outPath);
+        in = assetManager.open(fileName);
+        OutputStream out = new FileOutputStream(outPath + "/" + fileName);
+
+        byte[] buffer = new byte[4000];
+        int read;
+        while ((read = in.read(buffer)) != -1) {
+            out.write(buffer, 0, read);
+        }
+        in.close();
+        out.close();
+    }
+}

android/model-en/build.gradle

@@ -1,30 +1,6 @@
-buildscript {
-    repositories {
-        google()
-        jcenter()
-    }
-    dependencies {
-        classpath 'com.android.tools.build:gradle:3.5.3'
-        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.5'
-    }
-}
-
-plugins {
-    id "com.jfrog.bintray"
-}
-
 def archiveName = "vosk-model-en"
-def libVersion = "0.3.17"
-
-allprojects {
-  repositories {
-      google()
-      jcenter()
-  }
-}
-
-apply plugin: 'com.android.library'
-apply plugin: 'maven-publish'
+def pomName = "Vosk English Model"
+def pomDescription = "Small English model for Android"
 
 android {
     compileSdkVersion 29
@@ -32,40 +8,40 @@ android {
         minSdkVersion 21
         targetSdkVersion 29
         versionCode 6
-        versionName = libVersion
+        versionName = version
         archivesBaseName = archiveName
     }
-}
-
-Properties properties = new Properties()
-properties.load(project.rootProject.file('local.properties').newDataInputStream())
-
-bintray {
-    user = properties.getProperty("bintray.user")
-    key = properties.getProperty("bintray.apikey")
-    pkg {
-        repo = 'vosk'
-        name = 'vosk-model-en'
-        userOrg = "alphacep"
-        licenses = ['Apache2.0']
-        websiteUrl = 'https://github.com/alphacep/vosk-api'
-        issueTrackerUrl = 'https://github.com/alphacep/vosk-api/issues'
-        vcsUrl = 'https://github.com/alphacep/vosk-api'
-        version {
-            name = libVersion
-            vcsTag = libVersion
+    buildFeatures {
+        buildConfig = false
+    }
+    sourceSets {
+        main {
+            assets.srcDirs += "$buildDir/generated/assets"
         }
     }
-    publications = ['aar']
 }
 
+tasks.register('genUUID') {
+    def uuid = UUID.randomUUID().toString()
+    def odir = file("$buildDir/generated/assets/model-en-us")
+    def ofile = file("$odir/uuid")
+    doLast {
+        mkdir odir
+        ofile.text = uuid
+    }
+}
+
+preBuild.dependsOn(genUUID)
+
 publishing {
     publications {
         aar(MavenPublication) {
-            groupId 'com.alphacep'
-            artifactId archiveName
-            version libVersion
+            artifactId = archiveName
             artifact("$buildDir/outputs/aar/$archiveName-release.aar")
+            pom {
+                name = pomName
+                description = pomDescription
+            }
         }
     }
 }

android/model-en/src/main/AndroidManifest.xml

@@ -1,3 +1,3 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="org.kaldi.model.en">
+    package="org.vosk.model.en">
 </manifest>

android/model-en/src/main/assets/vosk-model-en/version

@@ -1 +0,0 @@
-0.3.16

android/settings.gradle

@@ -1 +1 @@
-include 'model-en'
+include ':lib', ':model-en'

android/src/main/java/org/kaldi/Assets.java

@@ -1,262 +0,0 @@
-// Copyright 2019 Alpha Cephei Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//       http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package org.kaldi;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.io.PrintWriter;
-import java.io.Reader;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Queue;
-
-import android.content.Context;
-import android.content.res.AssetManager;
-import android.os.Environment;
-import android.util.Log;
-
-/**
- * Provides utility methods to keep asset files to external storage to allow
- * further JNI code access assets from a filesystem.
- * 
- * There must be special file {@value #ASSET_LIST_NAME} among the application
- * assets containing relative paths of assets to synchronize. If the
- * corresponding path does not exist on the external storage it is copied. If
- * the path exists checksums are compared and the asset is copied only if there
- * is a mismatch. Checksum is stored in a separate asset with the name that
- * consists of the original name and a suffix that depends on the checksum
- * algorithm (e.g. MD5). Checksum files are copied along with the corresponding
- * asset files.
- * 
- * @author Alexander Solovets
- */
-public class Assets {
-
-    protected static final String TAG = Assets.class.getSimpleName();
-
-    public static final String ASSET_LIST_NAME = "assets.lst";
-    public static final String SYNC_DIR = "sync";
-    public static final String HASH_EXT = ".md5";
-
-    private final AssetManager assetManager;
-    private final File externalDir;
-
-    /**
-     * Creates new instance for asset synchronization
-     * 
-     * @param context
-     *            application context
-     * 
-     * @throws IOException
-     *             if the directory does not exist
-     * 
-     * @see android.content.Context#getExternalFilesDir
-     * @see android.os.Environment#getExternalStorageState
-     */
-    public Assets(Context context) throws IOException {
-        File appDir = context.getExternalFilesDir(null);
-        if (null == appDir)
-            throw new IOException("cannot get external files dir, "
-                    + "external storage state is " + Environment.getExternalStorageState());
-        externalDir = new File(appDir, SYNC_DIR);
-        assetManager = context.getAssets();
-    }
-
-    /**
-     * Creates new instance with specified destination for assets
-     * 
-     * @param context
-     *            application context to retrieve the assets
-     * @param path
-     *            path to sync the files
-     */ 
-    public Assets(Context context, String dest) {
-        externalDir = new File(dest);
-        assetManager = context.getAssets();
-    }
-
-    /**
-     * Returns destination path on external storage where assets are copied.
-     * 
-     * @return path to application directory or null if it does not exists
-     */
-    public File getExternalDir() {
-        return externalDir;
-    }
-
-    /**
-     * Returns the map of asset paths to the files checksums.
-     * 
-     * @return path to the root of resources directory on external storage
-     * @throws IOException
-     *             if an I/O error occurs or "assets.lst" is missing
-     */
-    public Map<String, String> getItems() throws IOException {
-        Map<String, String> items = new HashMap<String, String>();
-        for (String path : readLines(openAsset(ASSET_LIST_NAME))) {
-            Reader reader = new InputStreamReader(openAsset(path + HASH_EXT));
-            items.put(path, new BufferedReader(reader).readLine());
-        }
-        return items;
-    }
-
-    /**
-     * Returns path to hash mappings for the previously copied files. This
-     * method can be used to find out assets which must be updated.
-     */
-    public Map<String, String> getExternalItems() {
-        try {
-            Map<String, String> items = new HashMap<String, String>();
-            File assetFile = new File(externalDir, ASSET_LIST_NAME);
-            for (String line : readLines(new FileInputStream(assetFile))) {
-                String[] fields = line.split(" ");
-                items.put(fields[0], fields[1]);
-            }
-            return items;
-        } catch (IOException e) {
-            return Collections.emptyMap();
-        }
-    }
-
-    /**
-     * In case you want to create more smart sync implementation, this method
-     * returns the list of items which must be synchronized.
-     */
-    public Collection<String> getItemsToCopy(String path) throws IOException {
-        Collection<String> items = new ArrayList<String>();
-        Queue<String> queue = new ArrayDeque<String>();
-        queue.offer(path);
-
-        while (!queue.isEmpty()) {
-            path = queue.poll();
-            String[] list = assetManager.list(path);
-            for (String nested : list)
-                queue.offer(nested);
-
-            if (list.length == 0)
-                items.add(path);
-        }
-
-        return items;
-    }
-
-    private List<String> readLines(InputStream source) throws IOException {
-        List<String> lines = new ArrayList<String>();
-        BufferedReader br = new BufferedReader(new InputStreamReader(source));
-        String line;
-        while (null != (line = br.readLine()))
-            lines.add(line);
-        return lines;
-    }
-
-    private InputStream openAsset(String asset) throws IOException {
-        return assetManager.open(new File(SYNC_DIR, asset).getPath());
-    }
-
-    /**
-     * Saves the list of synchronized items. The list is stored as a two-column
-     * space-separated list of items in a text file. The file is located at the
-     * root of synchronization directory in the external storage.
-     * 
-     * @param items
-     *            the items
-     * @throws IOException
-     *             if an I/O error occurs
-     */
-    public void updateItemList(Map<String, String> items) throws IOException {
-        File assetListFile = new File(externalDir, ASSET_LIST_NAME);
-        PrintWriter pw = new PrintWriter(new FileOutputStream(assetListFile));
-        for (Map.Entry<String, String> entry : items.entrySet())
-            pw.format("%s %s\n", entry.getKey(), entry.getValue());
-        pw.close();
-    }
-
-    /**
-     * Copies raw asset resource to external storage of the device.
-     * 
-     * @param path
-     *            path of the asset to copy
-     * @throws IOException
-     *             if an I/O error occurs
-     */
-    public File copy(String asset) throws IOException {
-        InputStream source = openAsset(asset);
-        File destinationFile = new File(externalDir, asset);
-        destinationFile.getParentFile().mkdirs();
-        OutputStream destination = new FileOutputStream(destinationFile);
-        byte[] buffer = new byte[1024];
-        int nread;
-
-        while ((nread = source.read(buffer)) != -1) {
-            if (nread == 0) {
-                nread = source.read();
-                if (nread < 0)
-                    break;
-                destination.write(nread);
-                continue;
-            }
-            destination.write(buffer, 0, nread);
-        }
-        destination.close();
-        return destinationFile;
-    }
-
-    /**
-     * Performs the sync of assets in the application and on the external
-     * storage
-     * 
-     * @return The folder on external storage with data
-     * @throws IOException
-     */
-    public File syncAssets() throws IOException {
-        Collection<String> newItems = new ArrayList<String>();
-        Collection<String> unusedItems = new ArrayList<String>();
-        Map<String, String> items = getItems();
-        Map<String, String> externalItems = getExternalItems();
-
-        for (String path : items.keySet()) {
-            if (!items.get(path).equals(externalItems.get(path))
-                    || !(new File(externalDir, path).exists()))
-                newItems.add(path);
-        }
-
-        unusedItems.addAll(externalItems.keySet());
-        unusedItems.removeAll(items.keySet());
-
-        for (String path : newItems) {
-            File file = copy(path);
-        }
-
-        for (String path : unusedItems) {
-            File file = new File(externalDir, path);
-            file.delete();
-        }
-
-        updateItemList(items);
-        return externalDir;
-    }
-
-}

c/Makefile

@@ -1,16 +1,16 @@
 CFLAGS=-I../src
-LDFLAGS=-L../src -lvosk -ldl -lpthread -Wl,-rpath=../src
+LDFLAGS=-L../src -lvosk -ldl -lpthread -Wl,-rpath,../src
 
 all: test_vosk test_vosk_speaker
 
 test_vosk: test_vosk.o
-	g++ $^ -o $@ $(LDFLAGS)
+	gcc $^ -o $@ $(LDFLAGS)
 
 test_vosk_speaker: test_vosk_speaker.o
-	g++ $^ -o $@ $(LDFLAGS)
+	gcc $^ -o $@ $(LDFLAGS)
 
 %.o: %.c
-	g++ $(CFLAGS) -c -o $@ $<
+	gcc $(CFLAGS) -c -o $@ $<
 
 clean:
 	rm -f *.o *.a test_vosk test_vosk_speaker

c/test_vosk_speaker.c

@@ -8,7 +8,7 @@ int main() {
 
     VoskModel *model = vosk_model_new("model");
     VoskSpkModel *spk_model = vosk_spk_model_new("spk-model");
-    VoskRecognizer *recognizer = vosk_recognizer_new_spk(model, spk_model, 16000.0);
+    VoskRecognizer *recognizer = vosk_recognizer_new_spk(model, 16000.0, spk_model);
 
     wavin = fopen("test.wav", "rb");
     fseek(wavin, 44, SEEK_SET);

csharp/demo/VoskDemo.cs

@@ -2,14 +2,56 @@ using System;
 using System.IO;
 using Vosk;
 
-public class Test
+public class VoskDemo
 {
-   public static void Main()
+   public static void DemoBytes(Model model)
    {
-
-        Vosk.Vosk.SetLogLevel(0);
-        Model model = new Model("model");
+        // Demo byte buffer
         VoskRecognizer rec = new VoskRecognizer(model, 16000.0f);
+        rec.SetMaxAlternatives(0);
+        rec.SetWords(true);
+        using(Stream source = File.OpenRead("test.wav")) {
+            byte[] buffer = new byte[4096];
+            int bytesRead;
+            while((bytesRead = source.Read(buffer, 0, buffer.Length)) > 0) {
+                if (rec.AcceptWaveform(buffer, bytesRead)) {
+                    Console.WriteLine(rec.Result());
+                } else {
+                    Console.WriteLine(rec.PartialResult());
+                }
+            }
+        }
+        Console.WriteLine(rec.FinalResult());
+   }
+
+   public static void DemoFloats(Model model)
+   {
+        // Demo float array
+        VoskRecognizer rec = new VoskRecognizer(model, 16000.0f);
+        using(Stream source = File.OpenRead("test.wav")) {
+            byte[] buffer = new byte[4096];
+            int bytesRead;
+            while((bytesRead = source.Read(buffer, 0, buffer.Length)) > 0) {
+                float[] fbuffer = new float[bytesRead / 2];
+                for (int i = 0, n = 0; i < fbuffer.Length; i++, n+=2) {
+                    fbuffer[i] = BitConverter.ToInt16(buffer, n);
+                }
+                if (rec.AcceptWaveform(fbuffer, fbuffer.Length)) {
+                    Console.WriteLine(rec.Result());
+                } else {
+                    Console.WriteLine(rec.PartialResult());
+                }
+            }
+        }
+        Console.WriteLine(rec.FinalResult());
+   }
+
+   public static void DemoSpeaker(Model model)
+   {
+        // Output speakers
+        SpkModel spkModel = new SpkModel("model-spk");
+        VoskRecognizer rec = new VoskRecognizer(model, 16000.0f);
+        rec.SetSpkModel(spkModel);
 
         using(Stream source = File.OpenRead("test.wav")) {
             byte[] buffer = new byte[4096];
@@ -23,25 +65,16 @@ public class Test
             }
         }
         Console.WriteLine(rec.FinalResult());
+   }
 
-        rec = new VoskRecognizer(model, 16000.0f);
+   public static void Main()
+   {
+        // You can set to -1 to disable logging messages
+        Vosk.Vosk.SetLogLevel(0);
 
-        using(Stream source = File.OpenRead("test.wav")) {
-            byte[] buffer = new byte[4096];
-            int bytesRead;
-            while((bytesRead = source.Read(buffer, 0, buffer.Length)) > 0) {
-                float[] fbuffer = new float[bytesRead / 2];
-                for (int i = 0, n = 0; i < fbuffer.Length; i++, n+=2) {
-                    fbuffer[i] = (short)(buffer[n] | buffer[n+1] << 8);
-                }
-                if (rec.AcceptWaveform(fbuffer, fbuffer.Length)) {
-                    Console.WriteLine(rec.Result());
-                    GC.Collect();
-                } else {
-                    Console.WriteLine(rec.PartialResult());
-                }
-            }
-        }
-        Console.WriteLine(rec.FinalResult());
+        Model model = new Model("model");
+        DemoBytes(model);
+        DemoFloats(model);
+        DemoSpeaker(model);
    }
 }

csharp/demo/VoskDemo.csproj

@@ -6,8 +6,12 @@
     <RootNamespace>VoskDemo</RootNamespace>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <RestoreSources>$(RestoreSources);../nuget</RestoreSources>
+  </PropertyGroup>
+
   <ItemGroup>
-    <PackageReference Include="Vosk" Version="0.3.19" />
+    <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.19</version>
+    <version>0.3.38</version>
     <authors>Alpha Cephei Inc</authors>
     <owners>Alpha Cephei Inc</owners>
     <license type="expression">Apache-2.0</license>

csharp/nuget/build/Vosk.targets

@@ -2,6 +2,7 @@
   <ItemGroup>
     <NativeLibs Include="$(MSBuildThisFileDirectory)\lib\linux-x64\*.so" Condition="'$([MSBuild]::IsOsPlatform(Linux))'" />
     <NativeLibs Include="$(MSBuildThisFileDirectory)\lib\win-x64\*.dll" Condition="'$([MSBuild]::IsOsPlatform(Windows))'" />
+    <NativeLibs Include="$(MSBuildThisFileDirectory)\lib\osx-x64\*.dylib" Condition="'$([MSBuild]::IsOsPlatform(OSX))'" />
     <None Include="@(NativeLibs)">
       <Link>%(FileName)%(Extension)</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>

csharp/nuget/src/Model.cs

@@ -32,7 +32,7 @@ public class Model : global::System.IDisposable {
   public Model(string model_path) : this(VoskPINVOKE.new_Model(model_path)) {
   }
 
-  public int vosk_model_find_word(string word) {
+  public int FindWord(string word) {
     return VoskPINVOKE.Model_vosk_model_find_word(handle, word);
   }
 

csharp/nuget/src/Vosk.cs

@@ -5,6 +5,13 @@ public class Vosk {
     VoskPINVOKE.SetLogLevel(level);
   }
 
+  public static void GpuInit() {
+    VoskPINVOKE.GpuInit();
+  }
+
+  public static void GpuThreadInit() {
+    VoskPINVOKE.GpuThreadInit();
+  }
 }
 
 }

csharp/nuget/src/VoskPINVOKE.cs

@@ -24,7 +24,7 @@ class VoskPINVOKE {
   public static extern global::System.IntPtr new_VoskRecognizer(global::System.Runtime.InteropServices.HandleRef jarg1, float jarg2);
 
   [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_recognizer_new_spk")]
-  public static extern global::System.IntPtr new_VoskRecognizerSpk(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, float jarg3);
+  public static extern global::System.IntPtr new_VoskRecognizerSpk(global::System.Runtime.InteropServices.HandleRef jarg1, float jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);
 
   [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_recognizer_new_grm")]
   public static extern global::System.IntPtr new_VoskRecognizerGrm(global::System.Runtime.InteropServices.HandleRef jarg1, float jarg2, string jarg3);
@@ -32,6 +32,18 @@ class VoskPINVOKE {
   [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_recognizer_free")]
   public static extern void delete_VoskRecognizer(global::System.Runtime.InteropServices.HandleRef jarg1);
 
+  [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_recognizer_set_max_alternatives")]
+  public static extern void VoskRecognizer_SetMaxAlternatives(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);
+
+  [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_recognizer_set_words")]
+  public static extern void VoskRecognizer_SetWords(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);
+
+  [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_recognizer_set_partial_words")]
+  public static extern void VoskRecognizer_SetPartialWords(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);
+
+  [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_recognizer_set_spk_model")]
+  public static extern void VoskRecognizer_SetSpkModel(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
   [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_recognizer_accept_waveform")]
   public static extern bool VoskRecognizer_AcceptWaveform(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.In, global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPArray)]byte[] jarg2, int jarg3);
 
@@ -50,8 +62,17 @@ class VoskPINVOKE {
   [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_recognizer_final_result")]
   public static extern global::System.IntPtr VoskRecognizer_FinalResult(global::System.Runtime.InteropServices.HandleRef jarg1);
 
+  [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_recognizer_reset")]
+  public static extern void VoskRecognizer_Reset(global::System.Runtime.InteropServices.HandleRef jarg1);
+
   [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_set_log_level")]
   public static extern void SetLogLevel(int jarg1);
+
+  [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_gpu_init")]
+  public static extern void GpuInit();
+
+  [global::System.Runtime.InteropServices.DllImport("libvosk", EntryPoint="vosk_gpu_thread_init")]
+  public static extern void GpuThreadInit();
 }
 
 }

csharp/nuget/src/VoskRecognizer.cs

@@ -1,14 +1,14 @@
 namespace Vosk {
 
-public class VoskRecognizer : global::System.IDisposable {
-  private global::System.Runtime.InteropServices.HandleRef handle;
+public class VoskRecognizer : System.IDisposable {
+  private System.Runtime.InteropServices.HandleRef handle;
 
-  internal VoskRecognizer(global::System.IntPtr cPtr) {
-    handle = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+  internal VoskRecognizer(System.IntPtr cPtr) {
+    handle = new System.Runtime.InteropServices.HandleRef(this, cPtr);
   }
 
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(VoskRecognizer obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.handle;
+  internal static System.Runtime.InteropServices.HandleRef getCPtr(VoskRecognizer obj) {
+    return (obj == null) ? new System.Runtime.InteropServices.HandleRef(null, System.IntPtr.Zero) : obj.handle;
   }
 
   ~VoskRecognizer() {
@@ -17,14 +17,14 @@ public class VoskRecognizer : global::System.IDisposable {
 
   public void Dispose() {
     Dispose(true);
-    global::System.GC.SuppressFinalize(this);
+    System.GC.SuppressFinalize(this);
   }
 
   protected virtual void Dispose(bool disposing) {
     lock(this) {
-      if (handle.Handle != global::System.IntPtr.Zero) {
+      if (handle.Handle != System.IntPtr.Zero) {
         VoskPINVOKE.delete_VoskRecognizer(handle);
-        handle = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+        handle = new System.Runtime.InteropServices.HandleRef(null, System.IntPtr.Zero);
       }
     }
   }
@@ -32,12 +32,28 @@ public class VoskRecognizer : global::System.IDisposable {
   public VoskRecognizer(Model model, float sample_rate) : this(VoskPINVOKE.new_VoskRecognizer(Model.getCPtr(model), sample_rate)) {
   }
 
-  public VoskRecognizer(Model model, SpkModel spk_model, float sample_rate) : this(VoskPINVOKE.new_VoskRecognizerSpk(Model.getCPtr(model), SpkModel.getCPtr(spk_model), sample_rate)) {
+  public VoskRecognizer(Model model, float sample_rate, SpkModel spk_model) : this(VoskPINVOKE.new_VoskRecognizerSpk(Model.getCPtr(model), sample_rate, SpkModel.getCPtr(spk_model))) {
   }
 
   public VoskRecognizer(Model model, float sample_rate, string grammar) : this(VoskPINVOKE.new_VoskRecognizerGrm(Model.getCPtr(model), sample_rate, grammar)) {
   }
 
+  public void SetMaxAlternatives(int max_alternatives) {
+    VoskPINVOKE.VoskRecognizer_SetMaxAlternatives(handle, max_alternatives);
+  }
+
+  public void SetWords(bool words) {
+    VoskPINVOKE.VoskRecognizer_SetWords(handle, words ? 1 : 0);
+  }
+
+  public void SetPartialWords(bool partial_words) {
+    VoskPINVOKE.VoskRecognizer_SetPartialWords(handle, partial_words ? 1 : 0);
+  }
+
+  public void SetSpkModel(SpkModel spk_model) {
+    VoskPINVOKE.VoskRecognizer_SetSpkModel(handle, SpkModel.getCPtr(spk_model));
+  }
+
   public bool AcceptWaveform(byte[] data, int len) {
     return VoskPINVOKE.VoskRecognizer_AcceptWaveform(handle, data, len);
   }
@@ -50,16 +66,29 @@ public class VoskRecognizer : global::System.IDisposable {
     return VoskPINVOKE.VoskRecognizer_AcceptWaveformFloat(handle, fdata, len);
   }
 
+  private static string PtrToStringUTF8(System.IntPtr ptr) {
+    int len = 0;
+    while (System.Runtime.InteropServices.Marshal.ReadByte(ptr, len) != 0)
+        len++;
+    byte[] array = new byte[len];
+    System.Runtime.InteropServices.Marshal.Copy(ptr, array, 0, len);
+    return System.Text.Encoding.UTF8.GetString(array);
+  }
+
   public string Result() {
-    return global::System.Runtime.InteropServices.Marshal.PtrToStringUTF8(VoskPINVOKE.VoskRecognizer_Result(handle));
+    return PtrToStringUTF8(VoskPINVOKE.VoskRecognizer_Result(handle));
   }
 
   public string PartialResult() {
-    return global::System.Runtime.InteropServices.Marshal.PtrToStringUTF8(VoskPINVOKE.VoskRecognizer_PartialResult(handle));
+    return PtrToStringUTF8(VoskPINVOKE.VoskRecognizer_PartialResult(handle));
   }
 
   public string FinalResult() {
-    return global::System.Runtime.InteropServices.Marshal.PtrToStringUTF8(VoskPINVOKE.VoskRecognizer_FinalResult(handle));
+    return PtrToStringUTF8(VoskPINVOKE.VoskRecognizer_FinalResult(handle));
+  }
+
+  public void Reset() {
+    VoskPINVOKE.VoskRecognizer_Reset(handle);
   }
 
 }

doc/accuracy.md

@@ -1 +0,0 @@
-See https://alphacephei.com/vosk/accuracy

doc/adaptation.md

@@ -1 +0,0 @@
-See https://alphacephei.com/vosk/adaptation

doc/models.md

@@ -1 +0,0 @@
-See https://alphacephei.com/vosk/models

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/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

@@ -0,0 +1,152 @@
+package vosk
+
+// #cgo CPPFLAGS: -I ${SRCDIR}/../src
+// #cgo LDFLAGS: -L ${SRCDIR}/../src -lvosk -ldl -lpthread
+// #include <stdlib.h>
+// #include <vosk_api.h>
+import "C"
+
+// VoskModel contains a reference to the C VoskModel
+type VoskModel struct {
+	model *C.struct_VoskModel
+}
+
+// NewModel creates a new VoskModel instance
+func NewModel(modelPath string) (*VoskModel, error) {
+	internal := C.vosk_model_new(C.CString(modelPath))
+	model := &VoskModel{model: internal}
+	return model, nil
+}
+
+func (m *VoskModel) Free() {
+	C.vosk_model_free(m.model)
+}
+
+func freeModel(model *VoskModel) {
+	C.vosk_model_free(model.model)
+}
+
+// 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) {
+	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()
+}

ios/VoskApiTest.xcodeproj/project.pbxproj

@@ -13,10 +13,10 @@
 		92375229240C550B00DD6076 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 92375228240C550B00DD6076 /* Assets.xcassets */; };
 		9237522C240C550B00DD6076 /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 9237522A240C550B00DD6076 /* LaunchScreen.storyboard */; };
 		92375234240C558900DD6076 /* Vosk.swift in Sources */ = {isa = PBXBuildFile; fileRef = 92375233240C558900DD6076 /* Vosk.swift */; };
-		9237523C240C642000DD6076 /* libkaldiwrap.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 9237523A240C642000DD6076 /* libkaldiwrap.a */; };
 		92375244240C6DAF00DD6076 /* Accelerate.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 92375243240C6DAF00DD6076 /* Accelerate.framework */; };
-		92375246240C6DC900DD6076 /* libstdc++.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 92375245240C6DC900DD6076 /* libstdc++.tbd */; };
 		92375274240C6F1E00DD6076 /* 10001-90210-01803.wav in Resources */ = {isa = PBXBuildFile; fileRef = 92375256240C6E3D00DD6076 /* 10001-90210-01803.wav */; };
+		925527A9273C492C00FFD9CC /* libvosk.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 925527A8273C492C00FFD9CC /* libvosk.a */; };
+		92833003273C466E00058B52 /* libc++.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 92833002273C466E00058B52 /* libc++.tbd */; };
 		92BACED125BE125A00B5CC93 /* vosk-model-small-en-us-0.15 in Resources */ = {isa = PBXBuildFile; fileRef = 928CC50C25BE124400490481 /* vosk-model-small-en-us-0.15 */; };
 		92D6B8D325BDFEAC007FF08D /* VoskModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 92D6B8D225BDFEAC007FF08D /* VoskModel.swift */; };
 		92D86BD6253F823F0040D53F /* vosk-model-spk-0.4 in Resources */ = {isa = PBXBuildFile; fileRef = 92D86BD4253F823F0040D53F /* vosk-model-spk-0.4 */; };
@@ -31,10 +31,10 @@
 		9237522B240C550B00DD6076 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
 		9237522D240C550B00DD6076 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		92375233240C558900DD6076 /* Vosk.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Vosk.swift; sourceTree = "<group>"; };
-		9237523A240C642000DD6076 /* libkaldiwrap.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libkaldiwrap.a; sourceTree = "<group>"; };
 		92375243240C6DAF00DD6076 /* Accelerate.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Accelerate.framework; path = System/Library/Frameworks/Accelerate.framework; sourceTree = SDKROOT; };
-		92375245240C6DC900DD6076 /* libstdc++.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = "libstdc++.tbd"; path = "usr/lib/libstdc++.tbd"; sourceTree = SDKROOT; };
 		92375256240C6E3D00DD6076 /* 10001-90210-01803.wav */ = {isa = PBXFileReference; lastKnownFileType = audio.wav; path = "10001-90210-01803.wav"; sourceTree = "<group>"; };
+		925527A8273C492C00FFD9CC /* libvosk.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libvosk.a; sourceTree = "<group>"; };
+		92833002273C466E00058B52 /* libc++.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = "libc++.tbd"; path = "usr/lib/libc++.tbd"; sourceTree = SDKROOT; };
 		928CC50C25BE124400490481 /* vosk-model-small-en-us-0.15 */ = {isa = PBXFileReference; lastKnownFileType = folder; name = "vosk-model-small-en-us-0.15"; path = "/Users/shmyrev/Documents/IOS/VoskApiTest/VoskApiTest/Vosk/vosk-model-small-en-us-0.15"; sourceTree = "<absolute>"; };
 		92AA22AD244CDD1200DA464B /* vosk_api.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vosk_api.h; sourceTree = "<group>"; };
 		92AA22AE244CDD5200DA464B /* bridging.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bridging.h; sourceTree = "<group>"; };
@@ -47,9 +47,9 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				92375246240C6DC900DD6076 /* libstdc++.tbd in Frameworks */,
+				92833003273C466E00058B52 /* libc++.tbd in Frameworks */,
 				92375244240C6DAF00DD6076 /* Accelerate.framework in Frameworks */,
-				9237523C240C642000DD6076 /* libkaldiwrap.a in Frameworks */,
+				925527A9273C492C00FFD9CC /* libvosk.a in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -93,11 +93,11 @@
 		92375239240C642000DD6076 /* Vosk */ = {
 			isa = PBXGroup;
 			children = (
-				928CC50C25BE124400490481 /* vosk-model-small-en-us-0.15 */,
 				92D86BD4253F823F0040D53F /* vosk-model-spk-0.4 */,
-				92375256240C6E3D00DD6076 /* 10001-90210-01803.wav */,
+				928CC50C25BE124400490481 /* vosk-model-small-en-us-0.15 */,
+				925527A8273C492C00FFD9CC /* libvosk.a */,
 				92AA22AD244CDD1200DA464B /* vosk_api.h */,
-				9237523A240C642000DD6076 /* libkaldiwrap.a */,
+				92375256240C6E3D00DD6076 /* 10001-90210-01803.wav */,
 			);
 			name = Vosk;
 			path = VoskApiTest/Vosk;
@@ -106,7 +106,7 @@
 		92375242240C6DAF00DD6076 /* Frameworks */ = {
 			isa = PBXGroup;
 			children = (
-				92375245240C6DC900DD6076 /* libstdc++.tbd */,
+				92833002273C466E00058B52 /* libc++.tbd */,
 				92375243240C6DAF00DD6076 /* Accelerate.framework */,
 			);
 			name = Frameworks;
@@ -145,7 +145,7 @@
 					9237521D240C550B00DD6076 = {
 						CreatedOnToolsVersion = 8.3.2;
 						LastSwiftMigration = 0920;
-						ProvisioningStyle = Automatic;
+						ProvisioningStyle = Manual;
 					};
 				};
 			};
@@ -223,7 +223,6 @@
 				ALWAYS_SEARCH_USER_PATHS = NO;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
@@ -245,7 +244,7 @@
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "";
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
@@ -282,7 +281,6 @@
 				ALWAYS_SEARCH_USER_PATHS = NO;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
@@ -304,7 +302,7 @@
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "";
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				ENABLE_NS_ASSERTIONS = NO;
@@ -319,6 +317,7 @@
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 10.3;
 				MTL_ENABLE_DEBUG_INFO = NO;
+				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = iphoneos;
 				SWIFT_OBJC_BRIDGING_HEADER = bridging.h;
 				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";
@@ -333,7 +332,10 @@
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CLANG_ENABLE_MODULES = YES;
-				ENABLE_BITCODE = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				ENABLE_BITCODE = NO;
 				INFOPLIST_FILE = VoskApiTest/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
 				LIBRARY_SEARCH_PATHS = (
@@ -342,11 +344,13 @@
 				);
 				PRODUCT_BUNDLE_IDENTIFIER = com.alphacephei.VoskApiTest;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
 				SWIFT_INSTALL_OBJC_HEADER = YES;
 				SWIFT_OBJC_BRIDGING_HEADER = VoskApiTest/bridging.h;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
 				SWIFT_SWIFT3_OBJC_INFERENCE = Default;
 				SWIFT_VERSION = 4.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
 			};
 			name = Debug;
 		};
@@ -355,7 +359,10 @@
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CLANG_ENABLE_MODULES = YES;
-				ENABLE_BITCODE = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				ENABLE_BITCODE = NO;
 				INFOPLIST_FILE = VoskApiTest/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
 				LIBRARY_SEARCH_PATHS = (
@@ -364,10 +371,12 @@
 				);
 				PRODUCT_BUNDLE_IDENTIFIER = com.alphacephei.VoskApiTest;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
 				SWIFT_INSTALL_OBJC_HEADER = YES;
 				SWIFT_OBJC_BRIDGING_HEADER = VoskApiTest/bridging.h;
 				SWIFT_SWIFT3_OBJC_INFERENCE = Default;
 				SWIFT_VERSION = 4.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
 			};
 			name = Release;
 		};

ios/VoskApiTest.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -1,9 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Workspace
    version = "1.0">
-   <FileRef
-      location = "group:/Users/shmyrev/Documents/IOS/VoskApiTest/VoskApiTest/Vosk/vosk-model-small-en-us-0.15">
-   </FileRef>
    <FileRef
       location = "self:">
    </FileRef>

ios/VoskApiTest/Vosk.swift

@@ -14,7 +14,7 @@ public final class Vosk {
     var recognizer : OpaquePointer!
 
     init(model: VoskModel, sampleRate: Float) {
-        recognizer = vosk_recognizer_new_spk(model.model, model.spkModel, sampleRate)
+        recognizer = vosk_recognizer_new_spk(model.model, sampleRate, model.spkModel)
     }
     
     deinit {

ios/VoskApiTest/Vosk/vosk_api.h

@@ -1,4 +1,4 @@
-// Copyright 2020 Alpha Cephei Inc.
+// Copyright 2020-2021 Alpha Cephei Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -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);
 
 
@@ -55,10 +55,18 @@ VoskModel *vosk_model_new(const char *model_path);
 void vosk_model_free(VoskModel *model);
 
 
+/** Check if a word can be recognized by the model
+ * @param word: the word
+ * @returns the word symbol if @param word exists inside the model
+ * or -1 otherwise.
+ * Reminding that word symbol 0 is for <epsilon> */
+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);
 
 
@@ -71,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);
 
 
@@ -82,10 +94,14 @@ 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 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
- *  @param sample_rate The sample rate of the audio you going to feed into the recognizer
- *  @returns recognizer object */
-VoskRecognizer *vosk_recognizer_new_spk(VoskModel *model, VoskSpkModel *spk_model, float sample_rate);
+ *  @returns recognizer object or NULL if problem occured */
+VoskRecognizer *vosk_recognizer_new_spk(VoskModel *model, float sample_rate, VoskSpkModel *spk_model);
 
 
 /** Creates the recognizer object with the phrase list
@@ -98,42 +114,46 @@ VoskRecognizer *vosk_recognizer_new_spk(VoskModel *model, VoskSpkModel *spk_mode
  *  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);
 
 
-/** Accept voice data
+/** Adds speaker model to already initialized recognizer
  *
- *  accept and process new chunk of voice data
+ * Can add speaker recognition model to already created recognizer. Helps to initialize
+ * speaker recognition for grammar-based recognizer.
  *
- *  @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 */
-int vosk_recognizer_accept_waveform(VoskRecognizer *recognizer, const char *data, int length);
+ * @param spk_model Speaker recognition model */
+void vosk_recognizer_set_spk_model(VoskRecognizer *recognizer, VoskSpkModel *spk_model);
 
 
-/** Same as above but the version with the short data for language bindings where you have
- *  audio as array of shorts */
-int vosk_recognizer_accept_waveform_s(VoskRecognizer *recognizer, const short *data, int length);
-
-
-/** Same as above but the version with the float data for language bindings where you have
- *  audio as array of floats */
-int vosk_recognizer_accept_waveform_f(VoskRecognizer *recognizer, const float *data, int length);
-
-
-/** Returns speech recognition result
- *
- * @returns the result in JSON format which contains decoded line, decoded
- *          words, times in seconds and confidences. You can parse this result
- *          with any json parser
+/** Configures recognizer to output n-best results
+ *
+ * <pre>
+ *   {
+ *      "alternatives": [
+ *          { "text": "one two three four five", "confidence": 0.97 },
+ *          { "text": "one two three for five", "confidence": 0.03 },
+ *      ]
+ *   }
+ * </pre>
+ *
+ * @param max_alternatives - maximum alternatives to return from recognition results
+ */
+void vosk_recognizer_set_max_alternatives(VoskRecognizer *recognizer, int max_alternatives);
+
+
+/** Enables words with times in the output
  *
  * <pre>
- * {
  *   "result" : [{
  *       "conf" : 1.000000,
  *       "end" : 1.110000,
@@ -156,13 +176,54 @@ int vosk_recognizer_accept_waveform_f(VoskRecognizer *recognizer, const float *d
  *       "word" : "zero"
  *     }, {
  *       "conf" : 1.000000,
- *      "end" : 2.610000,
+ *       "end" : 2.610000,
  *       "start" : 2.340000,
  *       "word" : "one"
  *     }],
- *   "text" : "what zero zero zero one"
+ * </pre>
+ *
+ * @param words - boolean value
+ */
+void vosk_recognizer_set_words(VoskRecognizer *recognizer, int words);
+
+
+/** Accept voice data
+ *
+ *  accept and process new chunk of voice data
+ *
+ *  @param data - audio data in PCM 16-bit mono format
+ *  @param length - length of the audio data
+ *  @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);
+
+
+/** Same as above but the version with the short data for language bindings where you have
+ *  audio as array of shorts */
+int vosk_recognizer_accept_waveform_s(VoskRecognizer *recognizer, const short *data, int length);
+
+
+/** Same as above but the version with the float data for language bindings where you have
+ *  audio as array of floats */
+int vosk_recognizer_accept_waveform_f(VoskRecognizer *recognizer, const float *data, int length);
+
+
+/** Returns speech recognition result
+ *
+ * @returns the result in JSON format which contains decoded line, decoded
+ *          words, times in seconds and confidences. You can parse this result
+ *          with any json parser
+ *
+ * <pre>
+ *  {
+ *    "text" : "what zero zero zero one"
  *  }
  * </pre>
+ *
+ * If alternatives enabled it returns result with alternatives, see also vosk_recognizer_set_alternatives().
+ *
+ * If word times enabled returns word time, see also vosk_recognizer_set_word_times().
  */
 const char *vosk_recognizer_result(VoskRecognizer *recognizer);
 
@@ -174,7 +235,7 @@ const char *vosk_recognizer_result(VoskRecognizer *recognizer);
  *
  * <pre>
  * {
- *  "partial" : "cyril one eight zero"
+ *    "partial" : "cyril one eight zero"
  * }
  * </pre>
  */
@@ -190,6 +251,12 @@ const char *vosk_recognizer_partial_result(VoskRecognizer *recognizer);
 const char *vosk_recognizer_final_result(VoskRecognizer *recognizer);
 
 
+/** Resets the recognizer
+ *
+ *  Resets current results so the recognition can continue from scratch */
+void vosk_recognizer_reset(VoskRecognizer *recognizer);
+
+
 /** Releases recognizer object
  *
  *  Underlying model is also unreferenced and if needed released */
@@ -204,6 +271,20 @@ void vosk_recognizer_free(VoskRecognizer *recognizer);
  */
 void vosk_set_log_level(int log_level);
 
+/**
+ *  Init, automatically select a CUDA device and allow multithreading.
+ *  Must be called once from the main thread.
+ *  Has no effect if HAVE_CUDA flag is not set.
+ */
+void vosk_gpu_init();
+
+/**
+ *  Init CUDA device in a multi-threaded environment.
+ *  Must be called for each thread.
+ *  Has no effect if HAVE_CUDA flag is not set.
+ */
+void vosk_gpu_thread_init();
+
 #ifdef __cplusplus
 }
 #endif

java/README.md

@@ -1,5 +1,7 @@
-Java Vosk API using jnr-ffi
+Java bindings for Vosk API using jnr-ffi
 
-Still needs classes to wrap C code
+See demo project for details, build it with Gradle.
 
-Run with simple gradle build. Unpack model and put libvosk library in current folder.
+Download model and unpack as "model" folder in the demo project.
+
+Make sure you are using recent JDK and Gradle.

java/build.gradle

@@ -1,12 +0,0 @@
-apply plugin: "application"
-
-mainClassName = "test.DecoderTest"
-applicationDefaultJvmArgs = ['-Djna.library.path=.']
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    implementation group: 'net.java.dev.jna', name: 'jna', version: '4.5.0'
-}

java/demo/build.gradle

@@ -0,0 +1,16 @@
+plugins {
+    id 'application'
+}
+
+application {
+    mainClass = 'org.vosk.demo.DecoderDemo'
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation group: 'net.java.dev.jna', name: 'jna', version: '5.7.0'
+    implementation group: 'com.alphacephei', name: 'vosk', version: '0.3.38+'
+}

java/demo/src/main/java/org/vosk/demo/DecoderDemo.java

@@ -0,0 +1,38 @@
+package org.vosk.demo;
+
+import java.io.FileInputStream;
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.UnsupportedAudioFileException;
+
+import org.vosk.LogLevel;
+import org.vosk.Recognizer;
+import org.vosk.LibVosk;
+import org.vosk.Model;
+
+public class DecoderDemo {
+
+    public static void main(String[] argv) throws IOException, UnsupportedAudioFileException {
+        LibVosk.setLogLevel(LogLevel.DEBUG);
+
+        try (Model model = new Model("model");
+                    InputStream ais = AudioSystem.getAudioInputStream(new BufferedInputStream(new FileInputStream("../../python/example/test.wav")));
+                    Recognizer recognizer = new Recognizer(model, 16000)) {
+
+            int nbytes;
+            byte[] b = new byte[4096];
+            while ((nbytes = ais.read(b)) >= 0) {
+                if (recognizer.acceptWaveForm(b, nbytes)) {
+                    System.out.println(recognizer.getResult());
+                } else {
+                    System.out.println(recognizer.getPartialResult());
+                }
+            }
+
+            System.out.println(recognizer.getFinalResult());
+        }
+    }
+}

java/lib/build.gradle

@@ -0,0 +1,71 @@
+buildscript {
+  repositories {
+    mavenCentral()
+  }
+}
+
+plugins {
+    id 'java-library'
+    id 'maven-publish'
+    id 'com.vanniktech.maven.publish' version '0.18.0'
+}
+
+repositories {
+    mavenCentral()
+}
+
+archivesBaseName = 'vosk'
+group = 'com.alphacephei'
+version = '0.3.38'
+
+mavenPublish {
+    group = 'com.alphacephei'
+    version = version
+    sonatypeHost = 's01'
+}
+
+dependencies {
+    api group: 'net.java.dev.jna', name: 'jna', version: '5.7.0'
+    testImplementation 'junit:junit:4.13'
+}
+
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            artifactId = 'vosk'
+            from components.java
+            pom {
+                name = 'Vosk'
+                description = 'Speech recognition library'
+                url = 'http://www.alphacephei.com.com/vosk/'
+                licenses {
+                    license {
+                        name = 'The Apache License, Version 2.0'
+                        url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                    }
+                }
+                developers {
+                    developer {
+                        id = 'alphacephei'
+                        name = 'Alpha Cephei Inc'
+                        email = 'contact@alphacephei.com'
+                    }
+                }
+                scm {
+                    connection = 'scm:git:git://github.com/alphacep/vosk-api.git'
+                    url = 'https://github.com/alphacep/vosk-api/'
+                }
+            }
+        }
+    }
+}
+
+test {
+    dependsOn cleanTest
+    testLogging.showStandardStreams = true
+}
+
+java {
+    withSourcesJar()
+    withJavadocJar()
+}

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

@@ -0,0 +1,88 @@
+package org.vosk;
+
+import com.sun.jna.Native;
+import com.sun.jna.Library;
+import com.sun.jna.Platform;
+import com.sun.jna.Pointer;
+import java.io.File;
+import java.io.InputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+
+public class LibVosk {
+
+    private static void unpackDll(File targetDir, String lib) throws IOException {
+        InputStream source = LibVosk.class.getResourceAsStream("/win32-x86-64/" + lib + ".dll");
+        Files.copy(source, new File(targetDir, lib + ".dll").toPath(), StandardCopyOption.REPLACE_EXISTING);
+    }
+
+    static {
+
+        if (Platform.isWindows()) {
+            // We have to unpack dependencies
+            try {
+                // To get a tmp folder we unpack small library and mark it for deletion
+                File tmpFile = Native.extractFromResourcePath("/win32-x86-64/empty");
+                File tmpDir = tmpFile.getParentFile();
+                new File(tmpDir, tmpFile.getName() + ".x").createNewFile();
+
+                // Now unpack dependencies
+                unpackDll(tmpDir, "libwinpthread-1");
+                unpackDll(tmpDir, "libgcc_s_seh-1");
+                unpackDll(tmpDir, "libstdc++-6");
+
+            } catch (IOException e) {
+                // Nothing for now, it will fail on next step
+            } finally {
+                Native.register(LibVosk.class, "libvosk");
+            }
+        } else {
+            Native.register(LibVosk.class, "vosk");
+        }
+    }
+
+    public static native void vosk_set_log_level(int level);
+
+    public static native Pointer vosk_model_new(String path);
+
+    public static native void vosk_model_free(Pointer model);
+
+    public static native Pointer vosk_spk_model_new(String path);
+
+    public static native void vosk_spk_model_free(Pointer model);
+
+    public static native Pointer vosk_recognizer_new(Model model, float sample_rate);
+
+    public static native Pointer vosk_recognizer_new_spk(Pointer model, float sample_rate, Pointer spk_model);
+
+    public static native Pointer vosk_recognizer_new_grm(Pointer model, float sample_rate, String grammar);
+
+    public static native void vosk_recognizer_set_max_alternatives(Pointer recognizer, int max_alternatives);
+
+    public static native void vosk_recognizer_set_words(Pointer recognizer, boolean words);
+
+    public static native void vosk_recognizer_set_partial_words(Pointer recognizer, boolean partial_words);
+
+    public static native void vosk_recognizer_set_spk_model(Pointer recognizer, Pointer spk_model);
+
+    public static native boolean vosk_recognizer_accept_waveform(Pointer recognizer, byte[] data, int len);
+
+    public static native boolean vosk_recognizer_accept_waveform_s(Pointer recognizer, short[] data, int len);
+
+    public static native boolean vosk_recognizer_accept_waveform_f(Pointer recognizer, float[] data, int len);
+
+    public static native String vosk_recognizer_result(Pointer recognizer);
+
+    public static native String vosk_recognizer_final_result(Pointer recognizer);
+
+    public static native String vosk_recognizer_partial_result(Pointer recognizer);
+
+    public static native void vosk_recognizer_reset(Pointer recognizer);
+
+    public static native void vosk_recognizer_free(Pointer recognizer);
+
+    public static void setLogLevel(LogLevel loglevel) {
+        vosk_set_log_level(loglevel.getValue());
+    }
+}

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

@@ -0,0 +1,17 @@
+package org.vosk;
+
+public enum LogLevel {
+    WARNINGS(-1),  // Print warning and errors
+    INFO(0),       // Print info, along with warning and error messages, but no debug
+    DEBUG(1);      // Print debug info
+
+    private final int value;
+
+    LogLevel(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return this.value;
+    }
+}

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

@@ -0,0 +1,22 @@
+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) throws IOException {
+        super(LibVosk.vosk_model_new(path));
+
+        if (getPointer() == null) {
+            throw new IOException("Failed to create a model");
+        }
+    }
+
+    @Override
+    public void close() {
+        LibVosk.vosk_model_free(this.getPointer());
+    }
+}

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

@@ -0,0 +1,71 @@
+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) 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) {
+        super(LibVosk.vosk_recognizer_new_spk(model.getPointer(), sampleRate, spkModel.getPointer()));
+    }
+
+    public Recognizer(Model model, float sampleRate, String grammar) {
+        super(LibVosk.vosk_recognizer_new_grm(model.getPointer(), sampleRate, grammar));
+    }
+
+    public void setMaxAlternatives(int maxAlternatives) {
+        LibVosk.vosk_recognizer_set_max_alternatives(this.getPointer(), maxAlternatives);
+    }
+
+    public void setWords(boolean words) {
+        LibVosk.vosk_recognizer_set_words(this.getPointer(), words);
+    }
+
+    public void setPartialWords(boolean partial_words) {
+        LibVosk.vosk_recognizer_set_partial_words(this.getPointer(), partial_words);
+    }
+
+    public void setSpeakerModel(SpeakerModel spkModel) {
+        LibVosk.vosk_recognizer_set_spk_model(this.getPointer(), spkModel.getPointer());
+    }
+
+    public boolean acceptWaveForm(byte[] data, int len) {
+        return LibVosk.vosk_recognizer_accept_waveform(this.getPointer(), data, len);
+    }
+
+    public boolean acceptWaveForm(short[] data, int len) {
+        return LibVosk.vosk_recognizer_accept_waveform_s(this.getPointer(), data, len);
+    }
+
+    public boolean acceptWaveForm(float[] data, int len) {
+        return LibVosk.vosk_recognizer_accept_waveform_f(this.getPointer(), data, len);
+    }
+
+    public String getResult() {
+        return LibVosk.vosk_recognizer_result(this.getPointer());
+    }
+
+    public String getPartialResult() {
+        return LibVosk.vosk_recognizer_partial_result(this.getPointer());
+    }
+
+    public String getFinalResult() {
+        return LibVosk.vosk_recognizer_final_result(this.getPointer());
+    }
+
+    public void reset() {
+        LibVosk.vosk_recognizer_reset(this.getPointer());
+    }
+
+    @Override
+    public void close() {
+        LibVosk.vosk_recognizer_free(this.getPointer());
+    }
+}

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

@@ -0,0 +1,22 @@
+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) throws IOException {
+        super(LibVosk.vosk_spk_model_new(path));
+
+        if (getPointer() == null) {
+            throw new IOException("Failed to create a speaker model");
+        }
+    }
+
+    @Override
+    public void close() {
+        LibVosk.vosk_spk_model_free(this.getPointer());
+    }
+}

java/lib/src/main/resources/win32-x86-64/empty

@@ -0,0 +1 @@
+Mainly for work around JNA API

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

@@ -0,0 +1,103 @@
+package org.vosk.test;
+
+import java.io.FileInputStream;
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import org.junit.Test;
+import org.junit.Assert;
+
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.UnsupportedAudioFileException;
+
+import org.vosk.LogLevel;
+import org.vosk.Recognizer;
+import org.vosk.LibVosk;
+import org.vosk.Model;
+
+public class DecoderTest {
+
+    @Test
+    public void decoderTest() throws IOException, UnsupportedAudioFileException {
+        LibVosk.setLogLevel(LogLevel.DEBUG);
+
+        try (Model model = new Model("model");
+            InputStream ais = AudioSystem.getAudioInputStream(new BufferedInputStream(new FileInputStream("../../python/example/test.wav")));
+            Recognizer recognizer = new Recognizer(model, 16000)) {
+
+            recognizer.setMaxAlternatives(10);
+            recognizer.setWords(true);
+            recognizer.setPartialWords(true);
+
+            int nbytes;
+            byte[] b = new byte[4096];
+            while ((nbytes = ais.read(b)) >= 0) {
+                if (recognizer.acceptWaveForm(b, nbytes)) {
+                    System.out.println(recognizer.getResult());
+                } else {
+                    System.out.println(recognizer.getPartialResult());
+                }
+            }
+
+            System.out.println(recognizer.getFinalResult());
+        }
+        Assert.assertTrue(true);
+    }
+
+    @Test
+    public void decoderTestShort() throws IOException, UnsupportedAudioFileException {
+        LibVosk.setLogLevel(LogLevel.DEBUG);
+
+        try (Model model = new Model("model");
+            InputStream ais = AudioSystem.getAudioInputStream(new BufferedInputStream(new FileInputStream("../../python/example/test.wav")));
+            Recognizer recognizer = new Recognizer(model, 16000)) {
+
+            int nbytes;
+            byte[] b = new byte[4096];
+            short[] s = new short[2048];
+            while ((nbytes = ais.read(b)) >= 0) {
+                ByteBuffer.wrap(b).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().get(s);
+                if (recognizer.acceptWaveForm(s, nbytes / 2)) {
+                    System.out.println(recognizer.getResult());
+                } else {
+                    System.out.println(recognizer.getPartialResult());
+                }
+            }
+
+            System.out.println(recognizer.getFinalResult());
+        }
+        Assert.assertTrue(true);
+    }
+
+    @Test
+    public void decoderTestGrammar() throws IOException, UnsupportedAudioFileException {
+        LibVosk.setLogLevel(LogLevel.DEBUG);
+
+        try (Model model = new Model("model");
+            InputStream ais = AudioSystem.getAudioInputStream(new BufferedInputStream(new FileInputStream("../../python/example/test.wav")));
+            Recognizer recognizer = new Recognizer(model, 16000, "[\"one two three four five six seven eight nine zero oh\"]")) {
+
+            int nbytes;
+            byte[] b = new byte[4096];
+            while ((nbytes = ais.read(b)) >= 0) {
+                if (recognizer.acceptWaveForm(b, nbytes)) {
+                    System.out.println(recognizer.getResult());
+                } else {
+                    System.out.println(recognizer.getPartialResult());
+                }
+            }
+
+            System.out.println(recognizer.getFinalResult());
+        }
+        Assert.assertTrue(true);
+    }
+
+
+    @Test(expected = IOException.class)
+    public void decoderTestException() throws IOException {
+        Model model = new Model("model_missing");
+    }
+}

java/src/main/java/test/DecoderTest.java

@@ -1,49 +0,0 @@
-package test;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.net.URL;
-import java.nio.*;
-
-import com.sun.jna.Library;
-import com.sun.jna.Native;
-import com.sun.jna.Platform;
-import com.sun.jna.Pointer;
-
-public class DecoderTest {
-    public interface LibVosk extends Library {
-        static LibVosk INSTANCE = (LibVosk) Native.loadLibrary("vosk", LibVosk.class);
-
-        void vosk_set_log_level(int level);
-        Pointer vosk_model_new(String path);
-        void vosk_model_free(Pointer model);
-        Pointer vosk_recognizer_new(Pointer model, float sample_rate);
-        boolean vosk_recognizer_accept_waveform(Pointer recognizer, byte[] data, int len);
-        String vosk_recognizer_result(Pointer recognizer);
-        String vosk_recognizer_final_result(Pointer recognizer);
-        String vosk_recognizer_partial_result(Pointer recognizer);
-        void vosk_recognizer_free(Pointer recognizer);
-    }
-
-    public static void main(String[] args) throws IOException {
-        LibVosk.INSTANCE.vosk_set_log_level(0);
-        Pointer model = LibVosk.INSTANCE.vosk_model_new("model");
-
-        FileInputStream ais = new FileInputStream(new File("../python/example/test.wav"));
-        Pointer rec = LibVosk.INSTANCE.vosk_recognizer_new(model, 16000.0f);
-
-        int nbytes;
-        byte[] b = new byte[4096];
-        while ((nbytes = ais.read(b)) >= 0) {
-            if (LibVosk.INSTANCE.vosk_recognizer_accept_waveform(rec, b, nbytes)) {
-                System.out.println(LibVosk.INSTANCE.vosk_recognizer_result(rec));
-            } else {
-                System.out.println(LibVosk.INSTANCE.vosk_recognizer_partial_result(rec));
-            }
-         }
-        System.out.println(LibVosk.INSTANCE.vosk_recognizer_final_result(rec));
-        LibVosk.INSTANCE.vosk_recognizer_free(rec);
-        LibVosk.INSTANCE.vosk_model_free(model);
-    }
-}

nodejs/README.md

@@ -2,18 +2,18 @@ This is an FFI-NAPI wrapper for the Vosk library.
 
 ## Usage
 
-It mostly follows Vosk interface, some methods are not yet fully implemented.
+Bindings mostly follow Vosk interface, some methods are not yet fully implemented.
 
-To use it you need to compile libvosk library, see Python module build
-instructions for details. You can find prebuilt library inside python
-wheel.
+See [demo folder](https://github.com/alphacep/vosk-api/tree/master/nodejs/demo) for
+details.
 
 ## About
 
 Vosk is an offline open source speech recognition toolkit. It enables
-speech recognition models for 17 languages and dialects - English, Indian
+speech recognition for 20+ languages and dialects - English, Indian
 English, German, French, Spanish, Portuguese, Chinese, Russian, Turkish,
-Vietnamese, Italian, Dutch, Catalan, Arabic, Greek, Farsi, Filipino.
+Vietnamese, Italian, Dutch, Catalan, Arabic, Greek, Farsi, Filipino,
+Ukrainian, Kazakh, Swedish, Japanese, Esperanto, Hindi, Czech. More to come.
 
 Vosk models are small (50 Mb) but provide continuous large vocabulary
 transcription, zero-latency response with streaming API, reconfigurable

nodejs/demo/demo.js

@@ -1,30 +0,0 @@
-var vosk = require('..')
-
-const fs = require("fs");
-const { Readable } = require("stream");
-const wav = require("wav");
-
-vosk.setLogLevel(0);
-const model = new vosk.Model("model");
-const rec = new vosk.Recognizer(model, 16000.0);
-
-const wfStream = fs.createReadStream("test.wav", {'highWaterMark': 4096});
-const wfReader = new wav.Reader();
-
-wfReader.on('format', async ({ audioFormat, sampleRate, channels }) => {
-    if (audioFormat != 1 || channels != 1) {
-        console.error("Audio file must be WAV format mono PCM.");
-        process.exit(1);
-    }
-    for await (const data of new Readable().wrap(wfReader)) {
-        const end_of_speech = rec.acceptWaveform(data);
-        if (end_of_speech) {
-              console.log(rec.result());
-        }
-    }
-    console.log(rec.finalResult(rec));
-    rec.free();
-    model.free();
-});
-
-wfStream.pipe(wfReader);

nodejs/demo/test_ffmpeg.js

@@ -0,0 +1,33 @@
+var vosk = require('..')
+
+const fs = require("fs");
+const { spawn } = require("child_process");
+
+MODEL_PATH = "model"
+FILE_NAME = "test.wav"
+SAMPLE_RATE = 16000
+BUFFER_SIZE = 4000
+
+if (!fs.existsSync(MODEL_PATH)) {
+    console.log("Please download the model from https://alphacephei.com/vosk/models and unpack as " + MODEL_PATH + " in the current folder.")
+    process.exit()
+}
+
+if (process.argv.length > 2)
+    FILE_NAME = process.argv[2]
+
+vosk.setLogLevel(0);
+const model = new vosk.Model(MODEL_PATH);
+const rec = new vosk.Recognizer({model: model, sampleRate: SAMPLE_RATE});
+
+const ffmpeg_run = spawn('ffmpeg', ['-loglevel', 'quiet', '-i', FILE_NAME,
+                         '-ar', String(SAMPLE_RATE) , '-ac', '1',
+                         '-f', 's16le', '-bufsize', String(BUFFER_SIZE) , '-']);
+
+ffmpeg_run.stdout.on('data', (stdout) => {
+    if (rec.acceptWaveform(stdout))
+        console.log(rec.result());
+    else
+        console.log(rec.partialResult());
+    console.log(rec.finalResult());
+});

nodejs/demo/test_microphone.js

@@ -0,0 +1,39 @@
+var vosk = require('..')
+
+const fs = require("fs");
+var mic = require("mic");
+
+MODEL_PATH = "model"
+SAMPLE_RATE = 16000
+
+if (!fs.existsSync(MODEL_PATH)) {
+    console.log("Please download the model from https://alphacephei.com/vosk/models and unpack as " + MODEL_PATH + " in the current folder.")
+    process.exit()
+}
+
+vosk.setLogLevel(0);
+const model = new vosk.Model(MODEL_PATH);
+const rec = new vosk.Recognizer({model: model, sampleRate: SAMPLE_RATE});
+
+var micInstance = mic({
+    rate: String(SAMPLE_RATE),
+    channels: '1',
+    debug: false
+});
+
+var micInputStream = micInstance.getAudioStream();
+micInstance.start();
+
+micInputStream.on('data', data => {
+    if (rec.acceptWaveform(data))
+        console.log(rec.result());
+    else
+        console.log(rec.partialResult());
+});
+
+process.on('SIGINT', function() {
+    console.log(rec.finalResult());
+    console.log("\nDone");
+    rec.free();
+    model.free();
+});

nodejs/demo/test_simple.js

@@ -0,0 +1,48 @@
+var vosk = require('..')
+
+const fs = require("fs");
+const { Readable } = require("stream");
+const wav = require("wav");
+
+MODEL_PATH = "model"
+FILE_NAME = "test.wav"
+
+if (!fs.existsSync(MODEL_PATH)) {
+    console.log("Please download the model from https://alphacephei.com/vosk/models and unpack as " + MODEL_PATH + " in the current folder.")
+    process.exit()
+}
+
+if (process.argv.length > 2)
+    FILE_NAME = process.argv[2]
+
+vosk.setLogLevel(0);
+const model = new vosk.Model(MODEL_PATH);
+
+const wfReader = new wav.Reader();
+const wfReadable = new Readable().wrap(wfReader);
+
+wfReader.on('format', async ({ audioFormat, sampleRate, channels }) => {
+    if (audioFormat != 1 || channels != 1) {
+        console.error("Audio file must be WAV format mono PCM.");
+        process.exit(1);
+    }
+    const rec = new vosk.Recognizer({model: model, sampleRate: sampleRate});
+    rec.setMaxAlternatives(10);
+    rec.setWords(true);
+    rec.setPartialWords(true);
+    for await (const data of wfReadable) {
+        const end_of_speech = rec.acceptWaveform(data);
+        if (end_of_speech) {
+              console.log(JSON.stringify(rec.result(), null, 4));
+        } else {
+              console.log(JSON.stringify(rec.partialResult(), null, 4));
+        }
+    }
+    console.log(JSON.stringify(rec.finalResult(rec), null, 4));
+    rec.free();
+});
+
+fs.createReadStream(FILE_NAME, {'highWaterMark': 4096}).pipe(wfReader).on('finish', 
+    function (err) {
+        model.free();
+});

nodejs/demo/test_simple_async.js

@@ -0,0 +1,46 @@
+var vosk = require('..')
+
+const async = require("async");
+const fs = require("fs");
+const { Readable } = require("stream");
+const wav = require("wav");
+
+MODEL_PATH = "model"
+
+if (!fs.existsSync(MODEL_PATH)) {
+    console.log("Please download the model from https://alphacephei.com/vosk/models and unpack as " + MODEL_PATH + " in the current folder.")
+    process.exit()
+}
+
+// Process file 4 times in parallel with a single model
+files = Array(10).fill("test.wav")
+const model = new vosk.Model(MODEL_PATH)
+
+async.filter(files, function(filePath, callback) {
+    const wfReader = new wav.Reader();
+    const wfReadable = new Readable().wrap(wfReader);
+
+    wfReader.on('format', async ({ audioFormat, sampleRate, channels }) => {
+        const rec = new vosk.Recognizer({model: model, sampleRate: sampleRate});
+        if (audioFormat != 1 || channels != 1) {
+            console.error("Audio file must be WAV format mono PCM.");
+            process.exit(1);
+        }
+        for await (const data of wfReadable) {
+            const end_of_speech = await rec.acceptWaveformAsync(data);
+            if (end_of_speech) {
+                  console.log(rec.result());
+            }
+        }
+        console.log(rec.finalResult(rec));
+        rec.free();
+        // Signal we are done without errors
+        callback(null, true);
+    });
+
+    fs.createReadStream(filePath, {'highWaterMark': 4096}).pipe(wfReader);
+
+}, function(err, results) {
+    model.free();
+    console.log("Done!!!!!");
+});

nodejs/demo/test_speaker.js

@@ -0,0 +1,53 @@
+const vosk = require('..');
+
+const fs = require("fs");
+const { Readable } = require("stream");
+const wav = require("wav");
+
+MODEL_PATH = "model"
+SPEAKER_MODEL_PATH = "model-spk"
+FILE_NAME = "test.wav"
+
+if (!fs.existsSync(MODEL_PATH)) {
+    console.log("Please download the model from https://alphacephei.com/vosk/models and unpack as " + MODEL_PATH + " in the current folder.")
+    process.exit()
+}
+
+if (!fs.existsSync(SPEAKER_MODEL_PATH)) {
+    console.log("Please download the speaker model from https://alphacephei.com/vosk/models and unpack as " + SPEAKER_MODEL_PATH + " in the current folder.")
+    process.exit()
+}
+
+if (process.argv.length > 2)
+    FILE_NAME = process.argv[2]
+
+const model = new vosk.Model(MODEL_PATH);
+const speakerModel = new vosk.SpeakerModel(SPEAKER_MODEL_PATH);
+
+const wfReader = new wav.Reader();
+const wfReadable = new Readable().wrap(wfReader);
+
+wfReader.on('format', async ({ audioFormat, sampleRate, channels }) => {
+    if (audioFormat != 1 || channels != 1) {
+        console.error('Audio file must be WAV format mono PCM.');
+        process.exit(1);
+    }
+//    const rec = new vosk.Recognizer({ model: model,
+//                                      speakerModel: speakerModel,
+//                                      sampleRate: sampleRate });
+    const rec = new vosk.Recognizer({model: model, sampleRate: sampleRate});
+    rec.setSpkModel(speakerModel);
+    for await (const data of wfReadable) {
+        const end_of_speech = rec.acceptWaveform(data);
+        if (end_of_speech) {
+             console.log(rec.finalResult());
+        }
+    }
+    console.log(rec.finalResult());
+    rec.free();
+});
+
+fs.createReadStream(FILE_NAME, { highWaterMark: 4096 }).pipe(wfReader).on('finish', function (err) {
+    model.free();
+    speakerModel.free();
+});

nodejs/demo/test_srt.js

@@ -0,0 +1,84 @@
+var vosk = require('..')
+
+const fs = require("fs");
+const { spawn } = require("child_process");
+const { stringifySync } = require('subtitle')
+
+MODEL_PATH = "model"
+FILE_NAME = "test.wav"
+SAMPLE_RATE = 16000 
+BUFFER_SIZE = 4000
+
+if (!fs.existsSync(MODEL_PATH)) {
+    console.log("Please download the model from https://alphacephei.com/vosk/models and unpack as " + MODEL_PATH + " in the current folder.")
+    process.exit()
+}
+
+if (process.argv.length > 2)
+    FILE_NAME = process.argv[2]
+
+vosk.setLogLevel(-1);
+const model = new vosk.Model(MODEL_PATH);
+const rec = new vosk.Recognizer({model: model, sampleRate: SAMPLE_RATE});
+rec.setWords(true);
+
+const ffmpeg_run = spawn('ffmpeg', ['-loglevel', 'quiet', '-i', FILE_NAME,
+                         '-ar', String(SAMPLE_RATE) , '-ac', '1',
+                         '-f', 's16le', '-bufsize', String(BUFFER_SIZE), '-']);
+
+WORDS_PER_LINE = 7
+const subs = []
+const results = []
+ffmpeg_run.stdout.on('data', (stdout) => {
+    if (rec.acceptWaveform(stdout))
+        results.push(rec.result());
+    results.push(rec.finalResult());
+});
+
+ffmpeg_run.on('exit', code => {
+    rec.free();
+    model.free();
+    results.forEach(element =>{
+        if (!element.hasOwnProperty('result'))
+            return;
+        const words = element.result;
+        if (words.length == 1) {
+            subs.push({
+                type: 'cue',
+                data: {
+                start: words[0].start * 1000,
+                end: words[0].end * 1000,
+                text: words[0].word
+                }
+            });
+            return;
+        }
+        var start_index = 0;
+        var text = words[0].word + " ";
+        for (let i = 1; i < words.length; i++) {
+            text += words[i].word + " ";
+            if (i % WORDS_PER_LINE == 0) {
+                subs.push({
+                    type: 'cue',
+                    data: {
+                      start: words[start_index].start * 1000,
+                      end: words[i].end * 1000,
+                      text: text.slice(0, text.length-1)
+                    }
+                });
+                start_index = i;
+                text = "";
+            }
+        }
+        if (start_index != words.length - 1)
+            subs.push({
+                type: 'cue',
+                data: {
+                  start: words[start_index].start * 1000,
+                  end: words[words.length-1].end * 1000,
+                  text: text
+                }
+            });
+    });
+    console.log(stringifySync(subs, {format: "SRT"}));
+});

nodejs/index.js

@@ -1,8 +1,15 @@
+// @ts-check
 'use strict'
 
+/**
+ * @module vosk
+ */
+
 const os = require('os');
 const path = require('path');
+/** @type {import('ffi-napi')} */
 const ffi = require('ffi-napi');
+/** @type {import('ref-napi')} */
 const ref = require('ref-napi');
 
 const vosk_model = ref.types.void;
@@ -12,66 +19,415 @@ const vosk_spk_model_ptr = ref.refType(vosk_spk_model);
 const vosk_recognizer = ref.types.void;
 const vosk_recognizer_ptr = ref.refType(vosk_recognizer);
 
-var soname;
-if (os.platform == 'win32') {
+/**
+ * @typedef {Object} WordResult
+ * @property {number} conf The confidence rate in the detection. 0 For unlikely, and 1 for totally accurate.
+ * @property {number} start The start of the timeframe when the word is pronounced in seconds
+ * @property {number} end The end of the timeframe when the word is pronounced in seconds
+ * @property {string} word The word detected
+ */
+
+/**
+ * @typedef {Object} RecognitionResults
+ * @property {WordResult[]} result Details about the words that have been detected
+ * @property {string} text The complete sentence that have been detected
+ */
+
+/**
+ * @typedef {Object} SpeakerResults
+ * @property {number[]} spk A floating vector representing speaker identity. It is usually about 128 numbers which uniquely represent speaker voice.
+ * @property {number} spk_frames The number of frames used to extract speaker vector. The more frames you have the more reliable is speaker vector.
+ */
+
+/**
+ * @typedef {Object} BaseRecognizerParam
+ * @property {Model} model The language model to be used 
+ * @property {number} sampleRate The sample rate. Most models are trained at 16kHz
+ */
+
+/**
+ * @typedef {Object} GrammarRecognizerParam
+ * @property {string[]} grammar The list of sentences to be recognized.
+ */
+
+/**
+ * @typedef {Object} SpeakerRecognizerParam
+ * @property {SpeakerModel} speakerModel The SpeakerModel that will enable speaker identification
+ */
+
+/**
+ * @template {SpeakerRecognizerParam | GrammarRecognizerParam} T
+ * @typedef {T extends SpeakerRecognizerParam ? SpeakerResults & RecognitionResults : RecognitionResults} Result
+ */
+
+/**
+ * @typedef {Object} PartialResults
+ * @property {string} partial The partial sentence that have been detected until now
+ */
+
+/** @typedef {string[]} Grammar The list of strings to be recognized */
+
+let soname;
+if (os.platform() == 'win32') {
+    // Update path to load dependent dlls
+    let currentPath = process.env.Path;
+    let dllDirectory = path.resolve(path.join(__dirname, "lib", "win-x86_64"));
+    process.env.Path = currentPath + path.delimiter + dllDirectory;
+
     soname = path.join(__dirname, "lib", "win-x86_64", "libvosk.dll")
+} else if (os.platform() == 'darwin') {
+    soname = path.join(__dirname, "lib", "osx-x86_64", "libvosk.dylib")
 } else {
     soname = path.join(__dirname, "lib", "linux-x86_64", "libvosk.so")
 }
 
 const libvosk = ffi.Library(soname, {
-  'vosk_set_log_level': [ 'void', [ 'int' ] ],
-  'vosk_model_new': [ vosk_model_ptr, [ 'string' ] ],
-  'vosk_model_free': [ 'void', [ vosk_model_ptr ] ],
-  'vosk_recognizer_new': [ vosk_recognizer_ptr, [ vosk_model_ptr, 'float' ] ],
-  'vosk_recognizer_free': [ 'void', [ vosk_recognizer_ptr ] ],
-  'vosk_recognizer_accept_waveform': [ 'bool', [ vosk_recognizer_ptr, 'pointer', 'int' ] ],
-  'vosk_recognizer_result': ['string', [vosk_recognizer_ptr ] ],
-  'vosk_recognizer_final_result': ['string', [vosk_recognizer_ptr ] ],
+    'vosk_set_log_level': ['void', ['int']],
+    'vosk_model_new': [vosk_model_ptr, ['string']],
+    'vosk_model_free': ['void', [vosk_model_ptr]],
+    'vosk_spk_model_new': [vosk_spk_model_ptr, ['string']],
+    'vosk_spk_model_free': ['void', [vosk_spk_model_ptr]],
+    'vosk_recognizer_new': [vosk_recognizer_ptr, [vosk_model_ptr, 'float']],
+    'vosk_recognizer_new_spk': [vosk_recognizer_ptr, [vosk_model_ptr, 'float', vosk_spk_model_ptr]],
+    'vosk_recognizer_new_grm': [vosk_recognizer_ptr, [vosk_model_ptr, 'float', 'string']],
+    'vosk_recognizer_free': ['void', [vosk_recognizer_ptr]],
+    'vosk_recognizer_set_max_alternatives': ['void', [vosk_recognizer_ptr, 'int']],
+    'vosk_recognizer_set_words': ['void', [vosk_recognizer_ptr, 'bool']],
+    'vosk_recognizer_set_partial_words': ['void', [vosk_recognizer_ptr, 'bool']],
+    'vosk_recognizer_set_spk_model': ['void', [vosk_recognizer_ptr, vosk_spk_model_ptr]],
+    'vosk_recognizer_accept_waveform': ['bool', [vosk_recognizer_ptr, 'pointer', 'int']],
+    'vosk_recognizer_result': ['string', [vosk_recognizer_ptr]],
+    'vosk_recognizer_final_result': ['string', [vosk_recognizer_ptr]],
+    'vosk_recognizer_partial_result': ['string', [vosk_recognizer_ptr]],
+    'vosk_recognizer_reset': ['void', [vosk_recognizer_ptr]],
 });
 
+/**
+ * Set log level for Kaldi messages
+ * @param {number} level The higher, the more verbose. 0 for infos and errors. Less than 0 for silence. 
+ */
 function setLogLevel(level) {
     libvosk.vosk_set_log_level(level);
 }
 
-function Model(model_path) {
-
-    this.handle = libvosk.vosk_model_new(model_path);
-
-    this.free = function() {
-        libvosk.vosk_model_free(this.handle);
+/**
+ * Build a Model from a model file.
+ * @see models [models](https://alphacephei.com/vosk/models)
+ */
+class Model {
+    /**
+     * Build a Model to be used with the voice recognition. Each language should have it's own Model
+     * for the speech recognition to work.
+     * @param {string} modelPath The abstract pathname to the model
+     * @see models [models](https://alphacephei.com/vosk/models)
+     */
+    constructor(modelPath) {
+        /**
+         * Store the handle.
+         * For internal use only
+         * @type {unknown}
+         */
+        this.handle = libvosk.vosk_model_new(modelPath);
     }
 
-    this.getHandle = function() {
-        return this.handle;
+    /**
+     * Releases the model memory
+     *
+     * The model object is reference-counted so if some recognizer
+     * depends on this model, model might still stay alive. When
+     * last recognizer is released, model will be released too.
+     */
+    free() {
+        libvosk.vosk_model_free(this.handle);
     }
 }
 
+/**
+ * Build a Speaker Model from a speaker model file.
+ * The Speaker Model enables speaker identification.
+ * @see models [models](https://alphacephei.com/vosk/models)
+ */
+class SpeakerModel {
+    /**
+     * Loads speaker model data from the file and returns the model object
+     *
+     * @param {string} modelPath the path of the model on the filesystem
+     * @see models [models](https://alphacephei.com/vosk/models)
+     */
+    constructor(modelPath) {
+        /**
+         * Store the handle.
+         * For internal use only
+         * @type {unknown}
+         */
+        this.handle = libvosk.vosk_spk_model_new(modelPath);
+    }
 
-function Recognizer(model, sample_rate) {
-    this.handle = libvosk.vosk_recognizer_new(model.getHandle(), sample_rate);
+    /**
+     * Releases the model memory
+     *
+     * The model object is reference-counted so if some recognizer
+     * depends on this model, model might still stay alive. When
+     * last recognizer is released, model will be released too.
+     */
+    free() {
+        libvosk.vosk_spk_model_free(this.handle);
+    }
+}
 
-    this.free = function() {
+/**
+ * Helper to narrow down type while using `hasOwnProperty`.
+ * @see hasOwnProperty [typescript issue](https://fettblog.eu/typescript-hasownproperty/)
+ * @template {Object} Obj
+ * @template {PropertyKey} Key
+ * @param {Obj} obj 
+ * @param {Key} prop 
+ * @returns {obj is Obj & Record<Key, unknown>}
+ */
+function hasOwnProperty(obj, prop) {
+    return obj.hasOwnProperty(prop)
+}
+
+/**
+ * @template T
+ * @template U
+ * @typedef {{ [P in Exclude<keyof T, keyof U>]?: never }} Without
+ */
+
+/**
+ * @template T
+ * @template U
+ * @typedef {(T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U} XOR
+ */
+
+/**
+ * Create a Recognizer that will be able to transform audio streams into text using a Model.
+ * @template {XOR<SpeakerRecognizerParam, Partial<GrammarRecognizerParam>>} T extra parameter
+ * @see Model
+ */
+class Recognizer {
+    /**
+     * Create a Recognizer that will handle speech to text recognition.
+     * @constructor
+     * @param {T & BaseRecognizerParam} param The Recognizer parameters 
+     *
+     *  Sometimes when you want to improve recognition accuracy and when you don't need
+     *  to recognize large vocabulary you can specify a list of phrases to recognize. This
+     *  will improve recognizer speed and accuracy but might return [unk] if user said
+     *  something different.
+     *
+     *  Only recognizers with lookahead models support this type of quick configuration.
+     *  Precompiled HCLG graph models are not supported.
+     */
+    constructor(param) {
+        const { model, sampleRate } = param
+        // Prevent the user to receive unpredictable results
+        if (hasOwnProperty(param, 'speakerModel') && hasOwnProperty(param, 'grammar')) {
+            throw new Error('grammar and speakerModel cannot be used together for now.')
+        }
+        /**
+         * Store the handle.
+         * For internal use only
+         * @type {unknown}
+         */
+        this.handle = hasOwnProperty(param, 'speakerModel')
+            ? libvosk.vosk_recognizer_new_spk(model.handle, sampleRate, param.speakerModel.handle)
+            : hasOwnProperty(param, 'grammar')
+                ? libvosk.vosk_recognizer_new_grm(model.handle, sampleRate, JSON.stringify(param.grammar))
+                : libvosk.vosk_recognizer_new(model.handle, sampleRate);
+    }
+
+    /**
+     * Releases the model memory
+     *
+     * The model object is reference-counted so if some recognizer
+     * depends on this model, model might still stay alive. When
+     * last recognizer is released, model will be released too.
+     */
+    free() {
         libvosk.vosk_recognizer_free(this.handle);
     }
 
-    this.acceptWaveform = function(data) {
-       return libvosk.vosk_recognizer_accept_waveform(this.handle, data, data.length);
+    /** Configures recognizer to output n-best results
+     *
+     * <pre>
+     *   {
+     *      "alternatives": [
+     *          { "text": "one two three four five", "confidence": 0.97 },
+     *          { "text": "one two three for five", "confidence": 0.03 },
+     *      ]
+     *   }
+     * </pre>
+     *
+     * @param max_alternatives - maximum alternatives to return from recognition results
+     */
+    setMaxAlternatives(max_alternatives) {
+        libvosk.vosk_recognizer_set_max_alternatives(this.handle, max_alternatives);
     }
 
-    this.result = function() {
+    /** Configures recognizer to output words with times
+     *
+     * <pre>
+     *   "result" : [{
+     *       "conf" : 1.000000,
+     *       "end" : 1.110000,
+     *       "start" : 0.870000,
+     *       "word" : "what"
+     *     }, {
+     *       "conf" : 1.000000,
+     *       "end" : 1.530000,
+     *       "start" : 1.110000,
+     *       "word" : "zero"
+     *     }, {
+     *       "conf" : 1.000000,
+     *       "end" : 1.950000,
+     *       "start" : 1.530000,
+     *       "word" : "zero"
+     *     }, {
+     *       "conf" : 1.000000,
+     *       "end" : 2.340000,
+     *       "start" : 1.950000,
+     *       "word" : "zero"
+     *     }, {
+     *       "conf" : 1.000000,
+     *       "end" : 2.610000,
+     *       "start" : 2.340000,
+     *       "word" : "one"
+     *     }],
+     * </pre>
+     *
+     * @param words - boolean value
+     */
+    setWords(words) {
+        libvosk.vosk_recognizer_set_words(this.handle, words);
+    }
+
+    /** Same as above, but for partial results*/
+    setPartialWords(partial_words) {
+        libvosk.vosk_recognizer_set_partial_words(this.handle, partial_words);
+    }
+
+    /** Adds speaker recognition model to already created recognizer. Helps to initialize
+     * speaker recognition for grammar-based recognizer.
+     *
+     * @param spk_model Speaker recognition model
+     */
+    setSpkModel(spk_model) {
+        libvosk.vosk_recognizer_set_spk_model(this.handle, spk_model.handle);
+    }
+
+    /** 
+     * Accept voice data
+     *
+     * accept and process new chunk of voice data
+     *
+     * @param {Buffer} data audio data in PCM 16-bit mono format
+     * @returns true if silence is occured and you can retrieve a new utterance with result method
+     */
+    acceptWaveform(data) {
+        return libvosk.vosk_recognizer_accept_waveform(this.handle, data, data.length);
+    };
+
+    /** 
+     * Accept voice data
+     *
+     * accept and process new chunk of voice data
+     *
+     * @param {Buffer} data audio data in PCM 16-bit mono format
+     * @returns true if silence is occured and you can retrieve a new utterance with result method
+     */
+    acceptWaveformAsync(data) {
+        return new Promise((resolve, reject) => {
+            libvosk.vosk_recognizer_accept_waveform.async(this.handle, data, data.length, function(err, result) {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(result);
+                }
+            });
+        });
+    };
+
+    /** Returns speech recognition result in a string
+     *
+     * @returns the result in JSON format which contains decoded line, decoded
+     *          words, times in seconds and confidences. You can parse this result
+     *          with any json parser
+     * <pre>
+     * {
+     *   "result" : [{
+     *       "conf" : 1.000000,
+     *       "end" : 1.110000,
+     *       "start" : 0.870000,
+     *       "word" : "what"
+     *     }, {
+     *       "conf" : 1.000000,
+     *       "end" : 1.530000,
+     *       "start" : 1.110000,
+     *       "word" : "zero"
+     *     }, {
+     *       "conf" : 1.000000,
+     *       "end" : 1.950000,
+     *       "start" : 1.530000,
+     *       "word" : "zero"
+     *     }, {
+     *       "conf" : 1.000000,
+     *       "end" : 2.340000,
+     *       "start" : 1.950000,
+     *       "word" : "zero"
+     *     }, {
+     *       "conf" : 1.000000,
+     *      "end" : 2.610000,
+     *       "start" : 2.340000,
+     *       "word" : "one"
+     *     }],
+     *   "text" : "what zero zero zero one"
+     *  }
+     * </pre>
+     */
+    resultString() {
         return libvosk.vosk_recognizer_result(this.handle);
-    }
+    };
 
-    this.partialResult = function() {
-        return libvosk.vosk_recognizer_partial_result(this.handle);
-    }
+    /**
+     * Returns speech recognition results
+     * @returns {Result<T>} The results
+     */
+    result() {
+        return JSON.parse(libvosk.vosk_recognizer_result(this.handle));
+    };
 
-    this.finalResult = function() {
-        return libvosk.vosk_recognizer_final_result(this.handle);
+    /**
+     * speech recognition text which is not yet finalized.
+     * result may change as recognizer process more data.
+     * 
+     * @returns {PartialResults} The partial results
+     */
+    partialResult() {
+        return JSON.parse(libvosk.vosk_recognizer_partial_result(this.handle));
+    };
+
+    /**
+     * Returns speech recognition result. Same as result, but doesn't wait for silence
+     * You usually call it in the end of the stream to get final bits of audio. It
+     * flushes the feature pipeline, so all remaining audio chunks got processed.
+     *
+     * @returns {Result<T>} speech result.
+     */
+    finalResult() {
+        return JSON.parse(libvosk.vosk_recognizer_final_result(this.handle));
+    };
+
+    /**
+     *
+     * Resets current results so the recognition can continue from scratch 
+     */
+    reset() {
+        libvosk.vosk_recognizer_reset(this.handle);
     }
 }
 
 exports.setLogLevel = setLogLevel
 exports.Model = Model
+exports.SpeakerModel = SpeakerModel
 exports.Recognizer = Recognizer

nodejs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vosk",
-  "version": "0.3.21",
+  "version": "0.3.38",
   "description": "Node binding for continuous offline voice recoginition with Vosk library.",
   "repository": {
     "type": "git",
@@ -18,8 +18,10 @@
     "node": ">= 12.x.x"
   },
   "dependencies": {
-    "ffi-napi": "^3.1.0",
-    "ref-napi": "^3.0.0",
+    "async": "^3.2.0",
+    "ffi-napi": "^4.0.3",
+    "mic": "^2.1.2",
+    "ref-napi": ">=2.0.0",
     "wav": "^1.0.2"
   }
 }

python/README.md

@@ -1,9 +1,10 @@
 This is a Python module for Vosk.
 
 Vosk is an offline open source speech recognition toolkit. It enables
-speech recognition models for 17 languages and dialects - English, Indian
+speech recognition for 20+ languages and dialects - English, Indian
 English, German, French, Spanish, Portuguese, Chinese, Russian, Turkish,
-Vietnamese, Italian, Dutch, Catalan, Arabic, Greek, Farsi, Filipino.
+Vietnamese, Italian, Dutch, Catalan, Arabic, Greek, Farsi, Filipino,
+Ukrainian, Kazakh, Swedish, Japanese, Esperanto, Hindi, Czech. More to come.
 
 Vosk models are small (50 Mb) but provide continuous large vocabulary
 transcription, zero-latency response with streaming API, reconfigurable

python/example/test_alternatives.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+
+from vosk import Model, KaldiRecognizer, SetLogLevel
+import sys
+import os
+import wave
+import json
+
+SetLogLevel(0)
+
+if not os.path.exists("model"):
+    print ("Please download the model from https://alphacephei.com/vosk/models and unpack as 'model' in the current folder.")
+    exit (1)
+
+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.")
+    exit (1)
+
+model = Model("model")
+rec = KaldiRecognizer(model, wf.getframerate())
+rec.SetMaxAlternatives(10)
+rec.SetWords(True)
+
+while True:
+    data = wf.readframes(4000)
+    if len(data) == 0:
+        break
+    if rec.AcceptWaveform(data):
+        print(json.loads(rec.Result()))
+    else:
+        print(json.loads(rec.PartialResult()))
+
+print(json.loads(rec.FinalResult()))

python/example/test_gpu_batch.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+
+import sys
+import os
+import wave
+from time import sleep
+import json
+from timeit import default_timer as timer
+
+
+from vosk import BatchModel, BatchRecognizer, GpuInit
+
+GpuInit()
+
+model = BatchModel()
+
+fnames = open(sys.argv[1]).readlines()
+fds = [open(x.strip(), "rb") for x in fnames]
+uids = [fname.strip().split('/')[-1][:-4] for fname in fnames]
+recs = [BatchRecognizer(model, 16000) for x in fnames]
+results = [""] * len(fnames)
+ended = set()
+tot_samples = 0
+
+start_time = timer()
+
+while True:
+
+    # Feed in the data
+    for i, fd in enumerate(fds):
+        if i in ended:
+            continue
+        data = fd.read(8000);
+        if len(data) == 0:
+            recs[i].FinishStream()
+            ended.add(i)
+            continue
+        recs[i].AcceptWaveform(data)
+        tot_samples += len(data)
+
+    # Wait for results from CUDA
+    model.Wait()
+
+    # Retrieve and add results
+    for i, fd in enumerate(fds):
+       res = recs[i].Result()
+       if len(res) != 0:
+           results[i] = results[i] + " " + json.loads(res)['text']
+
+    if len(ended) == len(fds):
+        break
+
+end_time = timer()
+
+for i in range(len(results)):
+    print (uids[i], results[i].strip())
+
+print ("Processed %.3f seconds of audio in %.3f seconds (%.3f xRT)" % (tot_samples / 16000.0 / 2, end_time - start_time, 
+    (tot_samples / 16000.0 / 2 / (end_time - start_time))), file=sys.stderr)

python/example/test_microphone.py

@@ -20,7 +20,7 @@ def callback(indata, frames, time, status):
     """This is called (from a separate thread) for each audio block."""
     if status:
         print(status, file=sys.stderr)
-    q.put(indata)
+    q.put(bytes(indata))
 
 parser = argparse.ArgumentParser(add_help=False)
 parser.add_argument(
@@ -75,7 +75,6 @@ try:
             rec = vosk.KaldiRecognizer(model, args.samplerate)
             while True:
                 data = q.get()
-                data = bytes(data)
                 if rec.AcceptWaveform(data):
                     print(rec.Result())
                 else:

python/example/test_nlsml.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+
+from vosk import Model, KaldiRecognizer, SetLogLevel
+import sys
+import os
+import wave
+
+SetLogLevel(0)
+
+if not os.path.exists("model"):
+    print ("Please download the model from https://alphacephei.com/vosk/models and unpack as 'model' in the current folder.")
+    exit (1)
+
+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.")
+    exit (1)
+
+model = Model("model")
+rec = KaldiRecognizer(model, wf.getframerate())
+rec.SetMaxAlternatives(10)
+rec.SetNLSML(True)
+
+while True:
+    data = wf.readframes(4000)
+    if len(data) == 0:
+        break
+    if rec.AcceptWaveform(data):
+        print(rec.Result())
+
+print(rec.FinalResult())

python/example/test_reset.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+
+from vosk import Model, KaldiRecognizer, SetLogLevel
+import sys
+import os
+import wave
+import json
+
+SetLogLevel(0)
+
+if not os.path.exists("model"):
+    print ("Please download the model from https://alphacephei.com/vosk/models and unpack as 'model' in the current folder.")
+    exit (1)
+
+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.")
+    exit (1)
+
+model = Model("model")
+rec = KaldiRecognizer(model, wf.getframerate())
+
+while True:
+    data = wf.readframes(4000)
+    if len(data) == 0:
+        break
+    if rec.AcceptWaveform(data):
+        print(rec.Result())
+        break
+
+    else:
+        jres = json.loads(rec.PartialResult())
+        print(jres)
+
+        if jres['partial'] == "one zero zero zero":
+            print("We can reset recognizer here and start over")
+            rec.Reset();

python/example/test_simple.py

@@ -18,6 +18,8 @@ if wf.getnchannels() != 1 or wf.getsampwidth() != 2 or wf.getcomptype() != "NONE
 
 model = Model("model")
 rec = KaldiRecognizer(model, wf.getframerate())
+rec.SetWords(True)
+rec.SetPartialWords(True)
 
 while True:
     data = wf.readframes(4000)

python/example/test_speaker.py

@@ -26,7 +26,9 @@ if wf.getnchannels() != 1 or wf.getsampwidth() != 2 or wf.getcomptype() != "NONE
 # Large vocabulary free form recognition
 model = Model(model_path)
 spk_model = SpkModel(spk_model_path)
-rec = KaldiRecognizer(model, spk_model, wf.getframerate())
+#rec = KaldiRecognizer(model, wf.getframerate(), spk_model)
+rec = KaldiRecognizer(model, wf.getframerate())
+rec.SetSpkModel(spk_model)
 
 # We compare speakers with cosine distance. We can keep one or several fingerprints for the speaker in a database
 # to distingusih among users.

python/example/test_srt.py

@@ -18,6 +18,7 @@ if not os.path.exists("model"):
 sample_rate=16000
 model = Model("model")
 rec = KaldiRecognizer(model, sample_rate)
+rec.SetWords(True)
 
 process = subprocess.Popen(['ffmpeg', '-loglevel', 'quiet', '-i',
                             sys.argv[1],

python/example/test_webvtt.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+
+from vosk import Model, KaldiRecognizer, SetLogLevel
+from webvtt import WebVTT, Caption
+import sys
+import os
+import subprocess
+import json
+import textwrap
+
+SetLogLevel(-1)
+
+if not os.path.exists('model'):
+    print('Please download the model from https://alphacephei.com/vosk/models'
+          ' and unpack as `model` in the current folder.')
+    exit(1)
+
+sample_rate = 16000
+model = Model('model')
+rec = KaldiRecognizer(model, sample_rate)
+rec.SetWords(True)
+
+WORDS_PER_LINE = 7
+
+
+def timeString(seconds):
+    minutes = seconds / 60
+    seconds = seconds % 60
+    hours = int(minutes / 60)
+    minutes = int(minutes % 60)
+    return '%i:%02i:%06.3f' % (hours, minutes, seconds)
+
+
+def transcribe():
+    command = ['ffmpeg', '-nostdin', '-loglevel', 'quiet', '-i', sys.argv[1],
+               '-ar', str(sample_rate), '-ac', '1', '-f', 's16le', '-']
+    process = subprocess.Popen(command, stdout=subprocess.PIPE)
+
+    results = []
+    while True:
+        data = process.stdout.read(4000)
+        if len(data) == 0:
+            break
+        if rec.AcceptWaveform(data):
+            results.append(rec.Result())
+    results.append(rec.FinalResult())
+
+    vtt = WebVTT()
+    for i, res in enumerate(results):
+        words = json.loads(res).get('result')
+        if not words:
+            continue
+
+        start = timeString(words[0]['start'])
+        end = timeString(words[-1]['end'])
+        content = ' '.join([w['word'] for w in words])
+
+        caption = Caption(start, end, textwrap.fill(content))
+        vtt.captions.append(caption)
+
+    # save or return webvtt
+    if len(sys.argv) > 2:
+        vtt.save(sys.argv[2])
+    else:
+        print(vtt.content)
+
+
+if __name__ == '__main__':
+    if not (1 < len(sys.argv) < 4):
+        print(f'Usage: {sys.argv[0]} audiofile [output file]')
+        exit(1)
+    transcribe()

python/setup.py

@@ -25,7 +25,7 @@ else:
         def get_tag(self):
             abi = 'none'
             if system == 'Darwin':
-                oses = 'macosx_10_6_x86_64'
+                oses = 'macosx_10_6_universal'
             elif system == 'Windows' and architecture == '32bit':
                 oses = 'win32'
             elif system == 'Windows' and architecture == '64bit':
@@ -44,7 +44,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="vosk",
-    version="0.3.21",
+    version="0.3.38",
     author="Alpha Cephei Inc",
     author_email="contact@alphacephei.com",
     description="Offline open source speech recognition API based on Kaldi and Vosk",
@@ -53,6 +53,9 @@ setuptools.setup(
     url="https://github.com/alphacep/vosk-api",
     packages=setuptools.find_packages(),
     package_data = {'vosk': ['*.so', '*.dll', '*.dyld']},
+    entry_points = {
+        'console_scripts': ['vosk-transcriber=vosk.transcriber.cli:cli'],
+    },
     include_package_data=True,
     classifiers=[
         'Programming Language :: Python :: 3',

python/vosk/__init__.py

@@ -10,7 +10,7 @@ def open_dll():
         os.environ["PATH"] = dlldir + os.pathsep + os.environ['PATH']
         if hasattr(os, 'add_dll_directory'):
             os.add_dll_directory(dlldir)
-        return _ffi.dlopen("libvosk.dll")
+        return _ffi.dlopen(os.path.join(dlldir, "libvosk.dll"))
     elif sys.platform == 'linux':
         return _ffi.dlopen(os.path.join(dlldir, "libvosk.so"))
     elif sys.platform == 'darwin':
@@ -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)
 
@@ -44,18 +50,39 @@ class KaldiRecognizer(object):
     def __init__(self, *args):
         if len(args) == 2:
             self._handle = _c.vosk_recognizer_new(args[0]._handle, args[1])
-        elif len(args) == 3 and type(args[1]) is SpkModel:
-            self._handle = _c.vosk_recognizer_new_spk(args[0]._handle, args[1]._handle, args[2])
+        elif len(args) == 3 and type(args[2]) is SpkModel:
+            self._handle = _c.vosk_recognizer_new_spk(args[0]._handle, args[1], args[2]._handle)
         elif len(args) == 3 and type(args[2]) is str:
             self._handle = _c.vosk_recognizer_new_grm(args[0]._handle, args[1], args[2].encode('utf-8'))
         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)
 
+    def SetMaxAlternatives(self, max_alternatives):
+        _c.vosk_recognizer_set_max_alternatives(self._handle, max_alternatives)
+
+    def SetWords(self, enable_words):
+        _c.vosk_recognizer_set_words(self._handle, 1 if enable_words else 0)
+
+    def SetPartialWords(self, enable_partial_words):
+        _c.vosk_recognizer_set_partial_words(self._handle, 1 if enable_partial_words else 0)
+
+    def SetNLSML(self, enable_nlsml):
+        _c.vosk_recognizer_set_nlsml(self._handle, 1 if enable_nlsml else 0)
+
+    def SetSpkModel(self, spk_model):
+        _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')
@@ -66,6 +93,57 @@ class KaldiRecognizer(object):
     def FinalResult(self):
         return _ffi.string(_c.vosk_recognizer_final_result(self._handle)).decode('utf-8')
 
+    def Reset(self):
+        return _c.vosk_recognizer_reset(self._handle)
+
 
 def SetLogLevel(level):
     return _c.vosk_set_log_level(level)
+
+
+def GpuInit():
+    _c.vosk_gpu_init()
+
+
+def GpuThreadInit():
+    _c.vosk_gpu_thread_init()
+
+class BatchModel(object):
+
+    def __init__(self, *args):
+        self._handle = _c.vosk_batch_model_new()
+
+        if self._handle == _ffi.NULL:
+            raise Exception("Failed to create a model")
+
+    def __del__(self):
+        _c.vosk_batch_model_free(self._handle)
+
+    def Wait(self):
+        _c.vosk_batch_model_wait(self._handle)
+
+class BatchRecognizer(object):
+
+    def __init__(self, *args):
+        self._handle = _c.vosk_batch_recognizer_new(args[0]._handle, args[1])
+
+        if self._handle == _ffi.NULL:
+            raise Exception("Failed to create a recognizer")
+
+    def __del__(self):
+        _c.vosk_batch_recognizer_free(self._handle)
+
+    def AcceptWaveform(self, data):
+        res = _c.vosk_batch_recognizer_accept_waveform(self._handle, data, len(data))
+
+    def Result(self):
+        ptr = _c.vosk_batch_recognizer_front_result(self._handle)
+        res = _ffi.string(ptr).decode('utf-8')
+        _c.vosk_batch_recognizer_pop(self._handle)
+        return res
+
+    def FinishStream(self):
+        _c.vosk_batch_recognizer_finish_stream(self._handle)
+
+    def GetPendingChunks(self):
+        return _c.vosk_batch_recognizer_get_pending_chunks(self._handle)

python/vosk/transcriber/cli.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+
+import logging
+import argparse
+
+from datetime import datetime as dt
+from vosk.transcriber.transcriber import Transcriber
+from multiprocessing.dummy import Pool
+from pathlib import Path
+
+
+parser = argparse.ArgumentParser(
+        description = 'Transcribe audio file and save result in selected format')
+parser.add_argument(
+        '-model', type=str,
+        help='model path')
+parser.add_argument(
+        '-list_models', default=False, action='store_true', 
+        help='list available models')
+parser.add_argument(
+        '-list_languages', default=False, action='store_true',
+        help='list available languages')
+parser.add_argument(
+        '-model_name',  default='vosk-model-small-en-us-0.15', type=str,
+        help='select model by name')
+parser.add_argument(
+        '-lang', type=str,
+        help='select model by language')
+parser.add_argument(
+        '-input', type=str,
+        help='audiofile')
+parser.add_argument(
+        '-output', default='', type=str,
+        help='optional output filename path')
+parser.add_argument(
+        '-otype', '--outputtype', default='txt', type=str,
+        help='optional arg output data type')
+parser.add_argument(
+        '--log', default='INFO',
+        help='logging level')
+
+args = parser.parse_args()
+log_level = args.log.upper()
+logging.getLogger().setLevel(log_level)
+logging.info('checking args')
+
+def get_results(inputdata):
+    logging.info('converting audiofile to 16K sampled wav')
+    stream = transcriber.resample_ffmpeg(inputdata[0])
+    logging.info('starting transcription')
+    final_result, tot_samples = transcriber.transcribe(model, stream, args)
+    logging.info('complete')
+    if args.output:
+        with open(inputdata[1], 'w', encoding='utf-8') as fh:
+            fh.write(final_result)
+        logging.info('output written to %s' % (inputdata[1]))
+    else:
+        print(final_result)
+    return final_result, tot_samples
+
+def main(args):
+    global model
+    global transcriber
+    transcriber = Transcriber()
+    transcriber.check_args(args)
+    if args.input:
+        model = transcriber.get_model(args)
+        if Path(args.input).is_dir() and Path(args.output).is_dir():
+            task_list = transcriber.get_task_list(args)
+            with Pool() as pool:
+                for final_result, tot_samples in pool.map(get_results, file_list):
+                    return final_result, tot_samples
+        else:
+            if Path(args.input).is_file():
+                task = (args.input, args.output)
+                final_result, tot_samples = get_results(task)
+            elif not Path(args.input).exists():
+                logging.info('File %s does not exist, please select an existing file' % (args.input))
+                exit(1)
+            elif not Path(args.output).exists():
+                logging.info('Folder %s does not exist, please select an existing folder' % (args.output))
+                exit(1)
+        return final_result, tot_samples
+    else:
+        logging.info('Please specify input file or directory')
+        exit(1)
+
+def get_start_time():
+    start_time = dt.now()
+    return start_time
+
+def get_end_time(start_time):
+    script_time = str(dt.now() - start_time)
+    seconds = script_time[5:8].strip('0')
+    mcseconds = script_time[8:].strip('0')
+    return script_time.strip(':0'), seconds.rstrip('.'), mcseconds
+
+def cli():  # entrypoint used in setup.py
+    start_time = get_start_time()
+    tot_samples = main(args)[1]
+    diff_end_start, sec, mcsec = get_end_time(start_time)
+    logging.info(f'''Execution time: {sec} sec, {mcsec} mcsec; xRT: {format(tot_samples / 16000.0 / float(diff_end_start), '.3f')}''')
+
+if __name__ == "__main__":
+    main()

python/vosk/transcriber/transcriber.py

@@ -0,0 +1,133 @@
+import json
+import subprocess
+import time
+import requests
+import urllib.request
+import zipfile
+import srt
+import datetime
+import os
+import re
+import logging
+
+from vosk import KaldiRecognizer, Model
+from pathlib import Path
+
+
+WORDS_PER_LINE = 7
+MODEL_PRE_URL = 'https://alphacephei.com/vosk/models/'
+MODEL_LIST_URL = MODEL_PRE_URL + 'model-list.json'
+
+class Transcriber:
+
+    def get_result_and_tot_samples(self, rec, process):
+        tot_samples = 0
+        result = []
+        while True:
+            data = process.stdout.read(4000)
+            if len(data) == 0:
+                break
+            if rec.AcceptWaveform(data):
+                tot_samples += len(data)
+                result.append(json.loads(rec.Result())) 
+        result.append(json.loads(rec.FinalResult()))
+        return result, tot_samples
+
+    def transcribe(self, model, process, args):
+        rec = KaldiRecognizer(model, 16000)
+        rec.SetWords(True)
+        result, tot_samples = self.get_result_and_tot_samples(rec, process)
+        final_result = ''
+        if args.outputtype == 'srt':
+            subs = []
+            for i, res in enumerate(result):
+                if not 'result' in res:
+                    continue
+                words = res['result']
+                for j in range(0, len(words), WORDS_PER_LINE):
+                    line = words[j : j + WORDS_PER_LINE]
+                    s = srt.Subtitle(index=len(subs),
+                            content = ' '.join([l['word'] for l in line]),
+                            start=datetime.timedelta(seconds=line[0]['start']),
+                            end=datetime.timedelta(seconds=line[-1]['end']))
+                    subs.append(s)
+            final_result = srt.compose(subs)
+        elif args.outputtype == 'txt':
+            for part in result:
+                final_result += part['text'] + ' '
+        return final_result, tot_samples
+
+    def resample_ffmpeg(self, infile):
+        stream = subprocess.Popen(
+            ['ffmpeg', '-nostdin', '-loglevel', 'quiet', '-i', 
+            infile, 
+            '-ar', '16000','-ac', '1', '-f', 's16le', '-'], 
+            stdout=subprocess.PIPE)
+        return stream
+
+    def get_task_list(self, args):
+        task_list = [(Path(args.input, fn), Path(args.output, Path(fn).stem).with_suffix('.' + args.outputtype)) for fn in os.listdir(args.input)]
+        return task_list
+
+    def list_models(self):
+        response = requests.get(MODEL_LIST_URL)
+        [print(model['name']) for model in response.json()]
+        exit(1)
+
+    def list_languages(self):
+        response = requests.get(MODEL_LIST_URL)
+        list_languages = set([language['lang'] for language in response.json()])
+        print(*list_languages, sep='\n')
+        exit(1)
+
+    def check_args(self, args):
+        if args.list_models == True:
+            self.list_models()
+        elif args.list_languages == True:
+            self.list_languages()
+
+    def get_model_by_name(self, args, models_path):
+        if not Path.is_dir(Path(models_path, args.model_name)):
+            response = requests.get(MODEL_LIST_URL)
+            result = [model['name'] for model in response.json() if model['name'] == args.model_name]
+            if result == []:
+                logging.info('model name "%s" does not exist, request -list_models to see available models' % (args.model_name))
+                exit(1)
+            else:
+                result = result[0]
+        else:
+            result = args.model_name
+        return result
+
+    def get_model_by_lang(self, args, models_path):
+        model_file_list = os.listdir(models_path)
+        model_file = [model for model in model_file_list if re.match(f"vosk-model(-small)?-{args.lang}", model)]
+        if model_file == []:
+            response = requests.get(MODEL_LIST_URL)
+            result = [model['name'] for model in response.json() if model['lang'] == args.lang and model['type'] == 'small' and model['obsolete'] == 'false']
+            if result == []:
+                logging.info('language "%s" does not exist, request -list_languages to see available languages' % (args.lang))
+                exit(1)
+            else:
+                result = result[0]
+        else:
+            result = model_file[0]
+        return result
+
+    def get_model(self, args):
+        models_path = Path.home() / '.cache' / 'vosk'
+        if not Path.is_dir(models_path):
+            Path.mkdir(models_path)
+        if args.lang == None:
+            model_name = self.get_model_by_name(args, models_path)
+        else:
+            model_name = self.get_model_by_lang(args, models_path)
+        model_location = models_path / model_name
+        if not model_location.exists():
+            model_zip = str(model_location) + '.zip'
+            urllib.request.urlretrieve(MODEL_PRE_URL + model_name + '.zip', model_zip)
+            with zipfile.ZipFile(model_zip, 'r') as model_ref:
+                model_ref.extractall(models_path)
+            Path.unlink(Path(model_zip))
+        model = Model(str(model_location))
+        return model

src/Makefile

@@ -1,46 +1,114 @@
+# Locations of the dependencies
 KALDI_ROOT?=$(HOME)/travis/kaldi
 OPENFST_ROOT?=$(KALDI_ROOT)/tools/openfst
 OPENBLAS_ROOT?=$(KALDI_ROOT)/tools/OpenBLAS/install
-EXT?=so
+MKL_ROOT?=/opt/intel/mkl
+CUDA_ROOT?=/usr/local/cuda
+USE_SHARED?=0
+# Math libraries
+HAVE_OPENBLAS_CLAPACK?=1
+HAVE_MKL?=0
+HAVE_ACCELERATE=0
+HAVE_CUDA?=0
+# Compiler
 CXX?=g++
+EXT?=so
+# Extra
+EXTRA_CFLAGS?=
+EXTRA_LDFLAGS?=
+OUTDIR?=.
+
 VOSK_SOURCES= \
-    kaldi_recognizer.cc \
-    language_model.cc \
-    model.cc \
-    spk_model.cc \
-    vosk_api.cc
+	recognizer.cc \
+	language_model.cc \
+	model.cc \
+	spk_model.cc \
+	vosk_api.cc
 
-CFLAGS=-g -O2 -std=c++17 -fPIC -DFST_NO_DYNAMIC_LINKING -I. -I$(KALDI_ROOT)/src -I$(OPENFST_ROOT)/include -I$(OPENBLAS_ROOT)/include
-LIBS= \
-	$(KALDI_ROOT)/src/online2/kaldi-online2.a \
-	$(KALDI_ROOT)/src/decoder/kaldi-decoder.a \
-	$(KALDI_ROOT)/src/ivector/kaldi-ivector.a \
-	$(KALDI_ROOT)/src/gmm/kaldi-gmm.a \
-	$(KALDI_ROOT)/src/nnet3/kaldi-nnet3.a \
-	$(KALDI_ROOT)/src/tree/kaldi-tree.a \
-	$(KALDI_ROOT)/src/feat/kaldi-feat.a \
-	$(KALDI_ROOT)/src/lat/kaldi-lat.a \
-	$(KALDI_ROOT)/src/lm/kaldi-lm.a \
-	$(KALDI_ROOT)/src/hmm/kaldi-hmm.a \
-	$(KALDI_ROOT)/src/transform/kaldi-transform.a \
-	$(KALDI_ROOT)/src/cudamatrix/kaldi-cudamatrix.a \
-	$(KALDI_ROOT)/src/matrix/kaldi-matrix.a \
-	$(KALDI_ROOT)/src/fstext/kaldi-fstext.a \
-	$(KALDI_ROOT)/src/util/kaldi-util.a \
-	$(KALDI_ROOT)/src/base/kaldi-base.a \
-	$(OPENBLAS_ROOT)/lib/libopenblas.a \
-	$(OPENBLAS_ROOT)/lib/liblapack.a \
-	$(OPENBLAS_ROOT)/lib/libblas.a \
-	$(OPENBLAS_ROOT)/lib/libf2c.a \
-	$(OPENFST_ROOT)/lib/libfst.a \
-	$(OPENFST_ROOT)/lib/libfstngram.a
+VOSK_HEADERS= \
+	recognizer.h \
+	language_model.h \
+	model.h \
+	spk_model.h \
+	vosk_api.h
 
-all: libvosk.$(EXT)
+CFLAGS=-g -O3 -std=c++17 -Wno-deprecated-declarations -fPIC -DFST_NO_DYNAMIC_LINKING \
+       -I. -I$(KALDI_ROOT)/src -I$(OPENFST_ROOT)/include $(EXTRA_CFLAGS)
 
-libvosk.$(EXT): $(VOSK_SOURCES:.cc=.o)
-	$(CXX) --shared -s -o $@ $^ $(LIBS) -lm -latomic
+LDFLAGS=
 
-%.o: %.cc
+ifeq ($(USE_SHARED), 0)
+    LIBS = \
+        $(KALDI_ROOT)/src/online2/kaldi-online2.a \
+        $(KALDI_ROOT)/src/decoder/kaldi-decoder.a \
+        $(KALDI_ROOT)/src/ivector/kaldi-ivector.a \
+        $(KALDI_ROOT)/src/gmm/kaldi-gmm.a \
+        $(KALDI_ROOT)/src/tree/kaldi-tree.a \
+        $(KALDI_ROOT)/src/feat/kaldi-feat.a \
+        $(KALDI_ROOT)/src/lat/kaldi-lat.a \
+        $(KALDI_ROOT)/src/lm/kaldi-lm.a \
+        $(KALDI_ROOT)/src/rnnlm/kaldi-rnnlm.a \
+        $(KALDI_ROOT)/src/hmm/kaldi-hmm.a \
+        $(KALDI_ROOT)/src/nnet3/kaldi-nnet3.a \
+        $(KALDI_ROOT)/src/transform/kaldi-transform.a \
+        $(KALDI_ROOT)/src/cudamatrix/kaldi-cudamatrix.a \
+        $(KALDI_ROOT)/src/matrix/kaldi-matrix.a \
+        $(KALDI_ROOT)/src/fstext/kaldi-fstext.a \
+        $(KALDI_ROOT)/src/util/kaldi-util.a \
+        $(KALDI_ROOT)/src/base/kaldi-base.a \
+        $(OPENFST_ROOT)/lib/libfst.a \
+        $(OPENFST_ROOT)/lib/libfstngram.a
+else
+    LDFLAGS += \
+        -L$(KALDI_ROOT)/libs \
+        -lkaldi-online2 -lkaldi-decoder -lkaldi-ivector -lkaldi-gmm -lkaldi-tree \
+        -lkaldi-feat -lkaldi-lat -lkaldi-lm -lkaldi-rnnlm -lkaldi-hmm -lkaldi-nnet3 \
+        -lkaldi-transform -lkaldi-cudamatrix -lkaldi-matrix -lkaldi-fstext \
+        -lkaldi-util -lkaldi-base -lfst -lfstngram
+endif
+
+ifeq ($(HAVE_OPENBLAS_CLAPACK), 1)
+    CFLAGS += -I$(OPENBLAS_ROOT)/include
+    ifeq ($(USE_SHARED), 0)
+        LIBS += \
+            $(OPENBLAS_ROOT)/lib/libopenblas.a \
+            $(OPENBLAS_ROOT)/lib/liblapack.a \
+            $(OPENBLAS_ROOT)/lib/libblas.a \
+            $(OPENBLAS_ROOT)/lib/libf2c.a
+    else
+        LDFLAGS += -lopenblas -llapack -lblas -lf2c
+    endif
+endif
+
+ifeq ($(HAVE_MKL), 1)
+    CFLAGS += -DHAVE_MKL=1 -I$(MKL_ROOT)/include
+    LDFLAGS += -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)
+    LDFLAGS += -framework Accelerate
+endif
+
+ifeq ($(HAVE_CUDA), 1)
+    VOSK_SOURCES += batch_recognizer.cc batch_model.cc
+    VOSK_HEADERS += batch_recognizer.h batch_model.h
+
+    CFLAGS+=-DHAVE_CUDA=1 -I$(CUDA_ROOT)/include
+
+    LIBS := \
+        $(KALDI_ROOT)/src/cudadecoder/kaldi-cudadecoder.a \
+        $(KALDI_ROOT)/src/cudafeat/kaldi-cudafeat.a \
+        $(LIBS)
+
+    LDFLAGS += -L$(CUDA_ROOT)/lib64 -lcuda -lcublas -lcusparse -lcudart -lcurand -lcufft -lcusolver -lnvToolsExt
+endif
+
+all: $(OUTDIR)/libvosk.$(EXT)
+
+$(OUTDIR)/libvosk.$(EXT): $(VOSK_SOURCES:%.cc=$(OUTDIR)/%.o) $(LIBS)
+	$(CXX) --shared -s -o $@ $^ $(LDFLAGS) $(EXTRA_LDFLAGS)
+
+$(OUTDIR)/%.o: %.cc $(VOSK_HEADERS)
 	$(CXX) $(CFLAGS) -c -o $@ $<
 
 clean:

src/batch_model.cc

@@ -0,0 +1,121 @@
+// Copyright 2019-2020 Alpha Cephei Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "batch_model.h"
+
+#include <sys/stat.h>
+
+using namespace fst;
+using namespace kaldi::nnet3;
+using CorrelationID = CudaOnlinePipelineDynamicBatcher::CorrelationID;
+
+BatchModel::BatchModel() {
+    BatchedThreadedNnet3CudaOnlinePipelineConfig batched_decoder_config;
+
+    kaldi::ParseOptions po("something");
+    batched_decoder_config.Register(&po);
+    po.ReadConfigFile("model/conf/model.conf");
+
+    struct stat buffer;
+
+    string nnet3_rxfilename_ = "model/am/final.mdl";
+    string hclg_fst_rxfilename_ = "model/graph/HCLG.fst";
+    string word_syms_rxfilename_ = "model/graph/words.txt";
+    string winfo_rxfilename_ = "model/graph/phones/word_boundary.int";
+    string std_fst_rxfilename_ = "model/rescore/G.fst";
+    string carpa_rxfilename_ = "model/rescore/G.carpa";
+
+    trans_model_ = new kaldi::TransitionModel();
+    nnet_ = new kaldi::nnet3::AmNnetSimple();
+    {
+        bool binary;
+        kaldi::Input ki(nnet3_rxfilename_, &binary);
+        trans_model_->Read(ki.Stream(), binary);
+        nnet_->Read(ki.Stream(), binary);
+        SetBatchnormTestMode(true, &(nnet_->GetNnet()));
+        SetDropoutTestMode(true, &(nnet_->GetNnet()));
+        nnet3::CollapseModel(nnet3::CollapseModelConfig(), &(nnet_->GetNnet()));
+    }
+
+    if (stat(hclg_fst_rxfilename_.c_str(), &buffer) == 0) {
+        KALDI_LOG << "Loading HCLG from " << hclg_fst_rxfilename_;
+        hclg_fst_ = fst::ReadFstKaldiGeneric(hclg_fst_rxfilename_);
+    }
+
+    KALDI_LOG << "Loading words from " << word_syms_rxfilename_;
+    if (!(word_syms_ = fst::SymbolTable::ReadText(word_syms_rxfilename_))) {
+        KALDI_ERR << "Could not read symbol table from file "
+                  << word_syms_rxfilename_;
+    }
+    KALDI_ASSERT(word_syms_);
+
+    if (stat(winfo_rxfilename_.c_str(), &buffer) == 0) {
+        KALDI_LOG << "Loading winfo " << winfo_rxfilename_;
+        kaldi::WordBoundaryInfoNewOpts opts;
+        winfo_ = new kaldi::WordBoundaryInfo(opts, winfo_rxfilename_);
+    }
+
+    batched_decoder_config.num_worker_threads = -1;
+    batched_decoder_config.max_batch_size = 32;
+    batched_decoder_config.num_channels = 600;
+    batched_decoder_config.reset_on_endpoint = true;
+    batched_decoder_config.use_gpu_feature_extraction = true;
+
+    batched_decoder_config.feature_opts.feature_type = "mfcc";
+    batched_decoder_config.feature_opts.mfcc_config = "model/conf/mfcc.conf";
+    batched_decoder_config.feature_opts.ivector_extraction_config = "model/conf/ivector.conf";
+    batched_decoder_config.decoder_opts.max_active = 7000;
+    batched_decoder_config.decoder_opts.default_beam = 13.0;
+    batched_decoder_config.decoder_opts.lattice_beam = 6.0;
+    batched_decoder_config.compute_opts.acoustic_scale = 1.0;
+    batched_decoder_config.compute_opts.frame_subsampling_factor = 3;
+
+    int32 nnet_left_context, nnet_right_context;
+    nnet3::ComputeSimpleNnetContext(nnet_->GetNnet(), &nnet_left_context,
+                                    &nnet_right_context);
+
+    batched_decoder_config.compute_opts.frames_per_chunk = std::max(51, (nnet_right_context + 3 - nnet_right_context % 3));
+
+    cuda_pipeline_ = new BatchedThreadedNnet3CudaOnlinePipeline 
+         (batched_decoder_config, *hclg_fst_, *nnet_, *trans_model_);
+    cuda_pipeline_->SetSymbolTable(*word_syms_);
+
+    CudaOnlinePipelineDynamicBatcherConfig dynamic_batcher_config;
+    dynamic_batcher_ = new CudaOnlinePipelineDynamicBatcher(dynamic_batcher_config,
+                                                            *cuda_pipeline_);
+
+    samples_per_chunk_ = cuda_pipeline_->GetNSampsPerChunk();
+    last_id_ = 0;
+}
+
+uint64_t BatchModel::GetID(BatchRecognizer *recognizer) {
+    return last_id_++;
+}
+
+BatchModel::~BatchModel() {
+
+    delete trans_model_;
+    delete nnet_;
+    delete word_syms_;
+    delete winfo_;
+    delete hclg_fst_;
+
+    delete cuda_pipeline_;
+    delete dynamic_batcher_;
+}
+
+void BatchModel::WaitForCompletion()
+{
+    dynamic_batcher_->WaitForCompletion();
+}

src/batch_model.h

@@ -0,0 +1,68 @@
+// Copyright 2019 Alpha Cephei Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef VOSK_BATCH_MODEL_H
+#define VOSK_BATCH_MODEL_H
+
+#include "base/kaldi-common.h"
+#include "util/common-utils.h"
+#include "fstext/fstext-lib.h"
+#include "fstext/fstext-utils.h"
+#include "decoder/lattice-faster-decoder.h"
+#include "feat/feature-mfcc.h"
+#include "lat/kaldi-lattice.h"
+#include "lat/word-align-lattice.h"
+#include "lat/compose-lattice-pruned.h"
+#include "nnet3/am-nnet-simple.h"
+#include "nnet3/nnet-am-decodable-simple.h"
+#include "nnet3/nnet-utils.h"
+
+#include "cudadecoder/cuda-online-pipeline-dynamic-batcher.h"
+#include "cudadecoder/batched-threaded-nnet3-cuda-online-pipeline.h"
+#include "cudadecoder/batched-threaded-nnet3-cuda-pipeline2.h"
+#include "cudadecoder/cuda-pipeline-common.h"
+
+#include "model.h"
+
+using namespace kaldi;
+using namespace kaldi::cuda_decoder;
+
+class BatchRecognizer;
+
+class BatchModel {
+    public:
+        BatchModel();
+        ~BatchModel();
+
+        uint64_t GetID(BatchRecognizer *recognizer);
+        void WaitForCompletion();
+
+    private:
+        friend class BatchRecognizer;
+
+        kaldi::TransitionModel *trans_model_ = nullptr;
+        kaldi::nnet3::AmNnetSimple *nnet_ = nullptr;
+        const fst::SymbolTable *word_syms_ = nullptr;
+
+        fst::Fst<fst::StdArc> *hclg_fst_ = nullptr;
+        kaldi::WordBoundaryInfo *winfo_ = nullptr;
+
+        BatchedThreadedNnet3CudaOnlinePipeline *cuda_pipeline_ = nullptr;
+        CudaOnlinePipelineDynamicBatcher *dynamic_batcher_ = nullptr;
+
+        int32 samples_per_chunk_;
+        uint64_t last_id_;
+};
+
+#endif /* VOSK_BATCH_MODEL_H */

src/batch_recognizer.cc

@@ -0,0 +1,202 @@
+// Copyright 2019-2020 Alpha Cephei Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "batch_recognizer.h"
+
+#include "fstext/fstext-utils.h"
+#include "lat/sausages.h"
+#include "json.h"
+
+BatchRecognizer::BatchRecognizer(BatchModel *model, float
+                                 sample_frequency) : model_(model), sample_frequency_(sample_frequency),
+                                 initialized_(false), callbacks_set_(false), nlsml_(false) {
+    id_ = model->GetID(this);
+
+
+    resampler_ = new LinearResample(
+        sample_frequency, 16000.0f,
+        std::min(sample_frequency / 2, 16000.0f / 2), 6);
+}
+
+BatchRecognizer::~BatchRecognizer() {
+    delete resampler_;
+    // Drop the ID
+}
+
+void BatchRecognizer::FinishStream()
+{
+    SubVector<BaseFloat> chunk = buffer_.Range(0, buffer_.Dim());
+    model_->dynamic_batcher_->Push(id_, !initialized_, true, chunk);
+}
+
+void BatchRecognizer::PushLattice(CompactLattice &clat, BaseFloat offset)
+{
+    fst::ScaleLattice(fst::GraphLatticeScale(0.9), &clat);
+
+    CompactLattice aligned_lat;
+    WordAlignLattice(clat, *model_->trans_model_, *model_->winfo_, 0, &aligned_lat);
+
+    MinimumBayesRisk mbr(aligned_lat);
+    const vector<BaseFloat> &conf = mbr.GetOneBestConfidences();
+    const vector<int32> &words = mbr.GetOneBest();
+    const vector<pair<BaseFloat, BaseFloat> > &times =
+          mbr.GetOneBestTimes();
+
+    int size = words.size();
+
+    if (nlsml_) {
+
+        std::stringstream ss;
+        std::stringstream text;
+        ss << "<?xml version=\"1.0\"?>\n";
+        ss << "<result grammar=\"default\">\n";
+        BaseFloat confidence = 0.0;
+        for (int i = 0; i < size; i++) {
+            if (i) {
+                text << " ";
+            }
+            confidence += conf[i];
+            text << model_->word_syms_->Find(words[i]);
+        }
+        confidence /= size;
+
+        ss << "<interpretation grammar=\"default\" confidence=\"" << confidence << "\">\n";
+        ss << "<input mode=\"speech\">" << text.str() << "</input>\n";
+        ss << "<instance>" << text.str() << "</instance>\n";
+        ss << "</interpretation>\n";
+        ss << "</result>\n";
+
+        results_.push(ss.str());
+
+    } else {
+        json::JSON obj;
+        stringstream text;
+
+        // Create JSON object
+        for (int i = 0; i < size; i++) {
+            json::JSON word;
+
+            word["word"] = model_->word_syms_->Find(words[i]);
+            word["start"] = round(times[i].first) * 0.03 + offset;
+            word["end"] = round(times[i].second) * 0.03 + offset;
+            word["conf"] = conf[i];
+            obj["result"].append(word);
+
+            if (i) {
+                text << " ";
+            }
+            text << model_->word_syms_->Find(words[i]);
+        }
+        obj["text"] = text.str();
+
+//      KALDI_LOG << "Result " << id << " " << obj.dump();
+
+        results_.push(obj.dump());
+    }
+}
+
+void BatchRecognizer::SetNLSML(bool nlsml)
+{
+    nlsml_ = nlsml;
+}
+
+
+void BatchRecognizer::AcceptWaveform(const char *data, int len)
+{
+    uint64_t id = id_;
+    if (!callbacks_set_) {
+        // Define the callback for results.
+#if 0
+         model_->cuda_pipeline_->SetBestPathCallback(
+          id,
+          [&, id](const std::string &str, bool partial,
+                       bool endpoint_detected) {
+              if (partial) {
+                  KALDI_LOG << "id #" << id << " [partial] : " << str << ":";
+              }
+
+              if (endpoint_detected) {
+                  KALDI_LOG << "id #" << id << " [endpoint detected]";
+              }
+
+              if (!partial) {
+                  KALDI_LOG << "id #" << id << " : " << str;
+              }
+            });
+#endif
+        model_->cuda_pipeline_->SetLatticeCallback(
+          id,
+          [&, id](SegmentedLatticeCallbackParams& params) {
+              if (params.results.empty()) {
+                  KALDI_WARN << "Empty result for callback";
+                  return;
+              }
+              CompactLattice *clat = params.results[0].GetLatticeResult();
+              BaseFloat offset = params.results[0].GetTimeOffsetSeconds();
+              PushLattice(*clat, offset);
+          },
+          CudaPipelineResult::RESULT_TYPE_LATTICE);
+        callbacks_set_ = true;
+    }
+
+    Vector<BaseFloat> input_wave(len / 2);
+    for (int i = 0; i < len / 2; i++)
+        input_wave(i) = *(((short *)data) + i);
+
+    Vector<BaseFloat> resampled_wave;
+    resampler_->Resample(input_wave, true, &resampled_wave);
+
+    int32 end = buffer_.Dim();
+    buffer_.Resize(end + resampled_wave.Dim(), kCopyData);
+    buffer_.Range(end, resampled_wave.Dim()).CopyFromVec(resampled_wave);
+
+    // Pick chunks and submit them to the batcher
+    int32 i = 0;
+    while (i + model_->samples_per_chunk_ <= buffer_.Dim()) {
+        model_->dynamic_batcher_->Push(id_, !initialized_, false,
+                                       buffer_.Range(i, model_->samples_per_chunk_));
+        initialized_ = true;
+        i += model_->samples_per_chunk_;
+    }
+
+    // Keep remaining data
+    if (i > 0) {
+        int32 tail = buffer_.Dim() - i;
+        for (int j = 0; j < tail; j++) {
+            buffer_(j) = buffer_(i + j);
+        }
+        buffer_.Resize(tail, kCopyData);
+    }
+}
+
+const char* BatchRecognizer::FrontResult()
+{
+    if (results_.empty()) {
+        return "";
+    }
+    return results_.front().c_str();
+}
+
+void BatchRecognizer::Pop()
+{
+    if (results_.empty()) {
+        return;
+    }
+    results_.pop();
+}
+
+int BatchRecognizer::GetNumPendingChunks()
+{
+    return model_->dynamic_batcher_->GetNumPendingChunks(id_);
+}

src/batch_recognizer.h

@@ -0,0 +1,55 @@
+// Copyright 2019 Alpha Cephei Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef VOSK_BATCH_RECOGNIZER_H
+#define VOSK_BATCH_RECOGNIZER_H
+
+#include "base/kaldi-common.h"
+#include "util/common-utils.h"
+#include "feat/resample.h"
+
+#include <queue>
+
+#include "batch_model.h"
+
+using namespace kaldi;
+
+class BatchRecognizer {
+    public:
+        BatchRecognizer(BatchModel *model, float sample_frequency);
+        ~BatchRecognizer();
+
+        void AcceptWaveform(const char *data, int len);
+        int GetNumPendingChunks();
+        const char *FrontResult();
+        void Pop();
+        void FinishStream();
+        void SetNLSML(bool nlsml);
+
+    private:
+
+        void PushLattice(CompactLattice &clat, BaseFloat offset);
+
+        BatchModel *model_;
+        uint64_t id_;
+        bool initialized_;
+        bool callbacks_set_;
+        bool nlsml_;
+        float sample_frequency_;
+        std::queue<std::string> results_;
+        LinearResample *resampler_;
+        kaldi::Vector<BaseFloat> buffer_;
+};
+
+#endif /* VOSK_BATCH_RECOGNIZER_H */

src/json.h

@@ -424,7 +424,7 @@ class JSON
         Class Type = Class::Null;
 };
 
-JSON Array() {
+inline JSON Array() {
     return JSON::Make( JSON::Class::Array );
 }
 
@@ -435,11 +435,11 @@ JSON Array( T... args ) {
     return arr;
 }
 
-JSON Object() {
+inline JSON Object() {
     return JSON::Make( JSON::Class::Object );
 }
 
-std::ostream& operator<<( std::ostream &os, const JSON &json ) {
+inline std::ostream& operator<<( std::ostream &os, const JSON &json ) {
     os << json.dump();
     return os;
 }
@@ -647,7 +647,7 @@ namespace {
     }
 }
 
-JSON JSON::Load( const string &str ) {
+inline JSON JSON::Load( const string &str ) {
     size_t offset = 0;
     return parse_next( str, offset );
 }

src/kaldi_recognizer.cc

@@ -1,542 +0,0 @@
-// Copyright 2019-2020 Alpha Cephei Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//       http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "kaldi_recognizer.h"
-#include "json.h"
-#include "fstext/fstext-utils.h"
-#include "lat/sausages.h"
-#include "language_model.h"
-
-using namespace fst;
-using namespace kaldi::nnet3;
-
-KaldiRecognizer::KaldiRecognizer(Model *model, float sample_frequency) : model_(model), spk_model_(0), sample_frequency_(sample_frequency) {
-
-    model_->Ref();
-
-    feature_pipeline_ = new kaldi::OnlineNnet2FeaturePipeline (model_->feature_info_);
-    silence_weighting_ = new kaldi::OnlineSilenceWeighting(*model_->trans_model_, model_->feature_info_.silence_weighting_config, 3);
-
-    g_fst_ = NULL;
-    decode_fst_ = NULL;
-
-    if (!model_->hclg_fst_) {
-        if (model_->hcl_fst_ && model_->g_fst_) {
-            decode_fst_ = LookaheadComposeFst(*model_->hcl_fst_, *model_->g_fst_, model_->disambig_);
-        } else {
-            KALDI_ERR << "Can't create decoding graph";
-        }
-    }
-
-    decoder_ = new kaldi::SingleUtteranceNnet3Decoder(model_->nnet3_decoding_config_,
-            *model_->trans_model_,
-            *model_->decodable_info_,
-            model_->hclg_fst_ ? *model_->hclg_fst_ : *decode_fst_,
-            feature_pipeline_);
-
-    spk_feature_ = NULL;
-
-    InitState();
-    InitRescoring();
-}
-
-KaldiRecognizer::KaldiRecognizer(Model *model, float sample_frequency, char const *grammar) : model_(model), spk_model_(0), sample_frequency_(sample_frequency)
-{
-    model_->Ref();
-
-    feature_pipeline_ = new kaldi::OnlineNnet2FeaturePipeline (model_->feature_info_);
-    silence_weighting_ = new kaldi::OnlineSilenceWeighting(*model_->trans_model_, model_->feature_info_.silence_weighting_config, 3);
-
-    if (model_->hcl_fst_) {
-        json::JSON obj;
-        obj = json::JSON::Load(grammar);
-
-        if (obj.length() <= 0) {
-            KALDI_WARN << "Expecting array of strings, got: '" << grammar << "'";
-        } else {
-            KALDI_LOG << obj;
-
-            LanguageModelOptions opts;
-
-            opts.ngram_order = 2;
-            opts.discount = 0.5;
-
-            LanguageModelEstimator estimator(opts);
-            for (int i = 0; i < obj.length(); i++) {
-                bool ok;
-                string line = obj[i].ToString(ok);
-                if (!ok) {
-                    KALDI_ERR << "Expecting array of strings, got: '" << obj << "'";
-                }
-
-                std::vector<int32> sentence;
-                stringstream ss(line);
-                string token;
-                while (getline(ss, token, ' ')) {
-                    int32 id = model_->word_syms_->Find(token);
-                    if (id == kNoSymbol) {
-                        KALDI_WARN << "Ignoring word missing in vocabulary: '" << token << "'";
-                    } else {
-                        sentence.push_back(id);
-                    }
-                }
-                estimator.AddCounts(sentence);
-            }
-            g_fst_ = new StdVectorFst();
-            estimator.Estimate(g_fst_);
-
-            decode_fst_ = LookaheadComposeFst(*model_->hcl_fst_, *g_fst_, model_->disambig_);
-        }
-    } else {
-        decode_fst_ = NULL;
-        KALDI_WARN << "Runtime graphs are not supported by this model";
-    }
-
-    decoder_ = new kaldi::SingleUtteranceNnet3Decoder(model_->nnet3_decoding_config_,
-            *model_->trans_model_,
-            *model_->decodable_info_,
-            model_->hclg_fst_ ? *model_->hclg_fst_ : *decode_fst_,
-            feature_pipeline_);
-
-    spk_feature_ = NULL;
-
-    InitState();
-    InitRescoring();
-}
-
-KaldiRecognizer::KaldiRecognizer(Model *model, SpkModel *spk_model, float sample_frequency) : model_(model), spk_model_(spk_model), sample_frequency_(sample_frequency) {
-
-    model_->Ref();
-    spk_model->Ref();
-
-    feature_pipeline_ = new kaldi::OnlineNnet2FeaturePipeline (model_->feature_info_);
-    silence_weighting_ = new kaldi::OnlineSilenceWeighting(*model_->trans_model_, model_->feature_info_.silence_weighting_config, 3);
-
-    decode_fst_ = NULL;
-    g_fst_ = NULL;
-
-    if (!model_->hclg_fst_) {
-        if (model_->hcl_fst_ && model_->g_fst_) {
-            decode_fst_ = LookaheadComposeFst(*model_->hcl_fst_, *model_->g_fst_, model_->disambig_);
-        } else {
-            KALDI_ERR << "Can't create decoding graph";
-        }
-    }
-
-    decoder_ = new kaldi::SingleUtteranceNnet3Decoder(model_->nnet3_decoding_config_,
-            *model_->trans_model_,
-            *model_->decodable_info_,
-            model_->hclg_fst_ ? *model_->hclg_fst_ : *decode_fst_,
-            feature_pipeline_);
-
-    spk_feature_ = new OnlineMfcc(spk_model_->spkvector_mfcc_opts);
-
-    InitState();
-    InitRescoring();
-}
-
-KaldiRecognizer::~KaldiRecognizer() {
-    delete decoder_;
-    delete feature_pipeline_;
-    delete silence_weighting_;
-    delete g_fst_;
-    delete decode_fst_;
-    delete spk_feature_;
-    delete lm_fst_;
-
-    model_->Unref();
-    if (spk_model_)
-         spk_model_->Unref();
-}
-
-void KaldiRecognizer::InitState()
-{
-    frame_offset_ = 0;
-    samples_processed_ = 0;
-    samples_round_start_ = 0;
-
-    state_ = RECOGNIZER_INITIALIZED;
-}
-
-void KaldiRecognizer::InitRescoring()
-{
-    if (model_->std_lm_fst_) {
-        fst::CacheOptions cache_opts(true, 50000);
-        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);
-    } else {
-        lm_fst_ = NULL;
-    }
-}
-
-void KaldiRecognizer::CleanUp()
-{
-    delete silence_weighting_;
-    silence_weighting_ = new kaldi::OnlineSilenceWeighting(*model_->trans_model_, model_->feature_info_.silence_weighting_config, 3);
-
-    if (decoder_)
-       frame_offset_ += decoder_->NumFramesDecoded();
-
-    // Each 10 minutes we drop the pipeline to save frontend memory in continuous processing
-    // here we drop few frames remaining in the feature pipeline but hope it will not
-    // cause a huge accuracy drop since it happens not very frequently.
-
-    // Also restart if we retrieved final result already
-
-    if (decoder_ == NULL || state_ == RECOGNIZER_FINALIZED || frame_offset_ > 20000) {
-        samples_round_start_ += samples_processed_;
-        samples_processed_ = 0;
-        frame_offset_ = 0;
-
-        delete decoder_;
-        delete feature_pipeline_;
-
-        feature_pipeline_ = new kaldi::OnlineNnet2FeaturePipeline (model_->feature_info_);
-        decoder_ = new kaldi::SingleUtteranceNnet3Decoder(model_->nnet3_decoding_config_,
-            *model_->trans_model_,
-            *model_->decodable_info_,
-            model_->hclg_fst_ ? *model_->hclg_fst_ : *decode_fst_,
-            feature_pipeline_);
-
-        if (spk_model_) {
-            delete spk_feature_;
-            spk_feature_ = new OnlineMfcc(spk_model_->spkvector_mfcc_opts);
-        }
-    } else {
-        decoder_->InitDecoding(frame_offset_);
-    }
-}
-
-void KaldiRecognizer::UpdateSilenceWeights()
-{
-    if (silence_weighting_->Active() && feature_pipeline_->NumFramesReady() > 0 &&
-        feature_pipeline_->IvectorFeature() != NULL) {
-        vector<pair<int32, BaseFloat> > delta_weights;
-        silence_weighting_->ComputeCurrentTraceback(decoder_->Decoder());
-        silence_weighting_->GetDeltaWeights(feature_pipeline_->NumFramesReady(),
-                                          frame_offset_ * 3,
-                                          &delta_weights);
-        feature_pipeline_->UpdateFrameWeights(delta_weights);
-    }
-}
-
-bool KaldiRecognizer::AcceptWaveform(const char *data, int len)
-{
-    Vector<BaseFloat> wave;
-    wave.Resize(len / 2, kUndefined);
-    for (int i = 0; i < len / 2; i++)
-        wave(i) = *(((short *)data) + i);
-    return AcceptWaveform(wave);
-}
-
-bool KaldiRecognizer::AcceptWaveform(const short *sdata, int len)
-{
-    Vector<BaseFloat> wave;
-    wave.Resize(len, kUndefined);
-    for (int i = 0; i < len; i++)
-        wave(i) = sdata[i];
-    return AcceptWaveform(wave);
-}
-
-bool KaldiRecognizer::AcceptWaveform(const float *fdata, int len)
-{
-    Vector<BaseFloat> wave;
-    wave.Resize(len, kUndefined);
-    for (int i = 0; i < len; i++)
-        wave(i) = fdata[i];
-    return AcceptWaveform(wave);
-}
-
-bool KaldiRecognizer::AcceptWaveform(Vector<BaseFloat> &wdata)
-{
-    // Cleanup if we finalized previous utterance or the whole feature pipeline
-    if (!(state_ == RECOGNIZER_RUNNING || state_ == RECOGNIZER_INITIALIZED)) {
-        CleanUp();
-    }
-    state_ = RECOGNIZER_RUNNING;
-
-    int step = static_cast<int>(sample_frequency_ * 0.2);
-    for (int i = 0; i < wdata.Dim(); i+= step) {
-        SubVector<BaseFloat> r = wdata.Range(i, std::min(step, wdata.Dim() - i));
-        feature_pipeline_->AcceptWaveform(sample_frequency_, r);
-        UpdateSilenceWeights();
-        decoder_->AdvanceDecoding();
-    }
-    samples_processed_ += wdata.Dim();
-
-    if (spk_feature_) {
-        spk_feature_->AcceptWaveform(sample_frequency_, wdata);
-    }
-
-    if (decoder_->EndpointDetected(model_->endpoint_config_)) {
-        return true;
-    }
-
-    return false;
-}
-
-// Computes an xvector from a chunk of speech features.
-static void RunNnetComputation(const MatrixBase<BaseFloat> &features,
-    const nnet3::Nnet &nnet, nnet3::CachingOptimizingCompiler *compiler,
-    Vector<BaseFloat> *xvector) 
-{
-    nnet3::ComputationRequest request;
-    request.need_model_derivative = false;
-    request.store_component_stats = false;
-    request.inputs.push_back(
-    nnet3::IoSpecification("input", 0, features.NumRows()));
-    nnet3::IoSpecification output_spec;
-    output_spec.name = "output";
-    output_spec.has_deriv = false;
-    output_spec.indexes.resize(1);
-    request.outputs.resize(1);
-    request.outputs[0].Swap(&output_spec);
-    shared_ptr<const nnet3::NnetComputation> computation = compiler->Compile(request);
-    nnet3::Nnet *nnet_to_update = NULL;  // we're not doing any update.
-    nnet3::NnetComputer computer(nnet3::NnetComputeOptions(), *computation,
-                    nnet, nnet_to_update);
-    CuMatrix<BaseFloat> input_feats_cu(features);
-    computer.AcceptInput("input", &input_feats_cu);
-    computer.Run();
-    CuMatrix<BaseFloat> cu_output;
-    computer.GetOutputDestructive("output", &cu_output);
-    xvector->Resize(cu_output.NumCols());
-    xvector->CopyFromVec(cu_output.Row(0));
-}
-
-#define MIN_SPK_FEATS 50
-
-bool KaldiRecognizer::GetSpkVector(Vector<BaseFloat> &out_xvector, int *num_spk_frames)
-{
-    vector<int32> nonsilence_frames;
-    if (silence_weighting_->Active() && feature_pipeline_->NumFramesReady() > 0) {
-        silence_weighting_->ComputeCurrentTraceback(decoder_->Decoder(), true);
-        silence_weighting_->GetNonsilenceFrames(feature_pipeline_->NumFramesReady(),
-                                          frame_offset_ * 3,
-                                          &nonsilence_frames);
-    }
-
-    int num_frames = spk_feature_->NumFramesReady() - frame_offset_ * 3;
-    Matrix<BaseFloat> mfcc(num_frames, spk_feature_->Dim());
-
-    // Not very efficient, would be nice to have faster search
-    int num_nonsilence_frames = 0;
-    Vector<BaseFloat> feat(spk_feature_->Dim());
-
-    for (int i = 0; i < num_frames; ++i) {
-       if (std::find(nonsilence_frames.begin(),
-                     nonsilence_frames.end(), i / 3) == nonsilence_frames.end()) {
-           continue;
-       }
-
-       spk_feature_->GetFrame(i + frame_offset_ * 3, &feat);
-       mfcc.CopyRowFromVec(feat, num_nonsilence_frames);
-       num_nonsilence_frames++;
-    }
-
-    *num_spk_frames = num_nonsilence_frames;
-
-    // Don't extract vector if not enough data
-    if (num_nonsilence_frames < MIN_SPK_FEATS) {
-        return false;
-    }
-
-    mfcc.Resize(num_nonsilence_frames, spk_feature_->Dim(), kCopyData);
-
-    SlidingWindowCmnOptions cmvn_opts;
-    cmvn_opts.center = true;
-    cmvn_opts.cmn_window = 300;
-    Matrix<BaseFloat> features(mfcc.NumRows(), mfcc.NumCols(), kUndefined);
-    SlidingWindowCmn(cmvn_opts, mfcc, &features);
-
-    nnet3::NnetSimpleComputationOptions opts;
-    nnet3::CachingOptimizingCompilerOptions compiler_config;
-    nnet3::CachingOptimizingCompiler compiler(spk_model_->speaker_nnet, opts.optimize_config, compiler_config);
-
-    Vector<BaseFloat> xvector;
-    RunNnetComputation(features, spk_model_->speaker_nnet, &compiler, &xvector);
-
-    // Whiten the vector with global mean and transform and normalize mean
-    xvector.AddVec(-1.0, spk_model_->mean);
-
-    out_xvector.Resize(spk_model_->transform.NumRows(), kSetZero);
-    out_xvector.AddMatVec(1.0, spk_model_->transform, kNoTrans, xvector, 0.0);
-
-    BaseFloat norm = out_xvector.Norm(2.0);
-    BaseFloat ratio = norm / sqrt(out_xvector.Dim()); // how much larger it is
-                                                  // than it would be, in
-                                                  // expectation, if normally
-    out_xvector.Scale(1.0 / ratio);
-
-    return true;
-}
-
-const char* KaldiRecognizer::GetResult()
-{
-    if (decoder_->NumFramesDecoded() == 0) {
-        return StoreReturn("{\"text\": \"\"}");
-    }
-
-    kaldi::CompactLattice clat;
-    decoder_->GetLattice(true, &clat);
-
-    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);
-        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>());
-
-        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, &clat);
-    }
-
-    fst::ScaleLattice(fst::GraphLatticeScale(0.9), &clat); // Apply rescoring weight
-    CompactLattice aligned_lat;
-    if (model_->winfo_) {
-        WordAlignLattice(clat, *model_->trans_model_, *model_->winfo_, 0, &aligned_lat);
-    } else {
-        aligned_lat = clat;
-    }
-
-    MinimumBayesRisk mbr(aligned_lat);
-    const vector<BaseFloat> &conf = mbr.GetOneBestConfidences();
-    const vector<int32> &words = mbr.GetOneBest();
-    const vector<pair<BaseFloat, BaseFloat> > &times =
-          mbr.GetOneBestTimes();
-
-    int size = words.size();
-
-    json::JSON obj;
-    stringstream text;
-
-    // Create JSON object
-    for (int i = 0; i < size; i++) {
-        json::JSON word;
-        word["word"] = model_->word_syms_->Find(words[i]);
-        word["start"] = samples_round_start_ / sample_frequency_ + (frame_offset_ + times[i].first) * 0.03;
-        word["end"] = samples_round_start_ / sample_frequency_ + (frame_offset_ + times[i].second) * 0.03;
-        word["conf"] = conf[i];
-        obj["result"].append(word);
-
-        if (i) {
-            text << " ";
-        }
-        text << model_->word_syms_->Find(words[i]);
-    }
-    obj["text"] = text.str();
-
-    if (spk_model_) {
-        Vector<BaseFloat> xvector;
-        int num_spk_frames;
-        if (GetSpkVector(xvector, &num_spk_frames)) {
-            for (int i = 0; i < xvector.Dim(); i++) {
-                obj["spk"].append(xvector(i));
-            }
-            obj["spk_frames"] = num_spk_frames;
-        }
-    }
-
-    return StoreReturn(obj.dump());
-}
-
-
-const char* KaldiRecognizer::PartialResult()
-{
-    if (state_ != RECOGNIZER_RUNNING) {
-        return StoreReturn("{\"text\": \"\"}");
-    }
-
-    json::JSON res;
-
-    if (decoder_->NumFramesDecoded() == 0) {
-        res["partial"] = "";
-        return StoreReturn(res.dump());
-    }
-
-    kaldi::Lattice lat;
-    decoder_->GetBestPath(false, &lat);
-    vector<kaldi::int32> alignment, words;
-    LatticeWeight weight;
-    GetLinearSymbolSequence(lat, &alignment, &words, &weight);
-
-    ostringstream text;
-    for (size_t i = 0; i < words.size(); i++) {
-        if (i) {
-            text << " ";
-        }
-        text << model_->word_syms_->Find(words[i]);
-    }
-    res["partial"] = text.str();
-
-    return StoreReturn(res.dump());
-}
-
-const char* KaldiRecognizer::Result()
-{
-    if (state_ != RECOGNIZER_RUNNING) {
-        return StoreReturn("{\"text\": \"\"}");
-    }
-    decoder_->FinalizeDecoding();
-    state_ = RECOGNIZER_ENDPOINT;
-    return GetResult();
-}
-
-const char* KaldiRecognizer::FinalResult()
-{
-    if (state_ != RECOGNIZER_RUNNING) {
-        return StoreReturn("{\"text\": \"\"}");
-    }
-
-    feature_pipeline_->InputFinished();
-    UpdateSilenceWeights();
-    decoder_->AdvanceDecoding();
-    decoder_->FinalizeDecoding();
-    state_ = RECOGNIZER_FINALIZED;
-    GetResult();
-
-    // Free some memory while we are finalized, next
-    // iteration will reinitialize them anyway
-    delete decoder_;
-    delete feature_pipeline_;
-    delete silence_weighting_;
-    delete spk_feature_;
-
-    feature_pipeline_ = NULL;
-    silence_weighting_ = NULL;
-    decoder_ = NULL;
-    spk_feature_ = NULL;
-
-    return last_result_.c_str();
-}
-
-// Store result in recognizer and return as const string
-const char *KaldiRecognizer::StoreReturn(const string &res)
-{
-    last_result_ = res;
-    return last_result_.c_str();
-}

src/model.cc

@@ -1,4 +1,4 @@
-// Copyright 2019 Alpha Cephei Inc.
+// Copyright 2019-2021 Alpha Cephei Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -108,15 +108,22 @@ Model::Model(const char *model_path) : model_path_str_(model_path) {
     SetLogHandler(KaldiLogHandler);
 
     struct stat buffer;
-    string am_path = model_path_str_ + "/am/final.mdl";
-    if (stat(am_path.c_str(), &buffer) == 0) {
-         ConfigureV2();
+    string am_v2_path = model_path_str_ + "/am/final.mdl";
+    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(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) {
+        ConfigureV1();
+        ReadDataFiles();
     } else {
-         ConfigureV1();
+        KALDI_ERR << "Folder '" << model_path_str_ << "' does not contain model files. " <<
+                     "Make sure you specified the model path properly in Model constructor. " <<
+                     "If you are not sure about relative path, use absolute path specification.";
     }
 
-    ReadDataFiles();
-
     ref_cnt_ = 1;
 }
 
@@ -161,7 +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";
 }
 
 void Model::ConfigureV2()
@@ -184,7 +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";
 }
 
 void Model::ReadDataFiles()
@@ -196,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;
@@ -214,9 +241,9 @@ void Model::ReadDataFiles()
         SetDropoutTestMode(true, &(nnet_->GetNnet()));
         nnet3::CollapseModel(nnet3::CollapseModelConfig(), &(nnet_->GetNnet()));
     }
+
     decodable_info_ = new nnet3::DecodableNnetSimpleLoopedInfo(decodable_opts_,
                                                                nnet_);
-
     if (stat(final_ie_rxfilename_.c_str(), &buffer) == 0) {
         KALDI_LOG << "Loading i-vector extractor from " << final_ie_rxfilename_;
 
@@ -241,21 +268,23 @@ void Model::ReadDataFiles()
         ReadKaldiObject(global_cmvn_stats_rxfilename_, &feature_info_.global_cmvn_stats);
     }
 
+    if (stat(pitch_conf_rxfilename_.c_str(), &buffer) == 0) {
+        KALDI_LOG << "Using pitch in feature pipeline";
+        feature_info_.add_pitch = true;
+        ReadConfigsFromFile(pitch_conf_rxfilename_,
+                            &feature_info_.pitch_opts, &feature_info_.pitch_process_opts);
+    }
 
     if (stat(hclg_fst_rxfilename_.c_str(), &buffer) == 0) {
         KALDI_LOG << "Loading HCLG from " << hclg_fst_rxfilename_;
         hclg_fst_ = fst::ReadFstKaldiGeneric(hclg_fst_rxfilename_);
-        hcl_fst_ = NULL;
-        g_fst_ = NULL;
     } else {
         KALDI_LOG << "Loading HCL and G from " << hcl_fst_rxfilename_ << " " << g_fst_rxfilename_;
-        hclg_fst_ = NULL;
         hcl_fst_ = fst::StdFst::Read(hcl_fst_rxfilename_);
         g_fst_ = fst::StdFst::Read(g_fst_rxfilename_);
         ReadIntegerVectorSimple(disambig_rxfilename_, &disambig_);
     }
 
-    word_syms_ = NULL;
     if (hclg_fst_ && hclg_fst_->OutputSymbols()) {
         word_syms_ = hclg_fst_->OutputSymbols();
     } else if (g_fst_ && g_fst_->OutputSymbols()) {
@@ -266,6 +295,7 @@ void Model::ReadDataFiles()
         if (!(word_syms_ = fst::SymbolTable::ReadText(word_syms_rxfilename_)))
             KALDI_ERR << "Could not read symbol table from file "
                       << word_syms_rxfilename_;
+        word_syms_loaded_ = word_syms_;
     }
     KALDI_ASSERT(word_syms_);
 
@@ -273,34 +303,53 @@ void Model::ReadDataFiles()
         KALDI_LOG << "Loading winfo " << winfo_rxfilename_;
         kaldi::WordBoundaryInfoNewOpts opts;
         winfo_ = new kaldi::WordBoundaryInfo(opts, winfo_rxfilename_);
-    } else {
-        winfo_ = NULL;
     }
 
     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_;
-        std_lm_fst_ = fst::ReadFstKaldi(std_fst_rxfilename_);
-        fst::Project(std_lm_fst_, fst::PROJECT_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_);
-    } else {
-        std_lm_fst_ = NULL;
     }
+
+    // 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);
+        Matrix<BaseFloat> feature_embedding_mat;
+        ReadKaldiObject(rnnlm_feat_embedding_rxfilename_, &feature_embedding_mat);
+        SparseMatrix<BaseFloat> word_feature_mat;
+        {
+           Input input(rnnlm_word_feats_rxfilename_);
+           int32 feature_dim = feature_embedding_mat.NumRows();
+           rnnlm::ReadSparseWordFeatures(input.Stream(), feature_dim,
+                             &word_feature_mat);
+        }
+        Matrix<BaseFloat> wm(word_feature_mat.NumRows(), feature_embedding_mat.NumCols());
+        wm.AddSmatMat(1.0, word_feature_mat, kNoTrans,
+                      feature_embedding_mat, 0.0);
+        word_embedding_mat.Resize(wm.NumRows(), wm.NumCols(), kUndefined);
+        word_embedding_mat.CopyFromMat(wm);
+
+        ReadConfigFromFile(rnnlm_config_rxfilename_, &rnnlm_compute_opts);
+
+        rnnlm_enabled_ = true;
+    }
+
 }
 
 void Model::Ref() 
 {
-    ref_cnt_++;
+    std::atomic_fetch_add_explicit(&ref_cnt_, 1, std::memory_order_relaxed);
 }
 
 void Model::Unref() 
 {
-    ref_cnt_--;
-    if (ref_cnt_ == 0) {
-        delete this;
+    if (std::atomic_fetch_sub_explicit(&ref_cnt_, 1, std::memory_order_release) == 1) {
+         std::atomic_thread_fence(std::memory_order_acquire);
+         delete this;
     }
 }
 
@@ -316,8 +365,11 @@ Model::~Model() {
     delete decodable_info_;
     delete trans_model_;
     delete nnet_;
+    if (word_syms_loaded_)
+        delete word_syms_;
     delete winfo_;
     delete hclg_fst_;
     delete hcl_fst_;
     delete g_fst_;
+    delete graph_lm_fst_;
 }

src/model.h

@@ -1,4 +1,4 @@
-// Copyright 2019 Alpha Cephei Inc.
+// Copyright 2019-2021 Alpha Cephei Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@
 #include "online2/onlinebin-util.h"
 #include "online2/online-timing.h"
 #include "online2/online-endpoint.h"
-#include "online2/online-nnet3-decoding.h"
+#include "online2/online-nnet3-incremental-decoding.h"
 #include "online2/online-feature-pipeline.h"
 #include "lat/lattice-functions.h"
 #include "lat/sausages.h"
@@ -30,11 +30,13 @@
 #include "util/parse-options.h"
 #include "nnet3/nnet-utils.h"
 #include "rnnlm/rnnlm-utils.h"
+#include "rnnlm/rnnlm-lattice-rescoring.h"
+#include <atomic>
 
 using namespace kaldi;
 using namespace std;
 
-class KaldiRecognizer;
+class Recognizer;
 
 class Model {
 
@@ -50,7 +52,7 @@ protected:
     void ConfigureV2();
     void ReadDataFiles();
 
-    friend class KaldiRecognizer;
+    friend class Recognizer;
 
     string model_path_str_;
     string nnet3_rxfilename_;
@@ -64,28 +66,41 @@ 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_rxfilename_;
 
     kaldi::OnlineEndpointConfig endpoint_config_;
-    kaldi::LatticeFasterDecoderConfig nnet3_decoding_config_;
+    kaldi::LatticeIncrementalDecoderConfig nnet3_decoding_config_;
     kaldi::nnet3::NnetSimpleLoopedComputationOptions decodable_opts_;
     kaldi::OnlineNnet2FeaturePipelineInfo feature_info_;
 
-    kaldi::nnet3::DecodableNnetSimpleLoopedInfo *decodable_info_;
-    kaldi::TransitionModel *trans_model_;
-    kaldi::nnet3::AmNnetSimple *nnet_;
-    const fst::SymbolTable *word_syms_;
-    kaldi::WordBoundaryInfo *winfo_;
+    kaldi::nnet3::DecodableNnetSimpleLoopedInfo *decodable_info_ = nullptr;
+    kaldi::TransitionModel *trans_model_ = nullptr;
+    kaldi::nnet3::AmNnetSimple *nnet_ = nullptr;
+    const fst::SymbolTable *word_syms_ = nullptr;
+    bool word_syms_loaded_ = false;
+    kaldi::WordBoundaryInfo *winfo_ = nullptr;
     vector<int32> disambig_;
 
-    fst::Fst<fst::StdArc> *hclg_fst_;
-    fst::Fst<fst::StdArc> *hcl_fst_;
-    fst::Fst<fst::StdArc> *g_fst_;
+    fst::Fst<fst::StdArc> *hclg_fst_ = nullptr;
+    fst::Fst<fst::StdArc> *hcl_fst_ = nullptr;
+    fst::Fst<fst::StdArc> *g_fst_ = nullptr;
 
-    fst::VectorFst<fst::StdArc> *std_lm_fst_;
+    fst::VectorFst<fst::StdArc> *graph_lm_fst_ = nullptr;
     kaldi::ConstArpaLm const_arpa_;
 
-    int ref_cnt_;
+    kaldi::rnnlm::RnnlmComputeStateComputationOptions rnnlm_compute_opts;
+    CuMatrix<BaseFloat> word_embedding_mat;
+    kaldi::nnet3::Nnet rnnlm;
+    bool rnnlm_enabled_ = false;
+
+    std::atomic<int> ref_cnt_;
 };
 
 #endif /* VOSK_MODEL_H */