lookatstudy-termux-voice 0.12.1

package/README.md

@@ -0,0 +1,11 @@
+# Introduction
+
+Please see
+https://github.com/k2-fsa/sherpa-onnx/blob/master/nodejs-addon-examples/README.md
+for usages.
+
+
+||Method|Support multiple threads|Minimum required node version|
+|---|---|---|---|
+|this package| https://github.com/nodejs/node-addon-api | Yes | v16|
+|https://www.npmjs.com/package/sherpa-onnx| WebAssembly | No | v18|

package/addon-static-import.js

@@ -0,0 +1,70 @@
+const os = require('os');
+
+let addon = null;
+
+const platform = os.platform() === 'win32' ? 'win' : os.platform();
+const arch = os.arch();
+
+try {
+  if (arch === 'x64') {
+    if (platform === 'win') {
+      // @ts-expect-error
+      addon = require('../sherpa-onnx-win-x64/sherpa-onnx.node')
+    } else if (platform === 'darwin') {
+      // @ts-expect-error
+      addon = require('../sherpa-onnx-darwin-x64/sherpa-onnx.node')
+    } else if (platform === 'linux') {
+      // @ts-expect-error
+      addon = require('../sherpa-onnx-linux-x64/sherpa-onnx.node')
+    }
+  } else if (arch === 'arm64') {
+    if (platform === 'darwin') {
+      // @ts-expect-error
+      addon = require('../sherpa-onnx-darwin-arm64/sherpa-onnx.node')
+    } else if (platform === 'linux') {
+      // @ts-expect-error
+      addon = require('../sherpa-onnx-linux-arm64/sherpa-onnx.node')
+    }
+  } else if (arch === 'ia32') {
+    if (platform === 'win') {
+      // @ts-expect-error
+      addon = require('../sherpa-onnx-win-ia32/sherpa-onnx.node')
+    }
+  }
+} catch (error) {
+  //
+}
+
+if (!addon) {
+  try {
+    if (arch === 'x64') {
+      if (platform === 'win') {
+        // @ts-expect-error
+        addon = require('./node_modules/sherpa-onnx-win-x64/sherpa-onnx.node')
+      } else if (platform === 'darwin') {
+        // @ts-expect-error
+        addon = require('./node_modules/sherpa-onnx-darwin-x64/sherpa-onnx.node')
+      } else if (platform === 'linux') {
+        // @ts-expect-error
+        addon = require('./node_modules/sherpa-onnx-linux-x64/sherpa-onnx.node')
+      }
+    } else if (arch === 'arm64') {
+      if (platform === 'darwin') {
+        // @ts-expect-error
+        addon = require('./node_modules/sherpa-onnx-darwin-arm64/sherpa-onnx.node')
+      } else if (platform === 'linux') {
+        // @ts-expect-error
+        addon = require('./node_modules/sherpa-onnx-linux-arm64/sherpa-onnx.node')
+      }
+    } else if (arch === 'ia32') {
+      if (platform === 'win') {
+        // @ts-expect-error
+        addon = require('./node_modules/sherpa-onnx-win-ia32/sherpa-onnx.node')
+      }
+    }
+  } catch (error) {
+    //
+  }
+}
+ 
+module.exports = addon;

package/addon.js

@@ -0,0 +1,98 @@
+/** @typedef {import('./types').WaveObject} WaveObject */
+
+const os = require('os');
+const path = require('path');
+const addonStaticImport = require('./addon-static-import');
+
+// Package name triggered spam for sherpa-onnx-win32-x64
+// so we have renamed it to sherpa-onnx-win-x64
+const platform = os.platform() === 'win32' ? 'win' : os.platform();
+const arch = os.arch();
+const platform_arch = `${platform}-${arch}`;
+const possible_paths = [
+  '../build/Release/sherpa-onnx.node',
+  '../build/Debug/sherpa-onnx.node',
+  `./node_modules/sherpa-onnx-${platform_arch}/sherpa-onnx.node`,
+  `../sherpa-onnx-${platform_arch}/sherpa-onnx.node`,
+  './sherpa-onnx.node',
+];
+
+let addon = addonStaticImport;
+
+if (!addon) {
+  for (const p of possible_paths) {
+    try {
+      addon = require(p);
+      break;
+    } catch (error) {
+      // do nothing; try the next option
+      ;
+    }
+  }
+}
+
+module.exports = addon;
+
+if (!addon) {
+  let addon_path =
+      `${process.env.PWD}/node_modules/sherpa-onnx-${platform_arch}`;
+  const pnpmIndex = __dirname.indexOf(`node_modules${path.sep}.pnpm`);
+  if (pnpmIndex !== -1) {
+    const parts = __dirname.slice(pnpmIndex).split(path.sep);
+    parts.pop();
+    addon_path =
+        `${process.env.PWD}/${parts.join('/')}/sherpa-onnx-${platform_arch}`;
+  }
+
+  let msg = `Could not find sherpa-onnx-node. Tried\n\n  ${
+      possible_paths.join('\n  ')}\n`
+  if (os.platform() == 'darwin' &&
+      (!process.env.DYLD_LIBRARY_PATH ||
+       !process.env.DYLD_LIBRARY_PATH.includes(
+           `node_modules/sherpa-onnx-${platform_arch}`))) {
+    msg +=
+        'Please remember to set the following environment variable and try again:\n';
+
+    msg += `export DYLD_LIBRARY_PATH=${addon_path}`;
+
+    msg += ':$DYLD_LIBRARY_PATH\n';
+  }
+
+  if (os.platform() == 'linux' &&
+      (!process.env.LD_LIBRARY_PATH ||
+       !process.env.LD_LIBRARY_PATH.includes(
+           `node_modules/sherpa-onnx-${platform_arch}`))) {
+    msg +=
+        'Please remember to set the following environment variable and try again:\n';
+
+    msg += `export LD_LIBRARY_PATH=${addon_path}`;
+
+    msg += ':$LD_LIBRARY_PATH\n';
+  }
+
+  throw new Error(msg)
+}
+
+/**
+ * Read a wave file from disk.
+ * @function module.exports.readWave
+ * @param {string} filename
+ * @param {boolean} [enableExternalBuffer=true]
+ * @returns {WaveObject}
+ */
+
+/**
+ * Read a wave from binary buffer.
+ * @function module.exports.readWaveFromBinary
+ * @param {Uint8Array} data - Binary contents of a wave file.
+ * @param {boolean} [enableExternalBuffer=true]
+ * @returns {WaveObject}
+ */
+
+/**
+ * Write a wave file to disk.
+ * @function module.exports.writeWave
+ * @param {string} filename
+ * @param {WaveObject} obj - { samples: Float32Array, sampleRate: number }
+ * @returns {boolean}
+ */

package/audio-tagg.js

@@ -0,0 +1,45 @@
+/** @typedef {import('./types').AudioTaggingConfig} AudioTaggingConfig */
+/** @typedef {import('./types').AudioEvent} AudioEvent */
+/** @typedef {import('./types').AudioTaggingHandle} AudioTaggingHandle */
+/** @typedef {import('./non-streaming-asr').OfflineStream} OfflineStream */
+
+const addon = require('./addon.js');
+const non_streaming_asr = require('./non-streaming-asr.js');
+
+/**
+ * AudioTagging utility.
+ * @class
+ */
+class AudioTagging {
+  /**
+   * Create an AudioTagging instance.
+   * @param {AudioTaggingConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createAudioTagging(config);
+    this.config = config;
+  }
+
+  /**
+   * Create an offline stream bound to this AudioTagging instance.
+   * @returns {OfflineStream}
+   */
+  createStream() {
+    return new non_streaming_asr.OfflineStream(
+        addon.audioTaggingCreateOfflineStream(this.handle));
+  }
+
+  /**
+   * Compute audio tags from an offline stream.
+   * @param {OfflineStream} stream - An offline stream created by `AudioTagging.createStream()`.
+   * @param {number} [topK=-1] - Return top K results; -1 for all.
+   * @returns {AudioEvent[]}
+   */
+  compute(stream, topK = -1) {
+    return addon.audioTaggingCompute(this.handle, stream.handle, topK);
+  }
+}
+
+module.exports = {
+  AudioTagging,
+}

package/keyword-spotter.js

@@ -0,0 +1,68 @@
+/** @typedef {import('./types').KeywordSpotterConfig} KeywordSpotterConfig */
+/** @typedef {import('./types').KeywordSpotterHandle} KeywordSpotterHandle */
+/** @typedef {import('./types').KeywordResult} KeywordResult */
+/** @typedef {import('./streaming-asr').OnlineStream} OnlineStream */
+
+const addon = require('./addon.js');
+const streaming_asr = require('./streaming-asr.js');
+
+/**
+ * KeywordSpotter handles keyword detection.
+ */
+class KeywordSpotter {
+  /**
+   * @param {KeywordSpotterConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createKeywordSpotter(config);
+    this.config = config
+  }
+
+  /**
+   * Create an OnlineStream for the spotter.
+   * @returns {OnlineStream}
+   */
+  createStream() {
+    const handle = addon.createKeywordStream(this.handle);
+    return new streaming_asr.OnlineStream(handle);
+  }
+
+  /**
+   * @param {OnlineStream} stream
+   * @returns {boolean}
+   */
+  isReady(stream) {
+    return addon.isKeywordStreamReady(this.handle, stream.handle);
+  }
+
+  /**
+   * Trigger decode on a stream.
+   * @param {OnlineStream} stream
+   */
+  decode(stream) {
+    addon.decodeKeywordStream(this.handle, stream.handle);
+  }
+
+  /**
+   * Reset a stream.
+   * @param {OnlineStream} stream
+   */
+  reset(stream) {
+    addon.resetKeywordStream(this.handle, stream.handle);
+  }
+
+  /**
+   * Get the keyword result for a stream.
+   * @param {OnlineStream} stream
+   * @returns {KeywordResult}
+   */
+  getResult(stream) {
+    const jsonStr = addon.getKeywordResultAsJson(this.handle, stream.handle);
+
+    return JSON.parse(jsonStr);
+  }
+}
+
+module.exports = {
+  KeywordSpotter,
+}

package/non-streaming-asr.js

@@ -0,0 +1,158 @@
+/** @typedef {import('./types').OfflineStreamObject} OfflineStreamObject */
+/** @typedef {import('./types').OfflineStreamHandle} OfflineStreamHandle */
+/** @typedef {import('./types').OfflineRecognizerHandle} OfflineRecognizerHandle */
+/** @typedef {import('./types').Waveform} Waveform */
+/**
+ * @typedef {import('./types').OfflineRecognizerConfig} OfflineRecognizerConfig
+ */
+/**
+ * @typedef {import('./types').OfflineRecognizerResult} OfflineRecognizerResult
+ */
+
+const addon = require('./addon.js');
+
+/**
+ * Internal symbol to mark async-created recognizers.
+ * Not accessible unless someone has a reference to this Symbol.
+ */
+const kFromAsyncFactory = Symbol('OfflineRecognizer.fromAsync');
+
+/**
+ * OfflineStream represents a synchronous offline audio stream.
+ */
+class OfflineStream {
+  /**
+   * @param {OfflineStreamObject|Object} handle
+   */
+  constructor(handle) {
+    this.handle = handle;
+  }
+
+  /**
+   * Accept a chunk of waveform samples.
+   * @param {Waveform} obj - { samples: Float32Array, sampleRate: number }
+   */
+  acceptWaveform(obj) {
+    addon.acceptWaveformOffline(this.handle, obj);
+  }
+
+  /**
+   * Set a string option on the underlying offline stream.
+   * @param {string} key
+   * @param {string} value
+   */
+  setOption(key, value) {
+    addon.offlineStreamSetOption(this.handle, key, value);
+  }
+}
+
+/**
+ * OfflineRecognizer wraps the native offline recognizer.
+ */
+class OfflineRecognizer {
+  /**
+   * Constructor (SYNC path).
+   *
+   * Users call:
+   *   new OfflineRecognizer(config)
+   *
+   * Async factory calls this with an internal descriptor.
+   *
+   * @param {OfflineRecognizerConfig | Object} configOrInternal
+   */
+  constructor(configOrInternal) {
+    // ----- async factory path -----
+    if (configOrInternal && typeof configOrInternal === 'object' &&
+        configOrInternal[kFromAsyncFactory]) {
+      this.handle = configOrInternal.handle;
+      this.config = configOrInternal.config;
+      return;
+    }
+
+    // ----- sync constructor path -----
+    this.config = configOrInternal;
+    this.handle = addon.createOfflineRecognizer(this.config);
+  }
+
+  /**
+   * Create an OfflineRecognizer asynchronously (non-blocking).
+   *
+   * @param {OfflineRecognizerConfig} config
+   * @returns {Promise<OfflineRecognizer>}
+   */
+  static async createAsync(config) {
+    const handle = await addon.createOfflineRecognizerAsync(config);
+
+    return new OfflineRecognizer({
+      [kFromAsyncFactory]: true,
+      handle,
+      config,
+    });
+  }
+
+  /**
+   * Create a new OfflineStream bound to this recognizer.
+   *
+   * The optional hotwords argument enables contextual biasing for this
+   * stream only. Hotwords are supported only by transducer models decoded
+   * with decodingMethod 'modified_beam_search'. Separate multiple phrases
+   * with '/', and optionally append a per-phrase boosting score, e.g.
+   * 'PHOEBE :2.0/DON QUIXOTE'. When modelConfig.modelingUnit and
+   * modelConfig.bpeVocab are set, phrases are given as normal words;
+   * otherwise each phrase must be a sequence of tokens from tokens.txt
+   * separated by spaces. See also
+   * https://k2-fsa.github.io/sherpa/onnx/hotwords/index.html
+   *
+   * @param {string} [hotwords] Optional hotwords for this stream.
+   * @returns {OfflineStream}
+   */
+  createStream(hotwords) {
+    const handle = hotwords === undefined ?
+        addon.createOfflineStream(this.handle) :
+        addon.createOfflineStream(this.handle, hotwords);
+    return new OfflineStream(handle);
+  }
+
+  /**
+   * Replace the recognizer config at runtime.
+   * @param {OfflineRecognizerConfig} config
+   */
+  setConfig(config) {
+    this.config = config;
+    addon.offlineRecognizerSetConfig(this.handle, config);
+  }
+
+  /**
+   * Decode an offline stream (synchronous).
+   * @param {OfflineStream} stream
+   */
+  decode(stream) {
+    addon.decodeOfflineStream(this.handle, stream.handle);
+  }
+
+  /**
+   * Decode an offline stream asynchronously (non-blocking).
+   * @param {OfflineStream} stream
+   * @returns {Promise<OfflineRecognizerResult>}
+   */
+  async decodeAsync(stream) {
+    const jsonStr =
+        await addon.decodeOfflineStreamAsync(this.handle, stream.handle);
+    return JSON.parse(jsonStr);
+  }
+
+  /**
+   * Get recognition result for a stream.
+   * @param {OfflineStream} stream
+   * @returns {OfflineRecognizerResult}
+   */
+  getResult(stream) {
+    const jsonStr = addon.getOfflineStreamResultAsJson(stream.handle);
+    return JSON.parse(jsonStr);
+  }
+}
+
+module.exports = {
+  OfflineRecognizer,
+  OfflineStream,
+};

package/non-streaming-speaker-diarization.js

@@ -0,0 +1,38 @@
+/** @typedef {import('./types').OfflineSpeakerDiarizationConfig} OfflineSpeakerDiarizationConfig */
+/** @typedef {import('./types').OfflineSpeakerDiarizationHandle} OfflineSpeakerDiarizationHandle */
+/** @typedef {import('./types').SpeakerDiarizationSegment} SpeakerDiarizationSegment */
+
+const addon = require('./addon.js');
+
+class OfflineSpeakerDiarization {
+  /**
+   * @param {OfflineSpeakerDiarizationConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createOfflineSpeakerDiarization(config);
+    this.config = config;
+
+    this.sampleRate = addon.getOfflineSpeakerDiarizationSampleRate(this.handle);
+  }
+
+  /**
+   * @param {Float32Array} samples - 1-D float32 array in [-1, 1]
+   * @returns {SpeakerDiarizationSegment[]}
+   */
+  process(samples) {
+    return addon.offlineSpeakerDiarizationProcess(this.handle, samples);
+  }
+
+  /**
+   * Set clustering configuration.
+   * @param {{clustering: import('./types').FastClusteringConfig}} config
+   */
+  setConfig(config) {
+    addon.offlineSpeakerDiarizationSetConfig(this.handle, config);
+    this.config.clustering = config.clustering;
+  }
+}
+
+module.exports = {
+  OfflineSpeakerDiarization,
+} 

package/non-streaming-speech-denoiser.js

@@ -0,0 +1,32 @@
+/** @typedef {import('./types').OfflineSpeechDenoiserConfig} OfflineSpeechDenoiserConfig */
+/** @typedef {import('./types').OfflineSpeechDenoiserHandle} OfflineSpeechDenoiserHandle */
+/** @typedef {import('./types').GeneratedAudio} GeneratedAudio */
+/** @typedef {import('./types').AudioProcessRequest} AudioProcessRequest */
+
+const addon = require('./addon.js');
+
+class OfflineSpeechDenoiser {
+  /**
+   * @param {OfflineSpeechDenoiserConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createOfflineSpeechDenoiser(config);
+    this.config = config;
+
+    this.sampleRate =
+        addon.offlineSpeechDenoiserGetSampleRateWrapper(this.handle);
+  }
+
+  /**
+   * Run denoiser synchronously.
+   * @param {AudioProcessRequest} obj - { samples: Float32Array, sampleRate: number, enableExternalBuffer?: boolean }
+   * @returns {GeneratedAudio}
+   */
+  run(obj) {
+    return addon.offlineSpeechDenoiserRunWrapper(this.handle, obj);
+  }
+}
+
+module.exports = {
+  OfflineSpeechDenoiser,
+} 

package/non-streaming-tts.js

@@ -0,0 +1,116 @@
+/** @typedef {import('./types').OfflineTtsConfig} OfflineTtsConfig */
+/** @typedef {import('./types').OfflineTtsHandle} OfflineTtsHandle */
+/** @typedef {import('./types').TtsRequest} TtsRequest */
+/** @typedef {import('./types').GeneratedAudio} GeneratedAudio */
+
+const addon = require('./addon.js');
+
+/**
+ * Internal symbol to mark async-created TTS instances.
+ */
+const kFromAsyncFactory = Symbol('OfflineTts.fromAsync');
+
+
+class GenerationConfig {
+  constructor(opts = {}) {
+    Object.assign(this, opts);
+  }
+}
+
+
+class OfflineTts {
+  /**
+   * Constructor (sync path).
+   *
+   * Users call:
+   *   new OfflineTts(config)
+   *
+   * Async factory calls this with an internal descriptor.
+   *
+   * @param {OfflineTtsConfig|Object} configOrInternal
+   */
+  constructor(configOrInternal) {
+    if (configOrInternal && typeof configOrInternal === 'object' &&
+        configOrInternal[kFromAsyncFactory]) {
+      // ----- async factory path -----
+      this.handle = configOrInternal.handle;
+      this.config = configOrInternal.config;
+    } else {
+      // ----- sync constructor path -----
+      this.config = configOrInternal;
+      this.handle = addon.createOfflineTts(this.config);
+    }
+
+    // Common initialization
+    this.numSpeakers = addon.getOfflineTtsNumSpeakers(this.handle);
+    this.sampleRate = addon.getOfflineTtsSampleRate(this.handle);
+  }
+
+  /**
+   * Create an OfflineTts asynchronously (non-blocking).
+   * @param {OfflineTtsConfig} config
+   * @returns {Promise<OfflineTts>}
+   */
+  static async createAsync(config) {
+    const handle = await addon.createOfflineTtsAsync(config);
+    return new OfflineTts({
+      [kFromAsyncFactory]: true,
+      handle,
+      config,
+    });
+  }
+
+  /**
+   * Generate audio synchronously.
+   * @param {TtsRequest} obj
+   * @returns {GeneratedAudio}
+   */
+  generate(obj) {
+    if (!obj || typeof obj !== 'object') {
+      throw new TypeError('generate() expects an object');
+    }
+
+    // If generationConfig is present, use new API
+    if (obj.generationConfig !== undefined) {
+      return addon.offlineTtsGenerateWithConfig(this.handle, obj);
+    }
+
+    // Fallback to legacy path
+    return addon.offlineTtsGenerate(this.handle, obj);
+  }
+  /**
+   * Generate audio asynchronously with optional generationConfig and progress
+   * callback
+   *
+   * The progress callback receives streaming audio chunks.
+   *
+   * @param {TtsRequest & { generationConfig?: GenerationConfig, onProgress?: (info: {
+   *     samples: Float32Array, progress: number }) => number | boolean | void
+   *     }} obj
+   * @returns {Promise<GeneratedAudio>}
+   */
+  generateAsync(obj) {
+    const {onProgress, ...rest} = obj;
+
+    const hasConfig = obj.generationConfig !== undefined;
+
+    const fn = hasConfig ? addon.offlineTtsGenerateAsyncWithConfig :
+                           addon.offlineTtsGenerateAsync;
+
+    return fn(this.handle, {
+      ...rest,
+      callback: typeof onProgress === 'function' ?
+          (info) => {
+            const ret = onProgress(info);
+            return ret === 0 || ret === false ? 0 : 1;
+          } :
+          undefined,
+    });
+  }
+}
+
+
+module.exports = {
+  OfflineTts,
+  GenerationConfig,
+}

package/online-speech-denoiser.js

@@ -0,0 +1,46 @@
+/** @typedef {import('./types').OnlineSpeechDenoiserConfig} OnlineSpeechDenoiserConfig */
+/** @typedef {import('./types').OnlineSpeechDenoiserHandle} OnlineSpeechDenoiserHandle */
+/** @typedef {import('./types').GeneratedAudio} GeneratedAudio */
+/** @typedef {import('./types').AudioProcessRequest} AudioProcessRequest */
+
+const addon = require('./addon.js');
+
+class OnlineSpeechDenoiser {
+  /**
+   * @param {OnlineSpeechDenoiserConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createOnlineSpeechDenoiser(config);
+    this.config = config;
+
+    this.sampleRate =
+        addon.onlineSpeechDenoiserGetSampleRateWrapper(this.handle);
+    this.frameShiftInSamples =
+        addon.onlineSpeechDenoiserGetFrameShiftInSamplesWrapper(this.handle);
+  }
+
+  /**
+   * @param {AudioProcessRequest} obj
+   * @returns {GeneratedAudio}
+   */
+  run(obj) {
+    return addon.onlineSpeechDenoiserRunWrapper(this.handle, obj);
+  }
+
+  /**
+   * @param {boolean} [enableExternalBuffer=true]
+   * @returns {GeneratedAudio}
+   */
+  flush(enableExternalBuffer = true) {
+    return addon.onlineSpeechDenoiserFlushWrapper(
+        this.handle, enableExternalBuffer);
+  }
+
+  reset() {
+    addon.onlineSpeechDenoiserResetWrapper(this.handle);
+  }
+}
+
+module.exports = {
+  OnlineSpeechDenoiser,
+};