Audio Utilities

function createPcmLiveStream(
  options?: PcmLiveStreamOptions
): PcmLiveStreamHandle

<uses-permission android:name="android.permission.RECORD_AUDIO" />

<key>NSMicrophoneUsageDescription</key>
<string>This app needs microphone access for speech recognition</string>

import { PermissionsAndroid, Platform } from 'react-native';

if (Platform.OS === 'android') {
  await PermissionsAndroid.request(
    PermissionsAndroid.PERMISSIONS.RECORD_AUDIO
  );
}

import { createPcmLiveStream } from 'react-native-sherpa-onnx/audio';

const mic = createPcmLiveStream({
  sampleRate: 16000,
  channelCount: 1,
});

// Handle audio data
const unsubscribeData = mic.onData((samples, sampleRate) => {
  console.log('Received', samples.length, 'samples at', sampleRate, 'Hz');
  // samples is Float32Array in range [-1, 1]
});

// Handle errors
const unsubscribeError = mic.onError((message) => {
  console.error('Microphone error:', message);
});

// Start recording
await mic.start();

// Later: stop recording
await mic.stop();
unsubscribeData();
unsubscribeError();

import { createPcmLiveStream } from 'react-native-sherpa-onnx/audio';
import { createStreamingSTT, assetModelPath } from 'react-native-sherpa-onnx/stt';

const engine = await createStreamingSTT({
  modelPath: assetModelPath('models/streaming-zipformer-en'),
  modelType: 'auto',
});

const stream = await engine.createStream();

const mic = createPcmLiveStream({ sampleRate: 16000 });

const unsubscribe = mic.onData(async (samples, sampleRate) => {
  const { result, isEndpoint } = await stream.processAudioChunk(
    samples,
    sampleRate
  );
  
  console.log('Live transcription:', result.text);
  
  if (isEndpoint) {
    console.log('Utterance complete:', result.text);
    await stream.reset();
  }
});

await mic.start();

// Later: cleanup
await mic.stop();
unsubscribe();
await stream.release();
await engine.destroy();

function convertAudioToFormat(
  inputPath: string,
  outputPath: string,
  format: string,
  outputSampleRateHz?: number
): Promise<void>

import { convertAudioToFormat } from 'react-native-sherpa-onnx/audio';
import { DocumentDirectoryPath } from '@dr.pogodin/react-native-fs';

// Convert to MP3
await convertAudioToFormat(
  `${DocumentDirectoryPath}/input.wav`,
  `${DocumentDirectoryPath}/output.mp3`,
  'mp3',
  44100
);

// Convert to FLAC
await convertAudioToFormat(
  `${DocumentDirectoryPath}/input.m4a`,
  `${DocumentDirectoryPath}/output.flac`,
  'flac'
);

function convertAudioToWav16k(
  inputPath: string,
  outputPath: string
): Promise<void>

import { convertAudioToWav16k } from 'react-native-sherpa-onnx/audio';
import { createSTT, assetModelPath } from 'react-native-sherpa-onnx/stt';
import { DocumentDirectoryPath } from '@dr.pogodin/react-native-fs';

const inputPath = `${DocumentDirectoryPath}/recording.m4a`;
const wavPath = `${DocumentDirectoryPath}/recording-16k.wav`;

// Convert to 16kHz mono WAV
await convertAudioToWav16k(inputPath, wavPath);

// Transcribe
const stt = await createSTT({
  modelPath: assetModelPath('models/whisper-tiny'),
});

const result = await stt.transcribeFile(wavPath);
console.log('Transcription:', result.text);

await stt.destroy();

interface PcmLiveStreamOptions {
  /** Target sample rate in Hz (e.g., 16000) */
  sampleRate?: number;
  
  /** Number of audio channels (1 = mono, 2 = stereo) */
  channelCount?: number;
  
  /** Buffer size in frames (0 = auto) */
  bufferSizeFrames?: number;
}

interface PcmLiveStreamHandle {
  start(): Promise<void>;
  stop(): Promise<void>;
  onData(
    callback: (samples: Float32Array, sampleRate: number) => void
  ): () => void;
  onError(callback: (message: string) => void): () => void;
}