react-native-sherpa-onnx 0.3.9 → 0.4.0

package/src/NativeSherpaOnnx.ts

@@ -422,6 +422,77 @@ export interface Spec extends TurboModule {
    */
   unloadTts(instanceId: string): Promise<void>;
 
+  // ==================== Speech Enhancement Methods ====================
+
+  detectEnhancementModel(
+    modelDir: string,
+    modelType?: string
+  ): Promise<{
+    success: boolean;
+    error?: string;
+    detectedModels: Array<{ type: string; modelDir: string }>;
+    modelType?: string;
+  }>;
+
+  initializeEnhancement(
+    instanceId: string,
+    modelDir: string,
+    modelType?: string,
+    numThreads?: number,
+    provider?: string,
+    debug?: boolean
+  ): Promise<{
+    success: boolean;
+    error?: string;
+    detectedModels: Array<{ type: string; modelDir: string }>;
+    modelType?: string;
+    sampleRate?: number;
+  }>;
+
+  enhanceFile(
+    instanceId: string,
+    inputPath: string,
+    outputPath?: string
+  ): Promise<{ samples: number[]; sampleRate: number }>;
+
+  enhanceSamples(
+    instanceId: string,
+    samples: number[],
+    sampleRate: number
+  ): Promise<{ samples: number[]; sampleRate: number }>;
+
+  getEnhancementSampleRate(instanceId: string): Promise<number>;
+
+  unloadEnhancement(instanceId: string): Promise<void>;
+
+  initializeOnlineEnhancement(
+    instanceId: string,
+    modelDir: string,
+    modelType?: string,
+    numThreads?: number,
+    provider?: string,
+    debug?: boolean
+  ): Promise<{
+    success: boolean;
+    error?: string;
+    sampleRate?: number;
+    frameShiftInSamples?: number;
+  }>;
+
+  feedEnhancementSamples(
+    instanceId: string,
+    samples: number[],
+    sampleRate: number
+  ): Promise<{ samples: number[]; sampleRate: number }>;
+
+  flushOnlineEnhancement(
+    instanceId: string
+  ): Promise<{ samples: number[]; sampleRate: number }>;
+
+  resetOnlineEnhancement(instanceId: string): Promise<void>;
+
+  unloadOnlineEnhancement(instanceId: string): Promise<void>;
+
   /**
    * Save TTS audio samples to a WAV file.
    * @param samples - Audio samples array

package/src/download/localModels.ts

@@ -18,12 +18,11 @@ import {
   getModelsBaseDir,
   getModelDir,
   getManifestPath,
-  getNativeAssetExtractedModelDir,
   getReadyMarkerPath,
   getTarArchivePath,
   getOnnxPath,
 } from './paths';
-import { resolveActualModelDir, removeDirectoryRecursive } from './validation';
+import { resolveActualModelDir } from './validation';
 import { emitModelsListUpdated } from './downloadEvents';
 import { clearMemoryCacheForCategory } from './registry';
 
@@ -211,7 +210,6 @@ export async function deleteModelByCategory(
   if (await exists(onnxPath)) {
     await unlink(onnxPath);
   }
-  await removeDirectoryRecursive(getNativeAssetExtractedModelDir(id));
   const list = await listDownloadedModelsByCategory<ModelMetaBase>(category);
   emitModelsListUpdated(category, list);
 }

package/src/download/paths.ts

@@ -122,7 +122,8 @@ export function getExtractionStatePath(
 /**
  * Directory where native `resolveAssetPath` materializes a bundled model folder
  * (`DocumentDirectoryPath/models/{modelId}` — Android internal `files/models/...`).
- * Separate from {@link getModelDir}. Remove on delete so empty dirs do not break detection.
+ * Separate from {@link getModelDir}. `deleteModelByCategory` does not remove this tree; it
+ * only deletes download-manager installs under `sherpa-onnx/models/`.
  */
 export function getNativeAssetExtractedModelDir(modelId: string): string {
   const safeId = modelId.replace(/[/\\]/g, '');

package/src/enhancement/index.ts

@@ -1,69 +1,131 @@
-/**
- * Speech Enhancement feature module
- *
- * @remarks
- * This feature is not yet implemented. This module serves as a placeholder
- * for future speech enhancement functionality.
- *
- * @example
- * ```typescript
- * // Future usage:
- * import { initializeEnhancement, enhanceAudio } from 'react-native-sherpa-onnx/enhancement';
- *
- * await initializeEnhancement({ modelPath: { type: 'auto', path: 'models/enhancement-model' } });
- * const enhancedPath = await enhanceAudio('path/to/noisy-audio.wav');
- * ```
- */
-
+import SherpaOnnx from '../NativeSherpaOnnx';
 import type { ModelPathConfig } from '../types';
+import { resolveModelPath } from '../utils';
+import type {
+  EnhancedAudio,
+  EnhancementDetectResult,
+  EnhancementEngine,
+  EnhancementInitializeOptions,
+} from './types';
 
-/**
- * Enhancement initialization options (placeholder)
- */
-export interface EnhancementInitializeOptions {
-  modelPath: ModelPathConfig;
-  // Additional enhancement-specific options will be added here
-}
+let enhancementInstanceCounter = 0;
 
-/**
- * Enhancement result
- */
-export interface EnhancementResult {
-  outputPath: string;
-  // Additional result fields will be added here
+function normalizeEnhancedAudio(raw: {
+  samples?: number[] | Float32Array;
+  sampleRate?: number;
+}): EnhancedAudio {
+  const samplesArray = Array.isArray(raw.samples)
+    ? raw.samples
+    : Array.from(raw.samples ?? []);
+  return {
+    samples: Float32Array.from(samplesArray),
+    sampleRate: Number(raw.sampleRate ?? 0),
+  };
 }
 
-/**
- * Initialize Speech Enhancement with model directory.
- *
- * @throws {Error} Not yet implemented
- */
-export async function initializeEnhancement(
-  _options: EnhancementInitializeOptions
-): Promise<void> {
-  throw new Error(
-    'Speech Enhancement feature is not yet implemented. This is a placeholder module.'
+export async function detectEnhancementModel(
+  modelPath: ModelPathConfig,
+  options?: { modelType?: EnhancementInitializeOptions['modelType'] }
+): Promise<EnhancementDetectResult> {
+  const resolvedPath = await resolveModelPath(modelPath);
+  const raw = await SherpaOnnx.detectEnhancementModel(
+    resolvedPath,
+    options?.modelType
   );
+  const err = typeof raw.error === 'string' ? raw.error.trim() : '';
+  return {
+    success: raw.success,
+    ...(err.length > 0 ? { error: err } : {}),
+    detectedModels: raw.detectedModels ?? [],
+    ...(raw.modelType != null && raw.modelType !== ''
+      ? { modelType: raw.modelType }
+      : {}),
+  };
 }
 
-/**
- * Enhance speech quality in an audio file.
- *
- * @throws {Error} Not yet implemented
- */
-export function enhanceAudio(_filePath: string): Promise<EnhancementResult> {
-  throw new Error(
-    'Speech Enhancement feature is not yet implemented. This is a placeholder module.'
+export async function createEnhancement(
+  options: EnhancementInitializeOptions
+): Promise<EnhancementEngine> {
+  const instanceId = `enhancement_${++enhancementInstanceCounter}`;
+  const resolvedPath = await resolveModelPath(options.modelPath);
+  const init = await SherpaOnnx.initializeEnhancement(
+    instanceId,
+    resolvedPath,
+    options.modelType ?? 'auto',
+    options.numThreads,
+    options.provider,
+    options.debug
   );
-}
 
-/**
- * Release enhancement resources.
- *
- * @throws {Error} Not yet implemented
- */
-export function unloadEnhancement(): Promise<void> {
-  throw new Error(
-    'Speech Enhancement feature is not yet implemented. This is a placeholder module.'
-  );
+  if (!init.success) {
+    const nativeError = typeof init.error === 'string' ? init.error.trim() : '';
+    throw new Error(
+      nativeError.length > 0
+        ? `Enhancement initialization failed: ${nativeError}`
+        : `Enhancement initialization failed for ${instanceId}`
+    );
+  }
+
+  let destroyed = false;
+  const guard = () => {
+    if (destroyed) {
+      throw new Error(
+        `Enhancement instance ${instanceId} has been destroyed; cannot call methods on it.`
+      );
+    }
+  };
+
+  return {
+    get instanceId() {
+      return instanceId;
+    },
+    async enhanceFile(
+      inputPath: string,
+      outputPath?: string
+    ): Promise<EnhancedAudio> {
+      guard();
+      const raw = await SherpaOnnx.enhanceFile(
+        instanceId,
+        inputPath,
+        outputPath
+      );
+      return normalizeEnhancedAudio(raw);
+    },
+    async enhanceSamples(
+      samples: number[],
+      sampleRate: number
+    ): Promise<EnhancedAudio> {
+      guard();
+      const raw = await SherpaOnnx.enhanceSamples(
+        instanceId,
+        samples,
+        sampleRate
+      );
+      return normalizeEnhancedAudio(raw);
+    },
+    async getSampleRate(): Promise<number> {
+      guard();
+      return SherpaOnnx.getEnhancementSampleRate(instanceId);
+    },
+    async destroy(): Promise<void> {
+      if (destroyed) return;
+      destroyed = true;
+      await SherpaOnnx.unloadEnhancement(instanceId);
+    },
+  };
 }
+
+export { createStreamingEnhancement } from './streaming';
+export type {
+  OnlineEnhancementEngine,
+  StreamingEnhancementInitializeOptions,
+} from './streamingTypes';
+
+export type {
+  EnhancementModelType,
+  EnhancedAudio,
+  EnhancementInitializeOptions,
+  EnhancementDetectResult,
+  EnhancementEngine,
+} from './types';
+export { ENHANCEMENT_MODEL_TYPES } from './types';

package/src/enhancement/streaming.ts

@@ -0,0 +1,105 @@
+import SherpaOnnx from '../NativeSherpaOnnx';
+import { resolveModelPath } from '../utils';
+import type { EnhancedAudio, EnhancementModelType } from './types';
+import type {
+  OnlineEnhancementEngine,
+  StreamingEnhancementInitializeOptions,
+} from './streamingTypes';
+
+let streamingEnhancementInstanceCounter = 0;
+
+function normalizeEnhancedAudio(raw: {
+  samples?: number[] | Float32Array;
+  sampleRate?: number;
+}): EnhancedAudio {
+  const samplesArray = Array.isArray(raw.samples)
+    ? raw.samples
+    : Array.from(raw.samples ?? []);
+  return {
+    samples: Float32Array.from(samplesArray),
+    sampleRate: Number(raw.sampleRate ?? 0),
+  };
+}
+
+export async function createStreamingEnhancement(
+  options: StreamingEnhancementInitializeOptions
+): Promise<OnlineEnhancementEngine> {
+  const instanceId = `streaming_enhancement_${++streamingEnhancementInstanceCounter}`;
+  const resolvedPath = await resolveModelPath(options.modelPath);
+  const result = await SherpaOnnx.initializeOnlineEnhancement(
+    instanceId,
+    resolvedPath,
+    options.modelType ?? 'auto',
+    options.numThreads,
+    options.provider,
+    options.debug
+  );
+
+  if (!result.success) {
+    const nativeError =
+      typeof result.error === 'string' ? result.error.trim() : '';
+    throw new Error(
+      nativeError.length > 0
+        ? `Streaming enhancement initialization failed: ${nativeError}`
+        : `Streaming enhancement initialization failed for ${instanceId}`
+    );
+  }
+
+  let destroyed = false;
+  const guard = () => {
+    if (destroyed) {
+      throw new Error(
+        `Streaming enhancement instance ${instanceId} has been destroyed; cannot call methods on it.`
+      );
+    }
+  };
+
+  return {
+    get instanceId() {
+      return instanceId;
+    },
+
+    async feedSamples(
+      samples: number[],
+      sampleRate: number
+    ): Promise<EnhancedAudio> {
+      guard();
+      const raw = await SherpaOnnx.feedEnhancementSamples(
+        instanceId,
+        samples,
+        sampleRate
+      );
+      return normalizeEnhancedAudio(raw);
+    },
+
+    async flush(): Promise<EnhancedAudio> {
+      guard();
+      const raw = await SherpaOnnx.flushOnlineEnhancement(instanceId);
+      return normalizeEnhancedAudio(raw);
+    },
+
+    async reset(): Promise<void> {
+      guard();
+      await SherpaOnnx.resetOnlineEnhancement(instanceId);
+    },
+
+    async getSampleRate(): Promise<number> {
+      guard();
+      return SherpaOnnx.getEnhancementSampleRate(instanceId);
+    },
+
+    async getFrameShiftInSamples(): Promise<number> {
+      guard();
+      return Number(result.frameShiftInSamples ?? 0);
+    },
+
+    async destroy(): Promise<void> {
+      if (destroyed) return;
+      destroyed = true;
+      await SherpaOnnx.unloadOnlineEnhancement(instanceId);
+    },
+  };
+}
+
+export type { OnlineEnhancementEngine } from './streamingTypes';
+export type { EnhancementModelType };

package/src/enhancement/streamingTypes.ts

@@ -0,0 +1,14 @@
+import type { EnhancedAudio, EnhancementInitializeOptions } from './types';
+
+export type StreamingEnhancementInitializeOptions =
+  EnhancementInitializeOptions;
+
+export interface OnlineEnhancementEngine {
+  readonly instanceId: string;
+  feedSamples(samples: number[], sampleRate: number): Promise<EnhancedAudio>;
+  flush(): Promise<EnhancedAudio>;
+  reset(): Promise<void>;
+  getSampleRate(): Promise<number>;
+  getFrameShiftInSamples(): Promise<number>;
+  destroy(): Promise<void>;
+}

package/src/enhancement/types.ts

@@ -0,0 +1,36 @@
+import type { ModelPathConfig } from '../types';
+
+export type EnhancementModelType = 'gtcrn' | 'dpdfnet';
+
+export const ENHANCEMENT_MODEL_TYPES: readonly EnhancementModelType[] = [
+  'gtcrn',
+  'dpdfnet',
+] as const;
+
+export type EnhancedAudio = {
+  samples: Float32Array;
+  sampleRate: number;
+};
+
+export interface EnhancementInitializeOptions {
+  modelPath: ModelPathConfig;
+  modelType?: EnhancementModelType | 'auto';
+  numThreads?: number;
+  provider?: string;
+  debug?: boolean;
+}
+
+export type EnhancementDetectResult = {
+  success: boolean;
+  error?: string;
+  detectedModels: Array<{ type: string; modelDir: string }>;
+  modelType?: string;
+};
+
+export interface EnhancementEngine {
+  readonly instanceId: string;
+  enhanceFile(inputPath: string, outputPath?: string): Promise<EnhancedAudio>;
+  enhanceSamples(samples: number[], sampleRate: number): Promise<EnhancedAudio>;
+  getSampleRate(): Promise<number>;
+  destroy(): Promise<void>;
+}

package/src/licenses.ts

@@ -13,14 +13,17 @@ export async function getModelLicenses(): Promise<ModelLicense[]> {
   const asrPath = 'model_licenses/asr-models-license-status.csv';
   const qnnPath = 'model_licenses/qnn-asr-models-license-status.csv';
   const ttsPath = 'model_licenses/tts-models-license-status.csv';
+  const speechEnhancementPath =
+    'model_licenses/speech-enhancement-models-license-status.csv';
 
   const results = await Promise.allSettled([
     SherpaOnnx.readAssetFileAsUtf8(asrPath),
     SherpaOnnx.readAssetFileAsUtf8(qnnPath),
     SherpaOnnx.readAssetFileAsUtf8(ttsPath),
+    SherpaOnnx.readAssetFileAsUtf8(speechEnhancementPath),
   ]);
 
-  const [asrResult, qnnResult, ttsResult] = results;
+  const [asrResult, qnnResult, ttsResult, enhancementResult] = results;
 
   const licenses: ModelLicense[] = [];
 
@@ -48,6 +51,14 @@ export async function getModelLicenses(): Promise<ModelLicense[]> {
     );
   }
 
+  if (enhancementResult.status === 'fulfilled') {
+    licenses.push(...parseCsv(enhancementResult.value));
+  } else {
+    console.warn(
+      `[SherpaOnnx] Failed to load speech enhancement model licenses: ${enhancementResult.reason}`
+    );
+  }
+
   return licenses;
 }
 
@@ -91,7 +102,7 @@ function parseCsv(csvString: string): ModelLicense[] {
       }
     }
 
-    if (entry['asset_name']) {
+    if (entry.asset_name) {
       results.push(entry as unknown as ModelLicense);
     }
   }

package/third_party/sherpa-onnx-prebuilt/ANDROID_RELEASE_TAG

@@ -1 +1 @@
-sherpa-onnx-android-v1.12.34-1
+sherpa-onnx-android-v1.12.34-2