lookatstudy-termux-voice 0.12.1

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "lookatstudy-termux-voice",
+  "version": "0.12.1",
+  "description": "Speech-to-text, text-to-speech, speaker diarization, and speech enhancement using Next-gen Kaldi without internet connection [termux android-arm64 build with bundled .so]",
+  "main": "sherpa-onnx.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Kaiji-Z/LookatStudy.git"
+  },
+  "keywords": [
+    "speech to text",
+    "text to speech",
+    "transcription",
+    "real-time speech recognition",
+    "without internet connection",
+    "locally",
+    "local",
+    "embedded systems",
+    "open source",
+    "diarization",
+    "speaker diarization",
+    "speaker recognition",
+    "speaker",
+    "speaker segmentation",
+    "speaker verification",
+    "spoken language identification",
+    "sherpa",
+    "zipformer",
+    "asr",
+    "tts",
+    "stt",
+    "c++",
+    "onnxruntime",
+    "onnx",
+    "ai",
+    "next-gen kaldi",
+    "offline",
+    "privacy",
+    "open source",
+    "streaming speech recognition",
+    "speech",
+    "recognition",
+    "vad",
+    "node-addon-api",
+    "speaker id",
+    "language id",
+    "speech enhancement",
+    "denoising"
+  ],
+  "author": "The next-gen Kaldi team",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/csukuangfj/sherpa-onnx/issues"
+  },
+  "homepage": "https://github.com/csukuangfj/sherpa-onnx#readme",
+  "optionalDependencies": {
+    "sherpa-onnx-darwin-arm64": "^1.13.6",
+    "sherpa-onnx-darwin-x64": "^1.13.6",
+    "sherpa-onnx-linux-x64": "^1.13.6",
+    "sherpa-onnx-linux-arm64": "^1.13.6",
+    "sherpa-onnx-win-x64": "^1.13.6",
+    "sherpa-onnx-win-ia32": "^1.13.6"
+  },
+  "sherpaVersion": "1.13.6"
+}

package/punctuation.js

@@ -0,0 +1,43 @@
+/** @typedef {import('./types').OfflinePunctuationHandle} OfflinePunctuationHandle */
+/** @typedef {import('./types').OfflinePunctuationConfig} OfflinePunctuationConfig */
+/** @typedef {import('./types').OnlinePunctuationConfig} OnlinePunctuationConfig */
+/** @typedef {import('./types').OnlinePunctuationHandle} OnlinePunctuationHandle */
+
+const addon = require('./addon.js');
+
+class OfflinePunctuation {
+  /**
+   * @param {OfflinePunctuationConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createOfflinePunctuation(config);
+    this.config = config;
+  }
+  /**
+   * Add punctuation to `text` and return the punctuated text.
+   * @param {string} text
+   * @returns {string}
+   */
+  addPunct(text) {
+    return addon.offlinePunctuationAddPunct(this.handle, text);
+  }
+}
+
+class OnlinePunctuation {
+  /**
+   * @param {OnlinePunctuationConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createOnlinePunctuation(config);
+    this.config = config;
+  }
+  /** @param {string} text @returns {string} */
+  addPunct(text) {
+    return addon.onlinePunctuationAddPunct(this.handle, text);
+  }
+}
+
+module.exports = {
+  OfflinePunctuation,
+  OnlinePunctuation,
+} 

package/resampler.js

@@ -0,0 +1,80 @@
+/** @typedef {import('./types').LinearResamplerHandle} LinearResamplerHandle */
+
+const addon = require('./addon.js');
+
+/**
+ * A linear resampler that converts audio from one sample rate to another.
+ */
+class LinearResampler {
+  /**
+   * Create a linear resampler.
+   *
+   * @param {number} inputSampleRate - Input sample rate in Hz.
+   * @param {number} outputSampleRate - Output sample rate in Hz.
+   */
+  constructor(inputSampleRate, outputSampleRate) {
+    /** @type {LinearResamplerHandle} */
+    this.handle =
+        addon.createLinearResampler(inputSampleRate, outputSampleRate);
+    this.inputSampleRate = inputSampleRate;
+    this.outputSampleRate = outputSampleRate;
+  }
+
+  /**
+   * Resample a chunk of audio samples.
+   *
+   * Call this for each chunk of input audio. For the final chunk, call
+   * {@link flush} instead so that any internally buffered samples are
+   * emitted.
+   *
+   * @param {Float32Array} samples - Input audio samples.
+   * @returns {Float32Array} Resampled audio samples.
+   */
+  resample(samples) {
+    return addon.resampleLinear(this.handle, samples, 0);
+  }
+
+  /**
+   * Resample the final chunk of audio and flush internal buffers.
+   *
+   * This is the same as {@link resample} but sets flush=1 so that any
+   * remaining samples buffered inside the resampler are emitted. Call
+   * this once after the last chunk of input audio.
+   *
+   * @param {Float32Array} samples - The final chunk of input audio samples.
+   * @returns {Float32Array} Resampled audio samples including buffered tail.
+   */
+  flush(samples) {
+    return addon.resampleLinear(this.handle, samples, 1);
+  }
+
+  /**
+   * Reset the resampler to its initial state, discarding any internal
+   * buffered samples.
+   */
+  reset() {
+    addon.linearResamplerReset(this.handle);
+  }
+
+  /**
+   * Get the input sample rate.
+   *
+   * @returns {number} Input sample rate in Hz.
+   */
+  getInputSampleRate() {
+    return addon.linearResamplerGetInputSampleRate(this.handle);
+  }
+
+  /**
+   * Get the output sample rate.
+   *
+   * @returns {number} Output sample rate in Hz.
+   */
+  getOutputSampleRate() {
+    return addon.linearResamplerGetOutputSampleRate(this.handle);
+  }
+}
+
+module.exports = {
+  LinearResampler,
+}

package/sherpa-onnx.js

@@ -0,0 +1,49 @@
+/** @typedef {import('./types').WaveObject} WaveObject */
+/**
+ * @typedef {import('./types').OnlineRecognizerResult} OnlineRecognizerResult
+ */
+/**
+ * @typedef {import('./types').OfflineRecognizerResult} OfflineRecognizerResult
+ */
+
+const addon = require('./addon.js')
+const streaming_asr = require('./streaming-asr.js');
+const non_streaming_asr = require('./non-streaming-asr.js');
+const non_streaming_tts = require('./non-streaming-tts.js');
+const vad = require('./vad.js');
+const slid = require('./spoken-language-identification.js');
+const sid = require('./speaker-identification.js');
+const at = require('./audio-tagg.js');
+const punct = require('./punctuation.js');
+const kws = require('./keyword-spotter.js');
+const sd = require('./non-streaming-speaker-diarization.js');
+const speech_denoiser = require('./non-streaming-speech-denoiser.js');
+const online_speech_denoiser = require('./online-speech-denoiser.js');
+const resampler = require('./resampler.js');
+
+module.exports = {
+  OnlineRecognizer : streaming_asr.OnlineRecognizer,
+  OfflineRecognizer : non_streaming_asr.OfflineRecognizer,
+  OfflineTts : non_streaming_tts.OfflineTts,
+  GenerationConfig : non_streaming_tts.GenerationConfig,
+  readWave : addon.readWave,
+  writeWave : addon.writeWave,
+  Display : streaming_asr.Display,
+  Vad : vad.Vad,
+  CircularBuffer : vad.CircularBuffer,
+  SpokenLanguageIdentification : slid.SpokenLanguageIdentification,
+  SpeakerEmbeddingExtractor : sid.SpeakerEmbeddingExtractor,
+  SpeakerEmbeddingManager : sid.SpeakerEmbeddingManager,
+  AudioTagging : at.AudioTagging,
+  OfflinePunctuation : punct.OfflinePunctuation,
+  OnlinePunctuation : punct.OnlinePunctuation,
+  KeywordSpotter : kws.KeywordSpotter,
+  OfflineSpeakerDiarization : sd.OfflineSpeakerDiarization,
+  OfflineSpeechDenoiser : speech_denoiser.OfflineSpeechDenoiser,
+  OnlineSpeechDenoiser : online_speech_denoiser.OnlineSpeechDenoiser,
+  LinearResampler : resampler.LinearResampler,
+  version : addon.version,
+  gitSha1 : addon.gitSha1,
+  gitDate : addon.gitDate,
+  onnxruntimeVersion : addon.onnxruntimeVersion,
+}

package/speaker-identification.js

@@ -0,0 +1,152 @@
+/** @typedef {import('./types').SpeakerEmbeddingEntry} SpeakerEmbeddingEntry */
+/** @typedef {import('./types').SpeakerEmbeddingManagerSearchObj} SpeakerEmbeddingManagerSearchObj */
+/** @typedef {import('./types').SpeakerEmbeddingManagerVerifyObj} SpeakerEmbeddingManagerVerifyObj */
+/** @typedef {import('./types').SpeakerEmbeddingExtractorConfig} SpeakerEmbeddingExtractorConfig */
+/** @typedef {import('./types').SpeakerEmbeddingExtractorHandle} SpeakerEmbeddingExtractorHandle */
+/** @typedef {import('./types').SpeakerEmbeddingManagerHandle} SpeakerEmbeddingManagerHandle */
+/** @typedef {import('./streaming-asr').OnlineStream} OnlineStream */
+
+const addon = require('./addon.js');
+const streaming_asr = require('./streaming-asr.js');
+
+/**
+ * SpeakerEmbeddingExtractor wraps native speaker embedding extractor.
+ */
+class SpeakerEmbeddingExtractor {
+  /**
+   * @param {SpeakerEmbeddingExtractorConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createSpeakerEmbeddingExtractor(config);
+    this.config = config;
+    this.dim = addon.speakerEmbeddingExtractorDim(this.handle);
+  }
+
+  /**
+   * @returns {OnlineStream}
+   */
+  createStream() {
+    return new streaming_asr.OnlineStream(
+        addon.speakerEmbeddingExtractorCreateStream(this.handle));
+  }
+
+  /**
+   * @param {OnlineStream} stream
+   * @returns {boolean}
+   */
+  isReady(stream) {
+    return addon.speakerEmbeddingExtractorIsReady(this.handle, stream.handle);
+  }
+
+  /**
+   * Compute embedding and return a Float32Array
+   * @param {OnlineStream} stream
+   * @param {boolean} [enableExternalBuffer=true]
+   * @returns {Float32Array}
+   */
+  compute(stream, enableExternalBuffer = true) {
+    return addon.speakerEmbeddingExtractorComputeEmbedding(
+        this.handle, stream.handle, enableExternalBuffer);
+  }
+}
+
+/**
+ * Flattens an array of Float32Arrays into a single Float32Array.
+ * @param {Float32Array[]} arrayList
+ * @returns {Float32Array}
+ */
+function flatten(arrayList) {
+  let n = 0;
+  for (let i = 0; i < arrayList.length; ++i) {
+    n += arrayList[i].length;
+  }
+  let ans = new Float32Array(n);
+
+  let offset = 0;
+  for (let i = 0; i < arrayList.length; ++i) {
+    ans.set(arrayList[i], offset);
+    offset += arrayList[i].length;
+  }
+  return ans;
+}
+
+/**
+ * Manager for speaker embeddings.
+ */
+class SpeakerEmbeddingManager {
+  /**
+   * @param {number} dim - The embedding dimension
+   */
+  constructor(dim) {
+    this.handle = addon.createSpeakerEmbeddingManager(dim);
+    this.dim = dim;
+  }
+
+  /**
+   * @param {SpeakerEmbeddingEntry} obj
+   * @returns {boolean}
+   */
+  add(obj) {
+    return addon.speakerEmbeddingManagerAdd(this.handle, obj);
+  }
+
+  /**
+   * @param {{name:string, v: Float32Array[]}} obj
+   * @returns {boolean}
+   */
+  addMulti(obj) {
+    const c = {
+      name: obj.name,
+      vv: flatten(obj.v),
+      n: obj.v.length,
+    };
+    return addon.speakerEmbeddingManagerAddListFlattened(this.handle, c);
+  }
+
+  /**
+   * @param {string} name
+   * @returns {boolean}
+   */
+  remove(name) {
+    return addon.speakerEmbeddingManagerRemove(this.handle, name);
+  }
+
+  /**
+   * @param {SpeakerEmbeddingManagerSearchObj} obj
+   * @returns {string}
+   */
+  search(obj) {
+    return addon.speakerEmbeddingManagerSearch(this.handle, obj);
+  }
+
+  /**
+   * @param {SpeakerEmbeddingManagerVerifyObj} obj
+   * @returns {boolean}
+   */
+  verify(obj) {
+    return addon.speakerEmbeddingManagerVerify(this.handle, obj);
+  }
+
+  /**
+   * @param {string} name
+   * @returns {boolean}
+   */
+  contains(name) {
+    return addon.speakerEmbeddingManagerContains(this.handle, name);
+  }
+
+  /** @returns {number} */
+  getNumSpeakers() {
+    return addon.speakerEmbeddingManagerNumSpeakers(this.handle);
+  }
+
+  /** @returns {string[]} */
+  getAllSpeakerNames() {
+    return addon.speakerEmbeddingManagerGetAllSpeakers(this.handle);
+  }
+}
+
+module.exports = {
+  SpeakerEmbeddingExtractor,
+  SpeakerEmbeddingManager,
+}

package/spoken-language-identification.js

@@ -0,0 +1,38 @@
+/** @typedef {import('./types').SpokenLanguageIdentificationConfig} SpokenLanguageIdentificationConfig */
+/** @typedef {import('./types').SpokenLanguageIdentificationHandle} SpokenLanguageIdentificationHandle */
+/** @typedef {import('./non-streaming-asr').OfflineStream} OfflineStream */
+
+const addon = require('./addon.js');
+const non_streaming_asr = require('./non-streaming-asr.js');
+
+class SpokenLanguageIdentification {
+  /**
+   * @param {SpokenLanguageIdentificationConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createSpokenLanguageIdentification(config);
+    this.config = config;
+  }
+
+  /**
+   * @returns {OfflineStream}
+   */
+  createStream() {
+    return new non_streaming_asr.OfflineStream(
+        addon.createSpokenLanguageIdentificationOfflineStream(this.handle));
+  }
+
+  /**
+   * Return a 2-letter language code, e.g. 'en', 'de', 'fr', 'es', 'zh'
+   * @param {OfflineStream} stream
+   * @returns {string}
+   */
+  compute(stream) {
+    return addon.spokenLanguageIdentificationCompute(
+        this.handle, stream.handle);
+  }
+}
+
+module.exports = {
+  SpokenLanguageIdentification,
+} 

package/streaming-asr.js

@@ -0,0 +1,130 @@
+/** @typedef {import('./types').OnlineStreamObject} OnlineStreamObject */
+/** @typedef {import('./types').OnlineRecognizerHandle} OnlineRecognizerHandle */
+/** @typedef {import('./types').OnlineStreamHandle} OnlineStreamHandle */
+/** @typedef {import('./types').DisplayHandle} DisplayHandle */
+/** @typedef {import('./types').DisplayObject} DisplayObject */
+/** @typedef {import('./types').OnlineRecognizerConfig} OnlineRecognizerConfig */
+/** @typedef {import('./types').Waveform} Waveform */
+/** @typedef {import('./types').OnlineRecognizerResult} OnlineRecognizerResult */
+
+const addon = require('./addon.js');
+
+/**
+ * Display helper for printing recognized words.
+ */
+class Display {
+  /**
+   * @param {number} maxWordPerline
+   */
+  constructor(maxWordPerline) {
+    this.handle = addon.createDisplay(maxWordPerline);
+  }
+
+  /**
+   * Print text to display.
+   * @param {number} idx
+   * @param {string} text
+   */
+  print(idx, text) {
+    addon.print(this.handle, idx, text)
+  }
+}
+
+/**
+ * OnlineStream holds an active online stream handle.
+ */
+class OnlineStream {
+  /**
+   * @param {OnlineStreamObject|Object} handle - object with `handle` property
+   */
+  constructor(handle) {
+    this.handle = handle;
+  }
+
+  /**
+   * Accept waveform data
+   * @param {Waveform} obj - { samples: Float32Array, sampleRate: number }
+   */
+  acceptWaveform(obj) {
+    addon.acceptWaveformOnline(this.handle, obj)
+  }
+
+  /** Notify the stream input has finished. */
+  inputFinished() {
+    addon.inputFinished(this.handle)
+  }
+}
+
+/**
+ * OnlineRecognizer wraps native online recognizer.
+ */
+class OnlineRecognizer {
+  /**
+   * @param {OnlineRecognizerConfig} config - online recognizer config (see C++ for fields)
+   */
+  constructor(config) {
+    this.handle = addon.createOnlineRecognizer(config);
+    this.config = config
+  }
+
+  /**
+   * Create a new OnlineStream.
+   * @returns {OnlineStream}
+   */
+  createStream() {
+    const handle = addon.createOnlineStream(this.handle);
+    return new OnlineStream(handle);
+  }
+
+  /**
+   * Check whether a stream is ready.
+   * @param {OnlineStream} stream
+   * @returns {boolean}
+   */
+  isReady(stream) {
+    return addon.isOnlineStreamReady(this.handle, stream.handle);
+  }
+
+  /**
+   * Trigger decoding on a stream.
+   * @param {OnlineStream} stream
+   */
+  decode(stream) {
+    addon.decodeOnlineStream(this.handle, stream.handle);
+  }
+
+  /**
+   * Check endpoint condition for a stream.
+   * @param {OnlineStream} stream
+   * @returns {boolean}
+   */
+  isEndpoint(stream) {
+    return addon.isEndpoint(this.handle, stream.handle);
+  }
+
+  /**
+   * Reset a stream.
+   * @param {OnlineStream} stream
+   */
+  reset(stream) {
+    addon.reset(this.handle, stream.handle);
+  }
+
+  /**
+   * Get recognition result for a stream.
+   * @param {OnlineStream} stream
+   * @returns {OnlineRecognizerResult}
+   */
+  getResult(stream) {
+    const jsonStr =
+        addon.getOnlineStreamResultAsJson(this.handle, stream.handle);
+
+    return JSON.parse(jsonStr);
+  }
+}
+
+module.exports = {
+  OnlineRecognizer,
+  OnlineStream,
+  Display
+}