react-native-audio-api 0.12.0-nightly-37d6b7c-20260119 → 0.12.0-nightly-75589dc-20260121

package/src/core/WorkletProcessingNode.ts

@@ -1,3 +1,41 @@
 import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
+import { AudioWorkletRuntime } from '../types';
+import AudioAPIModule from '../AudioAPIModule';
 
-export default class WorkletProcessingNode extends AudioNode {}
+export default class WorkletProcessingNode extends AudioNode {
+  constructor(
+    context: BaseAudioContext,
+    runtime: AudioWorkletRuntime,
+    callback: (
+      inputData: Array<Float32Array>,
+      outputData: Array<Float32Array>,
+      framesToProcess: number,
+      currentTime: number
+    ) => void
+  ) {
+    const shareableWorklet =
+      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
+        (
+          inputBuffers: Array<ArrayBuffer>,
+          outputBuffers: Array<ArrayBuffer>,
+          framesToProcess: number,
+          currentTime: number
+        ) => {
+          'worklet';
+          const inputData: Array<Float32Array> = inputBuffers.map(
+            (buffer) => new Float32Array(buffer, 0, framesToProcess)
+          );
+          const outputData: Array<Float32Array> = outputBuffers.map(
+            (buffer) => new Float32Array(buffer, 0, framesToProcess)
+          );
+          callback(inputData, outputData, framesToProcess, currentTime);
+        }
+      );
+    const node = context.context.createWorkletProcessingNode(
+      shareableWorklet,
+      runtime === 'UIRuntime'
+    );
+    super(context, node);
+  }
+}

package/src/core/WorkletSourceNode.ts

@@ -1,3 +1,38 @@
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import BaseAudioContext from './BaseAudioContext';
+import { AudioWorkletRuntime } from '../types';
+import AudioAPIModule from '../AudioAPIModule';
 
-export default class WorkletSourceNode extends AudioScheduledSourceNode {}
+export default class WorkletSourceNode extends AudioScheduledSourceNode {
+  constructor(
+    context: BaseAudioContext,
+    runtime: AudioWorkletRuntime,
+    callback: (
+      audioData: Array<Float32Array>,
+      framesToProcess: number,
+      currentTime: number,
+      startOffset: number
+    ) => void
+  ) {
+    const shareableWorklet =
+      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
+        (
+          audioBuffers: Array<ArrayBuffer>,
+          framesToProcess: number,
+          currentTime: number,
+          startOffset: number
+        ) => {
+          'worklet';
+          const floatAudioData: Array<Float32Array> = audioBuffers.map(
+            (buffer) => new Float32Array(buffer)
+          );
+          callback(floatAudioData, framesToProcess, currentTime, startOffset);
+        }
+      );
+    const node = context.context.createWorkletSourceNode(
+      shareableWorklet,
+      runtime === 'UIRuntime'
+    );
+    super(context, node);
+  }
+}

package/src/defaults.ts

@@ -0,0 +1,100 @@
+import {
+  TAudioNodeOptions,
+  TGainOptions,
+  TSteroPannerOptions,
+  TConvolverOptions,
+  TConstantSourceOptions,
+  TPeriodicWaveConstraints,
+  TAnalyserOptions,
+  TBiquadFilterOptions,
+  TOscillatorOptions,
+  TBaseAudioBufferSourceOptions,
+  TAudioBufferSourceOptions,
+  TAudioBufferOptions,
+  TDelayOptions,
+  TWaveShaperOptions,
+} from './types';
+
+export const AudioNodeOptions: TAudioNodeOptions = {
+  channelCount: 2,
+  channelCountMode: 'max',
+  channelInterpretation: 'speakers',
+};
+
+export const GainOptions: TGainOptions = {
+  ...AudioNodeOptions,
+  gain: 1,
+};
+
+export const SteroPannerOptions: TSteroPannerOptions = {
+  ...AudioNodeOptions,
+  channelCountMode: 'clamped-max',
+  pan: 0,
+};
+
+export const AnalyserOptions: TAnalyserOptions = {
+  ...AudioNodeOptions,
+  fftSize: 2048,
+  minDecibels: -100,
+  maxDecibels: -30,
+  smoothingTimeConstant: 0.8,
+};
+
+export const BiquadFilterOptions: TBiquadFilterOptions = {
+  ...AudioNodeOptions,
+  Q: 1,
+  detune: 0,
+  frequency: 350,
+  gain: 0,
+  type: 'lowpass',
+};
+
+export const ConvolverOptions: TConvolverOptions = {
+  ...AudioNodeOptions,
+  disableNormalization: false,
+};
+
+export const ConstantSourceOptions: TConstantSourceOptions = {
+  offset: 1,
+};
+
+export const PeriodicWaveConstraints: TPeriodicWaveConstraints = {
+  disableNormalization: false,
+};
+
+export const OscillatorOptions: TOscillatorOptions = {
+  ...AudioNodeOptions,
+  type: 'sine',
+  frequency: 440,
+  detune: 0,
+};
+
+export const BaseAudioBufferSourceOptions: TBaseAudioBufferSourceOptions = {
+  playbackRate: 1,
+  detune: 0,
+  pitchCorrection: false,
+};
+
+export const AudioBufferSourceOptions: TAudioBufferSourceOptions = {
+  ...BaseAudioBufferSourceOptions,
+  loop: false,
+  loopStart: 0,
+  loopEnd: 0,
+};
+
+export const AudioBufferOptions: TAudioBufferOptions = {
+  numberOfChannels: 1,
+  length: 0, // always overwritten by provided value, only placeholder
+  sampleRate: 44100, // always overwritten by provided value, only placeholder
+};
+
+export const DelayOptions: TDelayOptions = {
+  ...AudioNodeOptions,
+  maxDelayTime: 1.0,
+  delayTime: 0.0,
+};
+
+export const WaveShaperOptions: TWaveShaperOptions = {
+  ...AudioNodeOptions,
+  oversample: 'none',
+};

package/src/interfaces.ts

@@ -11,6 +11,20 @@ import type {
   OverSampleType,
   Result,
   WindowType,
+  TGainOptions,
+  TSteroPannerOptions,
+  TConvolverOptions,
+  TConstantSourceOptions,
+  TAnalyserOptions,
+  TBiquadFilterOptions,
+  TOscillatorOptions,
+  TBaseAudioBufferSourceOptions,
+  TAudioBufferSourceOptions,
+  TStreamerOptions,
+  TAudioBufferOptions,
+  TDelayOptions,
+  TIIRFilterOptions,
+  TWaveShaperOptions,
 } from './types';
 
 // IMPORTANT: use only IClass, because it is a part of contract between cpp host object and js layer
@@ -62,37 +76,35 @@ export interface IBaseAudioContext {
     shareableWorklet: ShareableWorkletCallback,
     shouldUseUiRuntime: boolean
   ): IWorkletProcessingNode;
-  createOscillator(): IOscillatorNode;
-  createConstantSource(): IConstantSourceNode;
-  createGain(): IGainNode;
-  createDelay(maxDelayTime: number): IDelayNode;
-  createStereoPanner(): IStereoPannerNode;
-  createBiquadFilter: () => IBiquadFilterNode;
-  createIIRFilter: (
-    feedforward: number[],
-    feedback: number[]
-  ) => IIIRFilterNode;
-  createBufferSource: (pitchCorrection: boolean) => IAudioBufferSourceNode;
+  createOscillator(oscillatorOptions: TOscillatorOptions): IOscillatorNode;
+  createConstantSource(
+    constantSourceOptions: TConstantSourceOptions
+  ): IConstantSourceNode;
+  createGain(gainOptions: TGainOptions): IGainNode;
+  createStereoPanner(
+    stereoPannerOptions: TSteroPannerOptions
+  ): IStereoPannerNode;
+  createBiquadFilter: (
+    biquadFilterOptions: TBiquadFilterOptions
+  ) => IBiquadFilterNode;
+  createBufferSource: (
+    audioBufferSourceOptions: TAudioBufferSourceOptions
+  ) => IAudioBufferSourceNode;
+  createDelay(delayOptions: TDelayOptions): IDelayNode;
+  createIIRFilter: (IIRFilterOptions: TIIRFilterOptions) => IIIRFilterNode;
   createBufferQueueSource: (
-    pitchCorrection: boolean
+    audioBufferQueueSourceOptions: TBaseAudioBufferSourceOptions
   ) => IAudioBufferQueueSourceNode;
-  createBuffer: (
-    channels: number,
-    length: number,
-    sampleRate: number
-  ) => IAudioBuffer;
+  createBuffer: (audioBufferOptions: TAudioBufferOptions) => IAudioBuffer;
   createPeriodicWave: (
     real: Float32Array,
     imag: Float32Array,
     disableNormalization: boolean
   ) => IPeriodicWave;
-  createAnalyser: () => IAnalyserNode;
-  createConvolver: (
-    buffer: IAudioBuffer | undefined,
-    disableNormalization: boolean
-  ) => IConvolverNode;
-  createStreamer: () => IStreamerNode | null; // null when FFmpeg is not enabled
-  createWaveShaper: () => IWaveShaperNode;
+  createAnalyser: (analyserOptions: TAnalyserOptions) => IAnalyserNode;
+  createConvolver: (convolverOptions: TConvolverOptions) => IConvolverNode;
+  createStreamer: (streamerOptions?: TStreamerOptions) => IStreamerNode | null; // null when FFmpeg is not enabled
+  createWaveShaper: (waveShaperOptions?: TWaveShaperOptions) => IWaveShaperNode;
 }
 
 export interface IAudioContext extends IBaseAudioContext {
@@ -186,6 +198,7 @@ export interface IOscillatorNode extends IAudioScheduledSourceNode {
 }
 
 export interface IStreamerNode extends IAudioNode {
+  readonly streamPath: string;
   initialize(streamPath: string): boolean;
 }
 
@@ -304,7 +317,7 @@ export interface IAudioRecorderCallbackOptions
 
 export interface IAudioRecorder {
   // default recorder methods
-  start: () => Result<{ path: string }>;
+  start: (fileNameOverride?: string) => Result<{ path: string }>;
   stop: () => Result<FileInfo>;
   isRecording: () => boolean;
   isPaused: () => boolean;

package/src/options-validators.ts

@@ -0,0 +1,66 @@
+import { IndexSizeError, NotSupportedError } from './errors';
+import {
+  OptionsValidator,
+  TAnalyserOptions,
+  TConvolverOptions,
+  TOscillatorOptions,
+  TPeriodicWaveOptions,
+} from './types';
+
+export const AnalyserOptionsValidator: OptionsValidator<TAnalyserOptions> = {
+  validate(options: TAnalyserOptions): void {
+    const allowedFFTSize: number[] = [
+      32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768,
+    ];
+    if (options.fftSize && !allowedFFTSize.includes(options.fftSize)) {
+      throw new IndexSizeError(
+        `fftSize must be one of the following values: ${allowedFFTSize.join(
+          ', '
+        )}`
+      );
+    }
+  },
+};
+
+export const ConvolverOptionsValidator: OptionsValidator<TConvolverOptions> = {
+  validate(options: TConvolverOptions): void {
+    if (options.buffer) {
+      const numberOfChannels = options.buffer.numberOfChannels;
+      if (
+        numberOfChannels !== 1 &&
+        numberOfChannels !== 2 &&
+        numberOfChannels !== 4
+      ) {
+        throw new NotSupportedError(
+          `The number of channels provided (${numberOfChannels}) in impulse response for ConvolverNode buffer must be 1 or 2 or 4.`
+        );
+      }
+    }
+  },
+};
+
+export const OscillatorOptionsValidator: OptionsValidator<TOscillatorOptions> =
+  {
+    validate(options: TOscillatorOptions): void {
+      if (options.type === 'custom' && !options.periodicWave) {
+        throw new NotSupportedError(
+          "'type' cannot be set to 'custom' without providing a 'periodicWave'."
+        );
+      }
+    },
+  };
+
+export const PeriodicWaveOptionsValidator: OptionsValidator<TPeriodicWaveOptions> =
+  {
+    validate(options: TPeriodicWaveOptions): void {
+      if (
+        options.real &&
+        options.imag &&
+        options.real.length !== options.imag.length
+      ) {
+        throw new NotSupportedError(
+          "'real' and 'imag' arrays must have the same length"
+        );
+      }
+    },
+  };

package/src/types.ts

@@ -1,4 +1,5 @@
 import AudioBuffer from './core/AudioBuffer';
+import PeriodicWave from './core/PeriodicWave';
 
 export type Result<T> =
   | ({ status: 'success' } & T)
@@ -29,10 +30,6 @@ export type OscillatorType =
   | 'triangle'
   | 'custom';
 
-export interface PeriodicWaveConstraints {
-  disableNormalization: boolean;
-}
-
 export interface AudioContextOptions {
   sampleRate?: number;
 }
@@ -110,17 +107,99 @@ export interface FileInfo {
 
 export type WindowType = 'blackman' | 'hann';
 
-export interface AudioBufferBaseSourceNodeOptions {
-  pitchCorrection: boolean;
+export type ProcessorMode = 'processInPlace' | 'processThrough';
+
+export interface TAudioNodeOptions {
+  channelCount?: number;
+  channelCountMode?: ChannelCountMode;
+  channelInterpretation?: ChannelInterpretation;
 }
 
-export type ProcessorMode = 'processInPlace' | 'processThrough';
+export interface TGainOptions extends TAudioNodeOptions {
+  gain?: number;
+}
+
+export interface TSteroPannerOptions extends TAudioNodeOptions {
+  pan?: number;
+}
 
-export interface ConvolverNodeOptions {
-  buffer?: AudioBuffer | null;
+export interface TAnalyserOptions extends TAudioNodeOptions {
+  fftSize?: number;
+  minDecibels?: number;
+  maxDecibels?: number;
+  smoothingTimeConstant?: number;
+}
+
+export interface OptionsValidator<T> {
+  validate(options: T): void;
+}
+
+export interface TBiquadFilterOptions extends TAudioNodeOptions {
+  type?: BiquadFilterType;
+  frequency?: number;
+  detune?: number;
+  Q?: number;
+  gain?: number;
+}
+
+export interface TOscillatorOptions {
+  type?: OscillatorType;
+  frequency?: number;
+  detune?: number;
+  periodicWave?: PeriodicWave;
+}
+
+export interface TBaseAudioBufferSourceOptions {
+  detune?: number;
+  playbackRate?: number;
+  pitchCorrection?: boolean;
+}
+
+export interface TAudioBufferSourceOptions
+  extends TBaseAudioBufferSourceOptions {
+  buffer?: AudioBuffer;
+  loop?: boolean;
+  loopStart?: number;
+  loopEnd?: number;
+}
+
+export interface TConvolverOptions extends TAudioNodeOptions {
+  buffer?: AudioBuffer;
   disableNormalization?: boolean;
 }
 
+export interface TWebConvolverOptions {
+  buffer?: globalThis.AudioBuffer | null;
+  normalize?: boolean;
+}
+
+export interface TConstantSourceOptions {
+  offset?: number;
+}
+
+export interface TStreamerOptions {
+  streamPath?: string;
+}
+
+export interface TPeriodicWaveConstraints {
+  disableNormalization?: boolean;
+}
+
+export interface TPeriodicWaveOptions extends TPeriodicWaveConstraints {
+  real?: Float32Array;
+  imag?: Float32Array;
+}
+
+export interface TAudioBufferOptions {
+  numberOfChannels?: number;
+  length: number;
+  sampleRate: number;
+}
+
+export interface TIIRFilterOptions extends TAudioNodeOptions {
+  feedforward: number[];
+  feedback: number[];
+}
 export type OverSampleType = 'none' | '2x' | '4x';
 
 export interface AudioRecorderCallbackOptions {
@@ -145,9 +224,18 @@ export interface AudioRecorderCallbackOptions {
   channelCount: number;
 }
 
-export interface IIRFilterNodeOptions {
-  feedforward: number[];
-  feedback: number[];
+export interface TDelayOptions extends TAudioNodeOptions {
+  maxDelayTime?: number;
+  delayTime?: number;
+}
+
+export interface TWaveShaperOptions extends TAudioNodeOptions {
+  curve?: Float32Array;
+  oversample?: OverSampleType;
 }
 
 export type DecodeDataInput = number | string | ArrayBuffer;
+
+export interface AudioRecorderStartOptions {
+  fileNameOverride?: string;
+}

package/src/web-core/AnalyserNode.tsx

@@ -1,5 +1,5 @@
 import AudioNode from './AudioNode';
-import { WindowType } from '../types';
+import { WindowType, TAnalyserOptions } from '../types';
 import BaseAudioContext from './BaseAudioContext';
 
 export default class AnalyserNode extends AudioNode {
@@ -9,7 +9,8 @@ export default class AnalyserNode extends AudioNode {
   maxDecibels: number;
   smoothingTimeConstant: number;
 
-  constructor(context: BaseAudioContext, node: globalThis.AnalyserNode) {
+  constructor(context: BaseAudioContext, analyserOptions?: TAnalyserOptions) {
+    const node = new globalThis.AnalyserNode(context.context, analyserOptions);
     super(context, node);
 
     this.fftSize = node.fftSize;
@@ -30,18 +31,26 @@ export default class AnalyserNode extends AudioNode {
   }
 
   public getByteFrequencyData(array: Uint8Array): void {
-    (this.node as globalThis.AnalyserNode).getByteFrequencyData(array);
+    (this.node as globalThis.AnalyserNode).getByteFrequencyData(
+      array as Uint8Array<ArrayBuffer>
+    );
   }
 
   public getByteTimeDomainData(array: Uint8Array): void {
-    (this.node as globalThis.AnalyserNode).getByteTimeDomainData(array);
+    (this.node as globalThis.AnalyserNode).getByteTimeDomainData(
+      array as Uint8Array<ArrayBuffer>
+    );
   }
 
   public getFloatFrequencyData(array: Float32Array): void {
-    (this.node as globalThis.AnalyserNode).getFloatFrequencyData(array);
+    (this.node as globalThis.AnalyserNode).getFloatFrequencyData(
+      array as Float32Array<ArrayBuffer>
+    );
   }
 
   public getFloatTimeDomainData(array: Float32Array): void {
-    (this.node as globalThis.AnalyserNode).getFloatTimeDomainData(array);
+    (this.node as globalThis.AnalyserNode).getFloatTimeDomainData(
+      array as Float32Array<ArrayBuffer>
+    );
   }
 }

package/src/web-core/AudioBuffer.tsx

@@ -1,4 +1,6 @@
 import { IndexSizeError } from '../errors';
+import BaseAudioContext from './BaseAudioContext';
+import { TAudioBufferOptions } from '../types';
 
 export default class AudioBuffer {
   readonly length: number;
@@ -9,12 +11,24 @@ export default class AudioBuffer {
   /** @internal */
   public readonly buffer: globalThis.AudioBuffer;
 
-  constructor(buffer: globalThis.AudioBuffer) {
-    this.buffer = buffer;
-    this.length = buffer.length;
-    this.duration = buffer.duration;
-    this.sampleRate = buffer.sampleRate;
-    this.numberOfChannels = buffer.numberOfChannels;
+  constructor(buffer: globalThis.AudioBuffer);
+  constructor(context: BaseAudioContext, options: TAudioBufferOptions);
+
+  constructor(
+    contextOrBuffer: BaseAudioContext | globalThis.AudioBuffer,
+    options?: TAudioBufferOptions
+  ) {
+    let buf: globalThis.AudioBuffer;
+    if (contextOrBuffer instanceof BaseAudioContext) {
+      buf = new globalThis.AudioBuffer(options!);
+    } else {
+      buf = contextOrBuffer as globalThis.AudioBuffer;
+    }
+    this.buffer = buf;
+    this.length = buf.length;
+    this.duration = buf.duration;
+    this.sampleRate = buf.sampleRate;
+    this.numberOfChannels = buf.numberOfChannels;
   }
 
   public getChannelData(channel: number): Float32Array {