Source Separation

npm install react-native-sherpa-onnx

import { initializeSeparation, separateSources } from 'react-native-sherpa-onnx/separation';

// Initialize separation with model
await initializeSeparation({
  modelPath: {
    type: 'auto',
    path: 'models/separation-model'
  }
});

// Separate mixed audio
const sources = await separateSources('path/to/mixed-audio.wav');

console.log('Separated sources:', sources);
// [
//   { sourceId: 'vocals', outputPath: '/tmp/vocals.wav' },
//   { sourceId: 'music', outputPath: '/tmp/music.wav' }
// ]

await initializeSeparation(options: SeparationInitializeOptions): Promise<void>

await initializeSeparation({
  modelPath: {
    type: 'auto',
    path: 'models/demucs-separation'
  }
});

await separateSources(filePath: string): Promise<SeparatedSource[]>

const sources = await separateSources('/path/to/recording-with-music.wav');

for (const source of sources) {
  console.log(`${source.sourceId}: ${source.outputPath}`);
  
  // Process each source separately
  if (source.sourceId === 'speech') {
    await transcribeRecognizer({ filePath: source.outputPath });
  }
}

await unloadSeparation(): Promise<void>

// When done with separation
await unloadSeparation();

interface SeparationInitializeOptions {
  modelPath: ModelPathConfig;
  // Additional options will be added in v0.6.0
}

interface SeparatedSource {
  sourceId: string;    // Source identifier (e.g., "vocals", "music")
  outputPath: string;  // Path to separated audio file
  // Additional fields will be added in v0.6.0
}

interface ModelPathConfig {
  type: 'auto' | 'file';
  path: string;
}

import { initializeSeparation, separateSources } from 'react-native-sherpa-onnx/separation';
import { transcribeRecognizer } from 'react-native-sherpa-onnx';

async function transcribeWithMusic(audioPath: string) {
  // Initialize separation
  await initializeSeparation({
    modelPath: { type: 'auto', path: 'models/speech-music-separation' }
  });
  
  // Separate speech from music
  console.log('Separating audio sources...');
  const sources = await separateSources(audioPath);
  
  // Find speech source
  const speechSource = sources.find(s => s.sourceId === 'speech');
  
  if (speechSource) {
    // Transcribe isolated speech
    const result = await transcribeRecognizer({ 
      filePath: speechSource.outputPath 
    });
    return result.text;
  } else {
    throw new Error('No speech source found in audio');
  }
}

import { initializeSeparation, separateSources } from 'react-native-sherpa-onnx/separation';

async function createKaraoke(musicPath: string, outputPath: string) {
  await initializeSeparation({
    modelPath: { type: 'auto', path: 'models/vocal-separation' }
  });
  
  // Separate vocals and instrumentals
  const sources = await separateSources(musicPath);
  
  // Get instrumental track (music without vocals)
  const instrumental = sources.find(s => s.sourceId === 'music');
  
  if (instrumental) {
    // Copy instrumental to desired output
    await copyFile(instrumental.outputPath, outputPath);
    console.log('Karaoke track created:', outputPath);
    return outputPath;
  }
}

import { separateSources } from 'react-native-sherpa-onnx/separation';

async function analyzeAudioComposition(audioPath: string) {
  const sources = await separateSources(audioPath);
  
  // Analyze each separated source
  const analysis = await Promise.all(
    sources.map(async source => {
      const stats = await analyzeAudioFile(source.outputPath);
      return {
        sourceId: source.sourceId,
        duration: stats.duration,
        averageVolume: stats.averageVolume,
        spectralCentroid: stats.spectralCentroid
      };
    })
  );
  
  console.log('Audio composition:', analysis);
  return analysis;
}

import { separateSources } from 'react-native-sherpa-onnx/separation';
import { readdir } from 'fs/promises';
import { join } from 'path';

async function separateBatch(inputDir: string, outputDir: string) {
  const files = await readdir(inputDir);
  const audioFiles = files.filter(f => f.endsWith('.wav'));
  
  console.log(`Separating ${audioFiles.length} files...`);
  
  for (const file of audioFiles) {
    console.log(`Processing: ${file}`);
    const inputPath = join(inputDir, file);
    const sources = await separateSources(inputPath);
    
    // Save each source to output directory
    for (const source of sources) {
      const outputFilename = `${file.replace('.wav', '')}_${source.sourceId}.wav`;
      const outputPath = join(outputDir, outputFilename);
      await copyFile(source.outputPath, outputPath);
    }
  }
  
  console.log('Batch separation complete');
}

try {
  await initializeSeparation({
    modelPath: {
      type: 'auto',
      path: 'models/separation'
    }
  });
  
  const sources = await separateSources('mixed-audio.wav');
  
  if (sources.length === 0) {
    console.log('No sources could be separated from audio');
  } else {
    console.log(`Successfully separated ${sources.length} source(s)`);
    sources.forEach(s => console.log(`  - ${s.sourceId}: ${s.outputPath}`));
  }
  
} catch (error) {
  if (error.message.includes('model not found')) {
    console.error('Separation model not found. Please download the model.');
  } else if (error.message.includes('unsupported format')) {
    console.error('Audio format not supported. Convert to WAV format.');
  } else {
    console.error('Separation error:', error);
  }
} finally {
  await unloadSeparation();
}