@s-h-a-d-o-w/speech-recorder 2.1.10

package/.clang-format

@@ -0,0 +1,2 @@
+BasedOnStyle: Google
+IncludeBlocks: Preserve

package/.github/workflows/prebuilds.yml

@@ -0,0 +1,62 @@
+name: Prebuilds
+
+on:
+  push:
+    tags:
+      - "*"
+
+permissions:
+  contents: write
+
+jobs:
+  prebuild:
+    name: ${{ matrix.platform }} ${{ matrix.arch }}
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: linux
+            os: ubuntu-latest
+            arch: x64
+          - platform: macos
+            os: macos-latest
+            arch: x64
+          - platform: macos
+            os: macos-latest
+            arch: arm64
+          - platform: windows
+            os: windows-latest
+            arch: x64
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v6
+
+      - name: Set up pnpm
+        uses: pnpm/action-setup@v6
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: lts/*
+
+      # - name: Install Linux build dependencies
+      #   if: runner.os == 'Linux'
+      #   run: |
+      #     sudo apt-get update
+      #     sudo apt-get install -y libasound2-dev
+
+      - name: Install npm dependencies
+        run: pnpm install --frozen-lockfile --ignore-scripts
+
+      - name: Build native dependencies
+        shell: bash
+        run: bash setup.sh "${{ matrix.arch }}"
+
+      - name: Build and upload prebuild
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: bash build.sh "${{ matrix.arch }}" "$GITHUB_TOKEN"

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2021 Serenade Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,122 @@
+# Fork notes
+
+## Prerequisites
+
+- cmake
+
+## Notes
+
+`pnpm install` errors if there's no build. But we need the dependencies in order to build. Ignore the error.
+
+Prebuilds MUST BE PUBLISHED TO GITHUB using `./build.sh <arch> <GITHUB_TOKEN>`!! Otherwise, users won't be able to install the package. (The build chain is nix-only, which would be a problem for windows users.)
+
+Latest portaudio release was in 2021. Which is why it already requires the `-DCMAKE_POLICY_VERSION_MINIMUM=3.5` override and may become incompatible sooner or later.
+
+
+# Speech Recorder
+
+speech-recorder is a cross-platform, native [node.js](https://nodejs.org) [addon](http://nodejs.org/api/addons.html) for getting a stream of audio from a device's microphone. Using speech-recorder, you can also get only the audio that corresponds to someone speaking.
+
+This module is used for speech recognition in [Serenade](https://serenade.ai). Serenade enables you to write code through natural speech, rather than typing.
+
+## Installation
+
+speech-recorder has been tested on Windows 10, macOS 10.14+, and Ubuntu 18.04+ (and may work on other platforms as well).
+
+To install speech-recorder, run:
+
+    yarn add speech-recorder
+
+If you're using this library with Electron, you should probably use [electron-rebuild](https://github.com/electron/electron-rebuild).
+
+## Usage
+
+This library uses two voice activity detection mechanisms: a fast first pass (the WebRTC VAD), and a slightly slower, but much more accurate, second pass (the Silero VAD). See below for the various options you can supply to each.
+
+### Streaming
+
+When you start recording, you can register various callbacks. `onAudio` is called when any audio comes in from the microphone. `onChunkStart` is called when a chunk of speech begins, and `onChunkEnd` is called when speech ends.
+
+    const { SpeechRecorder } = require("speech-recorder");
+
+    const recorder = new SpeechRecorder({
+      onChunkStart: ({ audio }) => {
+        console.log(Date.now(), "Chunk start");
+      },
+      onAudio: ({ speaking, probability, volume }) => {
+        console.log(Date.now(), speaking, probability, volume);
+      },
+      onChunkEnd: () => {
+        console.log(Date.now(), "Chunk end");
+      },
+    });
+
+    console.log("Recording for 5 seconds...");
+    recorder.start();
+    setTimeout(() => {
+      console.log("Done!");
+      recorder.stop();
+    }, 5000);
+
+You can write all audio from the microphone to a file with:
+
+    const { SpeechRecorder } = require("speech-recorder");
+
+    const writeStream = fs.createWriteStream("audio.raw");
+    const recorder = new SpeechRecorder({
+      onAudio: ({ audio }) => {
+        writeStream.write(audio);
+      }
+    });
+
+Or, just the speech with:
+
+    const { SpeechRecorder } = require("speech-recorder");
+
+    const writeStream = fs.createWriteStream("audio.raw");
+    const recorder = new SpeechRecorder({
+      onAudio: ({ audio, speech }) => {
+        if (speech) {
+          writeStream.write(audio);
+        }
+      }
+    });
+
+### Devices
+
+You can get a list of supported devices with:
+
+    const { devices } = require("speech-recorder");
+
+    console.log(devices());
+
+### Options
+
+* `consecutiveFramesForSilence`: How many frames of audio must be silent before `onChunkEnd` is fired. Default `10`.
+* `consecutiveFramesForSpeaking`: How many frames of audio must be speech before `onChunkStart` is fired. Default `1`.
+* `device`: ID of the device to use for input (i.e., from the example above). Specify `-1` to use the system default. Default `-1`.
+* `leadingBufferFrames`: How many frames of audio to keep in a buffer that's included in `onChunkStart`. Default `10`.
+* `onChunkStart`: Callback to be executed when speech starts.
+* `onAudio`: Callback to be executed when any audio comes in.
+* `onChunkEnd`: Callback to be executed when speech ends.
+* `samplesPerFrame`: How many audio samples to be included in each frame from the microphone. Default `480`.
+* `sampleRate`: Audio sample rate. Default `16000`.
+* `sileroVadBufferSize`: How many audio samples to pass to the VAD. Default `2000`.
+* `sileroVadRateLimit`: Rate limit, in frames, for how frequently to call the VAD. Default `3`.
+* `sileroVadSilenceThreshold`: Probability threshold for speech to transition to silence. Default `0.1`.
+* `sileroVadSpeakingThreshold`: Probability threshold for silence to transition to speech. Default `0.3`.
+* `webrtcVadLevel`: Aggressiveness for the first-pass VAD filter. `0` is least aggressive, and `3` is most aggressive. Default `3`.
+* `webrtcVadBufferSize`: How many audio samples to pass to the first-pass VAD filter. Default `480`. Can only be `160`, `320`, or `480`.
+* `webrtcVadResultsSize`: How many first-pass VAD filter results to keep in history. Default `10`.
+
+## Building SpeechRecorder
+
+If you want to build speech-recorder from source, first install the necessary dependencies by running:
+
+    ./setup.sh <arch>
+
+Where `<arch>` specifies the architecture you'd like to build for and is one of `x64` or `arm64`. If you're not sure, you probably want `x64`.
+
+Then, you can build speech-recorder with:
+
+    ./build.sh <arch>

package/binding.gyp

@@ -0,0 +1,126 @@
+{
+    "targets": [
+        {
+            "target_name": "speechrecorder",
+            "sources": ["src/speech_recorder.cpp"],
+            "cflags!": [
+                "-fno-exceptions",
+                "-fno-rtti",
+            ],
+            "cflags_cc!": [
+                "-fno-exceptions",
+                "-fno-rtti",
+            ],
+            "include_dirs": [
+                "<!@(node -p \"require('node-addon-api').include\")",
+                "<(module_root_dir)/include",
+                "<(module_root_dir)/lib/include",
+                "<(module_root_dir)/lib/build/_deps/drwav-src",
+                "<(module_root_dir)/lib/build/_deps/readerwriterqueue-src",
+                "<(module_root_dir)/lib/3rd_party/webrtcvad",
+                "<(module_root_dir)/lib/3rd_party/portaudio/include",
+                "<(module_root_dir)/lib/3rd_party/onnxruntime/include",
+            ],
+            "defines": [
+                "NAPI_VERSION=<(napi_build_version)",
+                "NAPI_CPP_EXCEPTIONS",
+            ],
+            "conditions": [
+                [
+                    'OS=="mac"',
+                    {
+                        "xcode_settings": {
+                            "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+                            "GCC_ENABLE_CPP_RTTI": "YES",
+                            "MACOSX_DEPLOYMENT_TARGET": "10.14",
+                            "OTHER_LDFLAGS": ["-Wl,-rpath,@loader_path/"],
+                        },
+                        "copies": [
+                            {
+                                "destination": "<(module_root_dir)/build/Release",
+                                "files": [
+                                    "<(module_root_dir)/lib/install/lib/libspeechrecorder.dylib",
+                                    "<(module_root_dir)/lib/install/lib/libportaudio.dylib",
+                                    "<(module_root_dir)/lib/install/lib/libonnxruntime.1.10.0.dylib",
+                                ],
+                            }
+                        ],
+                        "libraries": [
+                            "<(module_root_dir)/build/Release/libspeechrecorder.dylib",
+                            "<(module_root_dir)/build/Release/libportaudio.dylib",
+                            "<(module_root_dir)/build/Release/libonnxruntime.1.10.0.dylib",
+                        ],
+                    },
+                ],
+                [
+                    'OS=="win"',
+                    {
+                        "msvs_settings": {
+                            "VCCLCompilerTool": {
+                                "ExceptionHandling": 1,
+                            },
+                        },
+                        "copies": [
+                            {
+                                "destination": "<(module_root_dir)/build/Release",
+                                "files": [
+                                    "<(module_root_dir)/lib/install/lib/speechrecorder.dll",
+                                    "<(module_root_dir)/lib/install/lib/onnxruntime.dll",
+                                    "<(module_root_dir)/lib/install/lib/onnxruntime_providers_shared.dll",
+                                ],
+                            }
+                        ],
+                        "libraries": [
+                            "<(module_root_dir)/lib/install/lib/speechrecorder.lib",
+                            "<(module_root_dir)/lib/install/lib/onnxruntime.lib",
+                            "<(module_root_dir)/lib/install/lib/onnxruntime_providers_shared.lib",
+                        ],
+                    },
+                ],
+                [
+                    'OS=="win" and target_arch=="x64"',
+                    {
+                        "copies": [
+                            {
+                                "destination": "<(module_root_dir)/build/Release",
+                                "files": [
+                                    "<(module_root_dir)/lib/install/lib/portaudio_x64.dll",
+                                    "<(module_root_dir)/lib/3rd_party/vcruntime/x64/vcruntime140.dll",
+                                    "<(module_root_dir)/lib/3rd_party/vcruntime/x64/vcruntime140_1.dll",
+                                ],
+                            }
+                        ],
+                        "libraries": [
+                            "<(module_root_dir)/lib/install/lib/portaudio_x64.lib",
+                        ],
+                    },
+                ],
+                [
+                    'OS=="linux"',
+                    {
+                        "link_settings": {
+                            "libraries": [
+                                "-Wl,-rpath,'$$ORIGIN'",
+                            ]
+                        },
+                        "copies": [
+                            {
+                                "destination": "<(module_root_dir)/build/Release",
+                                "files": [
+                                    "<(module_root_dir)/lib/install/lib/libspeechrecorder.so",
+                                    "<(module_root_dir)/lib/install/lib/libportaudio.so",
+                                    "<(module_root_dir)/lib/install/lib/libonnxruntime.so.1.10.0",
+                                ],
+                            }
+                        ],
+                        "libraries": [
+                            "<(module_root_dir)/build/Release/libspeechrecorder.so",
+                            "<(module_root_dir)/build/Release/libportaudio.so",
+                            "<(module_root_dir)/build/Release/libonnxruntime.so.1.10.0",
+                        ],
+                    },
+                ],
+            ],
+        }
+    ]
+}

package/build.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+set -e
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+pushd "$HERE" &> /dev/null
+
+if [[ -z "$1" ]] ; then
+  echo "Usage: build.sh x64|arm64 [github-token]"
+  exit 1
+fi
+
+rm -rf lib/build lib/install
+mkdir -p lib/build
+cd lib/build
+
+if [[ `uname -s` == "MINGW"* ]] ; then
+  cmake -A x64 ..
+elif [[ `uname -s` == "Darwin" ]] ; then
+  if [[ "$1" == "x64" ]] ; then
+    cmake -DCMAKE_OSX_ARCHITECTURES=x86_64 ..
+  elif [[ "$1" == "arm64" ]] ; then
+    cmake -DCMAKE_OSX_ARCHITECTURES=arm64 ..
+  fi
+else
+  cmake ..
+fi
+
+cmake --build . --config Release
+cmake --install . --prefix ../install
+
+cd ../..
+rm -rf prebuilds
+
+node_arch="$1"
+
+eval "npm_config_arch=$node_arch ./node_modules/.bin/node-gyp rebuild"
+
+prebuild_command="./node_modules/.bin/prebuild -r napi --include-regex '.(node|a|dylib|dll|so.*)$' --arch=$node_arch"
+if [[ -n "$2" ]] ; then
+  prebuild_command+=" --upload $2"
+fi
+eval $prebuild_command
+
+popd &> /dev/null

package/examples/analyze-files.js

@@ -0,0 +1,124 @@
+const fs = require("fs");
+const path = require("path");
+const { SpeechRecorder } = require("../src/index");
+
+const quantile = (elements, q) => {
+  const sorted = elements.sort((a, b) => a - b);
+  const p = (sorted.length - 1) * q;
+  const base = Math.floor(p);
+  const rest = p - base;
+  if (sorted[base + 1] !== undefined) {
+    return sorted[base] + rest * (sorted[base + 1] - sorted[base]);
+  } else {
+    return sorted[base];
+  }
+};
+
+if (process.argv.length < 4) {
+  console.log("Usage: node analyze-files.js /path/to/wav/files /path/to/labels");
+  process.exit(1);
+}
+
+let currentFile;
+let samples = 0;
+const leadingBufferFrames = 10;
+const sampleRate = 16000;
+const samplesPerFrame = 480;
+let results = {};
+let labels = JSON.parse(fs.readFileSync(process.argv[3], "utf8"));
+
+const recorder = new SpeechRecorder({
+  leadingBufferFrames,
+  samplesPerFrame,
+  sampleRate,
+  onAudio: ({ audio, probability, volume }) => {
+    samples += audio.length;
+  },
+
+  onChunkStart: ({ audio }) => {
+    results[currentFile].speech.push([]);
+    results[currentFile].speech[results[currentFile].speech.length - 1].push(samples / sampleRate);
+  },
+
+  onChunkEnd: () => {
+    results[currentFile].speech[results[currentFile].speech.length - 1].push(samples / sampleRate);
+  },
+});
+
+fs.readdir(process.argv[2], async (error, files) => {
+  for (const file of files) {
+    if (!file.endsWith(".wav")) {
+      continue;
+    }
+
+    currentFile = file;
+    samples = 0;
+    results[file] = { speech: [] };
+    console.log(`Processing ${file}...`);
+    recorder.processFile(path.join(process.argv[2], file));
+  }
+
+  let speechWindowTooSmall = [];
+  let noiseWasSpeech = [];
+  let noise = 0;
+  let speech = 0;
+  let extra = [];
+  for (const i of Object.keys(results)) {
+    const label = labels[i].speech;
+    const result = results[i].speech;
+
+    if (label.length == 0) {
+      noise++;
+    } else {
+      speech++;
+    }
+
+    if (label.length == 0 && result.length > 0) {
+      console.log("Noise was speech:", i);
+      console.log("VAD:", result);
+      noiseWasSpeech.push(i);
+    }
+
+    if (label.length > 0 && result.length > 0) {
+      const start = Math.min(...result.map((e) => e[0]));
+      const stop = Math.max(...result.map((e) => e[1]));
+      if (isNaN(start) || isNaN(stop)) {
+        continue;
+      }
+
+      const tolerance = 0.05;
+      if (
+        start - (leadingBufferFrames * samplesPerFrame) / sampleRate > label[0] + tolerance ||
+        stop < label[1] - tolerance
+      ) {
+        console.log("Speech window too small:", i);
+        console.log("Label:", label);
+        console.log("VAD:", result, start, stop);
+        speechWindowTooSmall.push(i);
+      } else if (stop > label[1]) {
+        extra.push(stop - label[1]);
+      }
+    }
+  }
+
+  console.log(
+    `\nSpeech window too small: ${(speechWindowTooSmall.length / speech).toFixed(2)} (${
+      speechWindowTooSmall.length
+    } / ${speech})`
+  );
+
+  console.log(
+    `Noise was speech: ${noise > 0 ? (noiseWasSpeech.length / noise).toFixed(2) : 0} (${
+      noiseWasSpeech.length
+    } / ${noise})`
+  );
+
+  if (extra.length > 0) {
+    console.log(
+      `Average extra speech: ${(extra.reduce((a, b) => a + b) / extra.length).toFixed(2)}`
+    );
+    console.log(`p50 extra speech: ${quantile(extra, 0.5).toFixed(2)}`);
+    console.log(`p90 extra speech: ${quantile(extra, 0.75).toFixed(2)}`);
+    console.log(`Max extra speech: ${Math.max(...extra).toFixed(2)}`);
+  }
+});

package/examples/devices.js

@@ -0,0 +1,3 @@
+const { devices } = require("../src/index");
+
+console.log(devices());

package/examples/live.js

@@ -0,0 +1,20 @@
+const { SpeechRecorder } = require("../src/index.js");
+
+const recorder = new SpeechRecorder({
+  onChunkStart: () => {
+    console.log(Date.now(), "Chunk start");
+  },
+  onAudio: ({ speaking, probability, volume }) => {
+    console.log(Date.now(), speaking, probability, volume);
+  },
+  onChunkEnd: () => {
+    console.log(Date.now(), "Chunk end");
+  },
+});
+
+console.log("Recording...");
+recorder.start();
+setTimeout(() => {
+  console.log("Done!");
+  recorder.stop();
+}, 60000);

package/examples/record.js

@@ -0,0 +1,31 @@
+const fs = require("fs");
+const { SpeechRecorder } = require("../src/index");
+const { WaveFile } = require("wavefile");
+
+if (process.argv.length < 3) {
+  console.log("Usage: node record.js /path/to/output.wav");
+  process.exit(1);
+}
+
+let buffer = [];
+const sampleRate = 16000;
+const recorder = new SpeechRecorder({
+  onAudio: ({ audio }) => {
+    for (let i = 0; i < audio.length; i++) {
+      buffer.push(audio[i]);
+    }
+
+    if (buffer.length >= sampleRate * 5) {
+      let wav = new WaveFile();
+      wav.fromScratch(1, sampleRate, "16", buffer);
+      fs.writeFileSync(process.argv[2], wav.toBuffer());
+      process.exit(1);
+    }
+  },
+});
+
+console.log("Ready...");
+setTimeout(() => {
+  console.log("Go!");
+  recorder.start();
+}, 1000);

package/include/speech_recorder.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <napi.h>
+
+#include <atomic>
+#include <functional>
+#include <thread>
+
+#include "aligned.h"
+#include "chunk_processor.h"
+
+struct SpeechRecorderCallbackData {
+  std::string event = "";
+  std::vector<short> audio;
+  bool speaking = false;
+  double volume = 0.0;
+  bool speech = false;
+  double probability = 0.0;
+  int consecutiveSilence = 0;
+};
+
+class SpeechRecorder : public Napi::ObjectWrap<SpeechRecorder> {
+ private:
+  std::thread thread_;
+  Napi::ThreadSafeFunction threadSafeFunction_;
+  std::atomic<bool> stopped_;
+  BlockingReaderWriterQueue<SpeechRecorderCallbackData*> queue_;
+  Napi::FunctionReference callback_;
+  std::function<void(Napi::Env, Napi::Function, SpeechRecorderCallbackData*)>
+      threadSafeFunctionCallback_;
+  std::string modelPath_;
+  speechrecorder::ChunkProcessorOptions options_;
+  speechrecorder::ChunkProcessor processor_;
+  std::unique_ptr<speechrecorder::ChunkProcessor> processFileProcessor_;
+
+  void ProcessFile(const Napi::CallbackInfo& info);
+  void Start(const Napi::CallbackInfo& info);
+  void Stop(const Napi::CallbackInfo& info);
+
+ public:
+  SpeechRecorder(const Napi::CallbackInfo& info);
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  ALIGNED
+};
+
+Napi::Value GetDevices(const Napi::CallbackInfo& info);
+Napi::Object Init(Napi::Env env, Napi::Object exports);

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@s-h-a-d-o-w/speech-recorder",
+  "version": "2.1.10",
+  "description": "A node.js library for streaming audio and speech from the microphone.",
+  "main": "src/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/s-h-a-d-o-w/speech-recorder.git"
+  },
+  "author": "Andreas Opferkuch",
+  "license": "MIT",
+  "gypfile": true,
+  "binary": {
+    "napi_versions": [
+      10
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bash build.sh",
+    "clean": "rm -rf build prebuilds lib/build lib/install",
+    "install": "prebuild-install -r napi || node-gyp rebuild"
+  },
+  "dependencies": {
+    "bindings": "^1.5.0",
+    "node-addon-api": "^8.8.0",
+    "prebuild-install": "^7.1.3"
+  },
+  "devDependencies": {
+    "node-gyp": "^13.0.0",
+    "prebuild": "^13.0.1",
+    "wavefile": "^11.0.0"
+  },
+  "packageManager": "pnpm@11.7.0+sha512.19cc852c120c7125760f2443ee6be0ca5b40f9f50598de1a09a1f177503e010e57c23c77646e01e761de59bf874fb22a3398c33ab9691fc13eb946b6f0f4d620"
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,5 @@
+allowBuilds:
+  es5-ext: true
+
+overrides:
+  node-gyp: "^13.0.0"

package/setup.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+
+set -e
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+pushd "$HERE" &> /dev/null
+
+if [[ -z "$1" ]] ; then
+  echo "Usage: setup.sh x64|arm64"
+  exit 1
+fi
+
+rm -rf tmp lib/3rd_party/portaudio lib/3rd_party/onnxruntime
+
+mkdir -p tmp/portaudio
+cd tmp/portaudio
+curl -Lo portaudio.tgz http://files.portaudio.com/archives/pa_stable_v190700_20210406.tgz
+tar xvf portaudio.tgz
+
+cd portaudio
+mkdir dist install
+cd dist
+
+portaudio_cmake="cmake -DCMAKE_POLICY_VERSION_MINIMUM=3.5"
+if [[ `uname -s` == "MINGW"* ]] ; then
+  portaudio_cmake+=" -A x64"
+elif [[ `uname -s` == "Darwin" ]] ; then
+  portaudio_cmake+=" -DCMAKE_OSX_DEPLOYMENT_TARGET=10.14"
+  if [[ "$1" == "x64" ]] ; then
+    portaudio_cmake+=" -DCMAKE_OSX_ARCHITECTURES=x86_64"
+  elif [[ "$1" == "arm64" ]] ; then
+    portaudio_cmake+=" -DCMAKE_OSX_ARCHITECTURES=arm64"
+  fi
+fi
+
+portaudio_cmake+=" .."
+eval $portaudio_cmake
+cmake --build . --config Release
+cmake --install . --prefix ../install
+cp -r ../install ../../../../lib/3rd_party/portaudio
+
+cd ../../..
+mkdir onnxruntime
+cd onnxruntime
+
+if [[ `uname -s` == "MINGW"* ]] ; then
+  mkdir -p ../../lib/3rd_party/onnxruntime/lib
+  curl -Lo onnxruntime.zip https://www.nuget.org/api/v2/package/Microsoft.ML.OnnxRuntime/1.10.0
+  unzip onnxruntime.zip
+  cp -r build/native/include ../../lib/3rd_party/onnxruntime
+
+  path="win-x64"
+
+  cp runtimes/$path/native/*.dll ../../lib/3rd_party/onnxruntime/lib
+  cp runtimes/$path/native/*.lib ../../lib/3rd_party/onnxruntime/lib
+else
+  path="onnxruntime-linux-x64-1.10.0"
+  if [[ `uname -s` == "Darwin" ]] ; then
+    if [[ "$1" == "x64" ]] ; then
+      path="onnxruntime-osx-x86_64-1.10.0"
+    elif [[ "$1" == "arm64" ]] ; then
+      path="onnxruntime-osx-arm64-1.10.0"
+    fi
+  fi
+
+  curl -Lo onnxruntime.tgz https://github.com/microsoft/onnxruntime/releases/download/v1.10.0/$path.tgz
+  tar xvf onnxruntime.tgz
+  cp -r $path ../../lib/3rd_party/onnxruntime
+fi
+
+cd ../..
+rm -rf tmp
+popd &> /dev/null

package/src/index.js

@@ -0,0 +1,72 @@
+const path = require("path");
+const { SpeechRecorder, devices } = require("bindings")("speechrecorder.node");
+
+class Wrapper {
+  constructor(options, model) {
+    options = options ? options : {};
+    options.consecutiveFramesForSilence =
+      options.consecutiveFramesForSilence !== undefined ? options.consecutiveFramesForSilence : 10;
+    options.consecutiveFramesForSpeaking =
+      options.consecutiveFramesForSpeaking !== undefined ? options.consecutiveFramesForSpeaking : 1;
+    options.device = options.device !== undefined ? options.device : -1;
+    options.leadingBufferFrames =
+      options.leadingBufferFrames !== undefined ? options.leadingBufferFrames : 10;
+    options.onChunkStart = options.onChunkStart !== undefined ? options.onChunkStart : (data) => {};
+    options.onAudio =
+      options.onAudio !== undefined
+        ? options.onAudio
+        : (audio, speaking, volume, speech, probability) => {};
+    options.onChunkEnd = options.onChunkEnd !== undefined ? options.onChunkEnd : (data) => {};
+    options.samplesPerFrame = options.samplesPerFrame !== undefined ? options.samplesPerFrame : 480;
+    options.sampleRate = options.sampleRate !== undefined ? options.sampleRate : 16000;
+    options.sileroVadBufferSize =
+      options.sileroVadBufferSize !== undefined ? options.sileroVadBufferSize : 2000;
+    options.sileroVadRateLimit =
+      options.sileroVadRateLimit !== undefined ? options.sileroVadRateLimit : 3;
+    options.sileroVadSilenceThreshold =
+      options.sileroVadSilenceThreshold !== undefined ? options.sileroVadSilenceThreshold : 0.1;
+    options.sileroVadSpeakingThreshold =
+      options.sileroVadSpeakingThreshold !== undefined ? options.sileroVadSpeakingThreshold : 0.3;
+    options.webrtcVadLevel = options.webrtcVadLevel !== undefined ? options.webrtcVadLevel : 3;
+    options.webrtcVadBufferSize =
+      options.webrtcVadBufferSize !== undefined ? options.webrtcVadBufferSize : 480;
+    options.webrtcVadResultsSize =
+      options.webrtcVadResultsSize !== undefined ? options.webrtcVadResultsSize : 10;
+
+    this.inner = new SpeechRecorder(
+      model !== undefined ? model : path.join(__dirname, "..", "lib", "resources", "vad.onnx"),
+      (event, data) => {
+        if (event == "chunkStart") {
+          options.onChunkStart({ audio: data.audio });
+        } else if (event == "audio") {
+          options.onAudio({
+            audio: data.audio,
+            speaking: data.speaking,
+            probability: data.probability,
+            volume: data.volume,
+            speech: data.speech,
+            consecutiveSilence: data.consecutiveSilence,
+          });
+        } else if (event == "chunkEnd") {
+          options.onChunkEnd();
+        }
+      },
+      options
+    );
+  }
+
+  processFile(file) {
+    this.inner.processFile(path.resolve(file));
+  }
+
+  start() {
+    this.inner.start();
+  }
+
+  stop() {
+    this.inner.stop();
+  }
+}
+
+exports.SpeechRecorder = Wrapper;
+exports.devices = devices;

package/src/speech_recorder.cpp

@@ -0,0 +1,298 @@
+#include <napi.h>
+
+#include <atomic>
+#include <chrono>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "chunk_processor.h"
+#include "devices.h"
+#include "portaudio.h"
+#include "speech_recorder.h"
+
+#define DR_WAV_IMPLEMENTATION
+#include "dr_wav.h"
+
+Napi::Object SpeechRecorder::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function f = DefineClass(
+      env, "SpeechRecorder",
+      {
+          InstanceMethod<&SpeechRecorder::ProcessFile>(
+              "processFile", static_cast<napi_property_attributes>(
+                                 napi_writable | napi_configurable)),
+          InstanceMethod<&SpeechRecorder::Start>(
+              "start", static_cast<napi_property_attributes>(
+                           napi_writable | napi_configurable)),
+          InstanceMethod<&SpeechRecorder::Stop>(
+              "stop", static_cast<napi_property_attributes>(napi_writable |
+                                                            napi_configurable)),
+      });
+
+  Napi::FunctionReference* constructor = new Napi::FunctionReference();
+  *constructor = Napi::Persistent(f);
+
+  exports.Set("SpeechRecorder", f);
+  env.SetInstanceData<Napi::FunctionReference>(constructor);
+
+  exports.Set(Napi::String::New(env, "devices"),
+              Napi::Function::New(env, GetDevices));
+  return exports;
+}
+
+SpeechRecorder::SpeechRecorder(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<SpeechRecorder>(info),
+      stopped_(true),
+      queue_(),
+      callback_(Napi::Persistent(info[1].As<Napi::Function>())),
+      threadSafeFunctionCallback_([&](Napi::Env env, Napi::Function jsCallback,
+                                      SpeechRecorderCallbackData* data) {
+        Napi::Object object = Napi::Object::New(env);
+        object.Set("speaking", Napi::Boolean::New(env, data->speaking));
+        object.Set("volume", Napi::Number::New(env, data->volume));
+        object.Set("speech", Napi::Boolean::New(env, data->speech));
+        object.Set("probability", Napi::Number::New(env, data->probability));
+        object.Set("consecutiveSilence",
+                   Napi::Number::New(env, (double)data->consecutiveSilence));
+
+        if (data->audio.size() > 0) {
+          Napi::Int16Array buffer =
+              Napi::Int16Array::New(env, data->audio.size());
+          for (size_t i = 0; i < data->audio.size(); i++) {
+            buffer[i] = data->audio[i];
+          }
+
+          object.Set("audio", buffer);
+        }
+
+        jsCallback.Call({Napi::String::New(env, data->event), object});
+        delete data;
+      }),
+      modelPath_(info[0].As<Napi::String>().Utf8Value()),
+      options_({
+          info[2]
+              .As<Napi::Object>()
+              .Get("consecutiveFramesForSilence")
+              .As<Napi::Number>()
+              .Int32Value(),
+          info[2]
+              .As<Napi::Object>()
+              .Get("consecutiveFramesForSpeaking")
+              .As<Napi::Number>()
+              .Int32Value(),
+          info[2]
+              .As<Napi::Object>()
+              .Get("device")
+              .As<Napi::Number>()
+              .Int32Value(),
+          info[2]
+              .As<Napi::Object>()
+              .Get("leadingBufferFrames")
+              .As<Napi::Number>()
+              .Int32Value(),
+          [&](std::vector<short> audio) {
+            SpeechRecorderCallbackData* data = new SpeechRecorderCallbackData();
+            data->event = "chunkStart";
+            data->audio = audio;
+            queue_.enqueue(data);
+          },
+          [&](std::vector<short> audio, bool speaking, double volume,
+              bool speech, double probability, int consecutiveSilence) {
+            SpeechRecorderCallbackData* data = new SpeechRecorderCallbackData();
+            data->event = "audio";
+            data->audio = audio;
+            data->speaking = speaking;
+            data->volume = volume;
+            data->speech = speech;
+            data->probability = probability;
+            data->consecutiveSilence = consecutiveSilence;
+            queue_.enqueue(data);
+          },
+          [&]() {
+            SpeechRecorderCallbackData* data = new SpeechRecorderCallbackData();
+            data->event = "chunkEnd";
+            queue_.enqueue(data);
+          },
+          info[2]
+              .As<Napi::Object>()
+              .Get("samplesPerFrame")
+              .As<Napi::Number>()
+              .Int32Value(),
+          info[2]
+              .As<Napi::Object>()
+              .Get("sampleRate")
+              .As<Napi::Number>()
+              .Int32Value(),
+          info[2]
+              .As<Napi::Object>()
+              .Get("sileroVadBufferSize")
+              .As<Napi::Number>()
+              .Int32Value(),
+          info[2]
+              .As<Napi::Object>()
+              .Get("sileroVadRateLimit")
+              .As<Napi::Number>()
+              .Int32Value(),
+          info[2]
+              .As<Napi::Object>()
+              .Get("sileroVadSilenceThreshold")
+              .As<Napi::Number>()
+              .DoubleValue(),
+          info[2]
+              .As<Napi::Object>()
+              .Get("sileroVadSpeakingThreshold")
+              .As<Napi::Number>()
+              .DoubleValue(),
+          info[2]
+              .As<Napi::Object>()
+              .Get("webrtcVadLevel")
+              .As<Napi::Number>()
+              .Int32Value(),
+          info[2]
+              .As<Napi::Object>()
+              .Get("webrtcVadBufferSize")
+              .As<Napi::Number>()
+              .Int32Value(),
+          info[2]
+              .As<Napi::Object>()
+              .Get("webrtcVadResultsSize")
+              .As<Napi::Number>()
+              .Int32Value(),
+      }),
+      processor_(modelPath_, options_) {}
+
+void SpeechRecorder::ProcessFile(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  std::string path = info[0].As<Napi::String>().Utf8Value();
+
+  // we don't want to create two processors on startup, because loading the
+  // silero model is expensive, so lazily create this instance only if this
+  // method is actually called (which is probably not common)
+  if (!processFileProcessor_) {
+    speechrecorder::ChunkProcessorOptions options = options_;
+
+    options.onChunkStart = [&](std::vector<short> audio) {
+      Napi::Object object = Napi::Object::New(env);
+      if (audio.size() > 0) {
+        Napi::Int16Array buffer = Napi::Int16Array::New(env, audio.size());
+        for (size_t i = 0; i < audio.size(); i++) {
+          buffer[i] = audio[i];
+        }
+
+        object.Set("audio", buffer);
+      }
+
+      callback_.Value().Call({Napi::String::New(env, "chunkStart"), object});
+    };
+
+    options.onAudio = [&](std::vector<short> audio, bool speaking,
+                          double volume, bool speech, double probability,
+                          int consecutiveSilence) {
+      Napi::Object object = Napi::Object::New(env);
+      object.Set("speaking", Napi::Boolean::New(env, speaking));
+      object.Set("volume", Napi::Number::New(env, volume));
+      object.Set("speech", Napi::Boolean::New(env, speech));
+      object.Set("probability", Napi::Number::New(env, probability));
+      object.Set("consecutiveSilence",
+                 Napi::Number::New(env, (double)consecutiveSilence));
+
+      if (audio.size() > 0) {
+        Napi::Int16Array buffer = Napi::Int16Array::New(env, audio.size());
+        for (size_t i = 0; i < audio.size(); i++) {
+          buffer[i] = audio[i];
+        }
+
+        object.Set("audio", buffer);
+        callback_.Value().Call({Napi::String::New(env, "audio"), object});
+      }
+    };
+
+    options.onChunkEnd = [&] {
+      callback_.Value().Call({Napi::String::New(env, "chunkEnd")});
+    };
+
+    processFileProcessor_ =
+        std::make_unique<speechrecorder::ChunkProcessor>(modelPath_, options);
+  }
+
+  unsigned int channels;
+  unsigned int sampleRate;
+  drwav_uint64 frames;
+  short* data = drwav_open_file_and_read_pcm_frames_s16(
+      path.c_str(), &channels, &sampleRate, &frames, nullptr);
+
+  processFileProcessor_->Reset();
+  int size = (int)frames;
+  for (int i = 0; i < size; i += options_.samplesPerFrame) {
+    std::vector<short> buffer;
+    for (int j = 0; j < options_.samplesPerFrame; j++) {
+      if (i + j < size) {
+        buffer.push_back(data[i + j]);
+      }
+    }
+
+    if (buffer.size() == (size_t)options_.samplesPerFrame) {
+      processFileProcessor_->Process(buffer.data());
+    }
+  }
+
+  drwav_free(data, nullptr);
+}
+
+void SpeechRecorder::Start(const Napi::CallbackInfo& info) {
+  stopped_ = false;
+  threadSafeFunction_ = Napi::ThreadSafeFunction::New(
+      info.Env(), callback_.Value(), "Speech Recorder Start", 0, 1,
+      [&](Napi::Env env) {
+        thread_.join();
+      });
+
+  thread_ = std::thread([&] {
+    while (!stopped_) {
+      SpeechRecorderCallbackData* data;
+      bool element = queue_.try_dequeue(data);
+      if (element) {
+        threadSafeFunction_.BlockingCall(data, threadSafeFunctionCallback_);
+      }
+
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+
+    threadSafeFunction_.Release();
+  });
+
+  processor_.Start();
+}
+
+void SpeechRecorder::Stop(const Napi::CallbackInfo& info) {
+  stopped_ = true;
+  processor_.Stop();
+}
+
+Napi::Value GetDevices(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  std::vector<speechrecorder::Device> devices = speechrecorder::GetDevices();
+  Napi::Array result = Napi::Array::New(env, devices.size());
+  for (size_t i = 0; i < devices.size(); i++) {
+    Napi::Object e = Napi::Object::New(env);
+    e.Set("id", devices[i].id);
+    e.Set("name", devices[i].name);
+    e.Set("apiName", devices[i].apiName);
+    e.Set("maxInputChannels", devices[i].maxInputChannels);
+    e.Set("maxOutputChannels", devices[i].maxOutputChannels);
+    e.Set("defaultSampleRate", devices[i].defaultSampleRate);
+    e.Set("isDefaultInput", devices[i].isDefaultInput);
+    e.Set("isDefaultOutput", devices[i].isDefaultOutput);
+    result[i] = e;
+  }
+
+  return result;
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  SpeechRecorder::Init(env, exports);
+  return exports;
+}
+
+NODE_API_MODULE(addon, Init);