react-native-audio-api 0.8.3 → 0.9.0-nightly-7ecb495-20251008

package/src/core/AudioScheduledSourceNode.ts

@@ -10,7 +10,7 @@ export default class AudioScheduledSourceNode extends AudioNode {
     global.AudioEventEmitter
   );
 
-  private onendedSubscription?: AudioEventSubscription;
+  private onEndedSubscription?: AudioEventSubscription;
   private onEndedCallback?: (event: OnEndedEventType) => void;
 
   public start(when: number = 0): void {
@@ -51,19 +51,19 @@ export default class AudioScheduledSourceNode extends AudioNode {
   public set onEnded(callback: ((event: OnEndedEventType) => void) | null) {
     if (!callback) {
       (this.node as IAudioScheduledSourceNode).onEnded = '0';
-      this.onendedSubscription?.remove();
-      this.onendedSubscription = undefined;
+      this.onEndedSubscription?.remove();
+      this.onEndedSubscription = undefined;
       this.onEndedCallback = undefined;
       return;
     }
 
     this.onEndedCallback = callback;
-    this.onendedSubscription = this.audioEventEmitter.addAudioEventListener(
+    this.onEndedSubscription = this.audioEventEmitter.addAudioEventListener(
       'ended',
       callback
     );
 
     (this.node as IAudioScheduledSourceNode).onEnded =
-      this.onendedSubscription.subscriptionId;
+      this.onEndedSubscription.subscriptionId;
   }
 }

package/src/core/AudioStretcher.ts

@@ -0,0 +1,43 @@
+import { IAudioStretcher } from '../interfaces';
+import AudioBuffer from './AudioBuffer';
+
+class AudioStretcher {
+  private static instance: AudioStretcher | null = null;
+  protected readonly stretcher: IAudioStretcher;
+
+  private constructor() {
+    this.stretcher = global.createAudioStretcher();
+  }
+
+  public static getInstance(): AudioStretcher {
+    if (!AudioStretcher.instance) {
+      AudioStretcher.instance = new AudioStretcher();
+    }
+    return AudioStretcher.instance;
+  }
+
+  public async changePlaybackSpeedInstance(
+    input: AudioBuffer,
+    playbackSpeed: number
+  ): Promise<AudioBuffer> {
+    const buffer = await this.stretcher.changePlaybackSpeed(
+      input.buffer,
+      playbackSpeed
+    );
+
+    if (!buffer) {
+      throw new Error('Failed to change playback speed');
+    }
+    return new AudioBuffer(buffer);
+  }
+}
+
+export default async function changePlaybackSpeed(
+  input: AudioBuffer,
+  playbackSpeed: number
+): Promise<AudioBuffer> {
+  return AudioStretcher.getInstance().changePlaybackSpeedInstance(
+    input,
+    playbackSpeed
+  );
+}

package/src/core/BaseAudioContext.ts

@@ -1,22 +1,29 @@
+import { InvalidAccessError, NotSupportedError } from '../errors';
 import { IBaseAudioContext } from '../interfaces';
 import {
+  AudioBufferBaseSourceNodeOptions,
   ContextState,
   PeriodicWaveConstraints,
-  AudioBufferSourceNodeOptions,
+  AudioWorkletRuntime,
 } from '../types';
+import { isWorkletsAvailable, workletsModule } from '../utils';
+import WorkletSourceNode from './WorkletSourceNode';
+import WorkletProcessingNode from './WorkletProcessingNode';
+import AnalyserNode from './AnalyserNode';
+import AudioBuffer from './AudioBuffer';
+import AudioBufferQueueSourceNode from './AudioBufferQueueSourceNode';
+import AudioBufferSourceNode from './AudioBufferSourceNode';
 import AudioDestinationNode from './AudioDestinationNode';
-import OscillatorNode from './OscillatorNode';
-import GainNode from './GainNode';
-import StereoPannerNode from './StereoPannerNode';
 import BiquadFilterNode from './BiquadFilterNode';
-import AudioBufferSourceNode from './AudioBufferSourceNode';
-import AudioBuffer from './AudioBuffer';
+import ConstantSourceNode from './ConstantSourceNode';
+import GainNode from './GainNode';
+import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
-import AnalyserNode from './AnalyserNode';
-import AudioBufferQueueSourceNode from './AudioBufferQueueSourceNode';
-import StreamerNode from './StreamerNode';
-import { InvalidAccessError, NotSupportedError } from '../errors';
 import RecorderAdapterNode from './RecorderAdapterNode';
+import StereoPannerNode from './StereoPannerNode';
+import StreamerNode from './StreamerNode';
+import WorkletNode from './WorkletNode';
+import { decodeAudioData, decodePCMInBase64 } from './AudioDecoder';
 
 export default class BaseAudioContext {
   readonly destination: AudioDestinationNode;
@@ -37,6 +44,152 @@ export default class BaseAudioContext {
     return this.context.state;
   }
 
+  public async decodeAudioData(
+    input: string | ArrayBuffer,
+    sampleRate?: number
+  ): Promise<AudioBuffer> {
+    if (!(typeof input === 'string' || input instanceof ArrayBuffer)) {
+      throw new TypeError('Input must be a string or ArrayBuffer');
+    }
+    return await decodeAudioData(input, sampleRate ?? this.sampleRate);
+  }
+
+  public async decodePCMInBase64(
+    base64String: string,
+    inputSampleRate: number,
+    inputChannelCount: number,
+    isInterleaved: boolean = true
+  ): Promise<AudioBuffer> {
+    return await decodePCMInBase64(
+      base64String,
+      inputSampleRate,
+      inputChannelCount,
+      isInterleaved
+    );
+  }
+
+  createWorkletNode(
+    callback: (audioData: Array<Float32Array>, channelCount: number) => void,
+    bufferLength: number,
+    inputChannelCount: number,
+    workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
+  ): WorkletNode {
+    if (inputChannelCount < 1 || inputChannelCount > 32) {
+      throw new NotSupportedError(
+        `The number of input channels provided (${inputChannelCount}) can not be less than 1 or greater than 32`
+      );
+    }
+    if (bufferLength < 1) {
+      throw new NotSupportedError(
+        `The buffer length provided (${bufferLength}) can not be less than 1`
+      );
+    }
+
+    if (isWorkletsAvailable) {
+      const shareableWorklet = workletsModule.makeShareableCloneRecursive(
+        (audioBuffers: Array<ArrayBuffer>, channelCount: number) => {
+          'worklet';
+          const floatAudioData: Array<Float32Array> = audioBuffers.map(
+            (buffer) => new Float32Array(buffer)
+          );
+          callback(floatAudioData, channelCount);
+        }
+      );
+      return new WorkletNode(
+        this,
+        this.context.createWorkletNode(
+          shareableWorklet,
+          workletRuntime === 'UIRuntime',
+          bufferLength,
+          inputChannelCount
+        )
+      );
+    }
+    /// User does not have worklets as a dependency so he cannot use the worklet API.
+    throw new Error(
+      '[RnAudioApi] Worklets are not available, please install react-native-worklets as a dependency. Refer to documentation for more details.'
+    );
+  }
+
+  createWorkletProcessingNode(
+    callback: (
+      inputData: Array<Float32Array>,
+      outputData: Array<Float32Array>,
+      framesToProcess: number,
+      currentTime: number
+    ) => void,
+    workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
+  ): WorkletProcessingNode {
+    if (isWorkletsAvailable) {
+      const shareableWorklet = 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);
+        }
+      );
+      return new WorkletProcessingNode(
+        this,
+        this.context.createWorkletProcessingNode(
+          shareableWorklet,
+          workletRuntime === 'UIRuntime'
+        )
+      );
+    }
+    /// User does not have worklets as a dependency so he cannot use the worklet API.
+    throw new Error(
+      '[RnAudioApi] Worklets are not available, please install react-native-worklets as a dependency. Refer to documentation for more details.'
+    );
+  }
+
+  createWorkletSourceNode(
+    callback: (
+      audioData: Array<Float32Array>,
+      framesToProcess: number,
+      currentTime: number,
+      startOffset: number
+    ) => void,
+    workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
+  ): WorkletSourceNode {
+    if (!isWorkletsAvailable) {
+      /// User does not have worklets as a dependency so he cannot use the worklet API.
+      throw new Error(
+        '[RnAudioApi] Worklets are not available, please install react-native-worklets as a dependency. Refer to documentation for more details.'
+      );
+    }
+    const shareableWorklet = 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);
+      }
+    );
+    return new WorkletSourceNode(
+      this,
+      this.context.createWorkletSourceNode(
+        shareableWorklet,
+        workletRuntime === 'UIRuntime'
+      )
+    );
+  }
+
   createRecorderAdapter(): RecorderAdapterNode {
     return new RecorderAdapterNode(this, this.context.createRecorderAdapter());
   }
@@ -49,6 +202,10 @@ export default class BaseAudioContext {
     return new StreamerNode(this, this.context.createStreamer());
   }
 
+  createConstantSource(): ConstantSourceNode {
+    return new ConstantSourceNode(this, this.context.createConstantSource());
+  }
+
   createGain(): GainNode {
     return new GainNode(this, this.context.createGain());
   }
@@ -62,7 +219,7 @@ export default class BaseAudioContext {
   }
 
   createBufferSource(
-    options?: AudioBufferSourceNodeOptions
+    options?: AudioBufferBaseSourceNodeOptions
   ): AudioBufferSourceNode {
     const pitchCorrection = options?.pitchCorrection ?? false;
 
@@ -72,10 +229,14 @@ export default class BaseAudioContext {
     );
   }
 
-  createBufferQueueSource(): AudioBufferQueueSourceNode {
+  createBufferQueueSource(
+    options?: AudioBufferBaseSourceNodeOptions
+  ): AudioBufferQueueSourceNode {
+    const pitchCorrection = options?.pitchCorrection ?? false;
+
     return new AudioBufferQueueSourceNode(
       this,
-      this.context.createBufferQueueSource()
+      this.context.createBufferQueueSource(pitchCorrection)
     );
   }
 
@@ -128,32 +289,4 @@ export default class BaseAudioContext {
   createAnalyser(): AnalyserNode {
     return new AnalyserNode(this, this.context.createAnalyser());
   }
-
-  /** Decodes audio data from a local file path. */
-  async decodeAudioDataSource(sourcePath: string): Promise<AudioBuffer> {
-    // Remove the file:// prefix if it exists
-    if (sourcePath.startsWith('file://')) {
-      sourcePath = sourcePath.replace('file://', '');
-    }
-
-    return new AudioBuffer(
-      await this.context.decodeAudioDataSource(sourcePath)
-    );
-  }
-
-  /** Decodes audio data from an ArrayBuffer. */
-  async decodeAudioData(data: ArrayBuffer): Promise<AudioBuffer> {
-    return new AudioBuffer(
-      await this.context.decodeAudioData(new Uint8Array(data))
-    );
-  }
-
-  async decodePCMInBase64Data(
-    base64: string,
-    playbackRate: number = 1.0
-  ): Promise<AudioBuffer> {
-    return new AudioBuffer(
-      await this.context.decodePCMAudioDataInBase64(base64, playbackRate)
-    );
-  }
 }

package/src/core/ConstantSourceNode.ts

@@ -0,0 +1,13 @@
+import { IConstantSourceNode } from '../interfaces';
+import AudioParam from './AudioParam';
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class ConstantSourceNode extends AudioScheduledSourceNode {
+  readonly offset: AudioParam;
+
+  constructor(context: BaseAudioContext, node: IConstantSourceNode) {
+    super(context, node);
+    this.offset = new AudioParam(node.offset, context);
+  }
+}

package/src/core/OfflineAudioContext.ts

@@ -3,12 +3,17 @@ import BaseAudioContext from './BaseAudioContext';
 import { OfflineAudioContextOptions } from '../types';
 import { InvalidStateError, NotSupportedError } from '../errors';
 import AudioBuffer from './AudioBuffer';
+import { isWorkletsAvailable, workletsModule } from '../utils';
 
 export default class OfflineAudioContext extends BaseAudioContext {
   private isSuspended: boolean;
   private isRendering: boolean;
   private duration: number;
 
+  // We need to keep here a reference to this runtime to better manage its lifecycle
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  private _audioRuntime: any;
+
   constructor(options: OfflineAudioContextOptions);
   constructor(numberOfChannels: number, length: number, sampleRate: number);
   constructor(
@@ -16,10 +21,20 @@ export default class OfflineAudioContext extends BaseAudioContext {
     arg1?: number,
     arg2?: number
   ) {
+    let audioRuntime = null;
+    if (isWorkletsAvailable) {
+      audioRuntime = workletsModule.createWorkletRuntime('AudioWorkletRuntime');
+    }
+
     if (typeof arg0 === 'object') {
       const { numberOfChannels, length, sampleRate } = arg0;
       super(
-        global.createOfflineAudioContext(numberOfChannels, length, sampleRate)
+        global.createOfflineAudioContext(
+          numberOfChannels,
+          length,
+          sampleRate,
+          audioRuntime
+        )
       );
 
       this.duration = length / sampleRate;
@@ -28,7 +43,7 @@ export default class OfflineAudioContext extends BaseAudioContext {
       typeof arg1 === 'number' &&
       typeof arg2 === 'number'
     ) {
-      super(global.createOfflineAudioContext(arg0, arg1, arg2));
+      super(global.createOfflineAudioContext(arg0, arg1, arg2, audioRuntime));
       this.duration = arg1 / arg2;
     } else {
       throw new NotSupportedError('Invalid constructor arguments');
@@ -36,6 +51,7 @@ export default class OfflineAudioContext extends BaseAudioContext {
 
     this.isSuspended = false;
     this.isRendering = false;
+    this._audioRuntime = audioRuntime;
   }
 
   async resume(): Promise<undefined> {

package/src/core/OscillatorNode.ts

@@ -5,6 +5,7 @@ import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
 import PeriodicWave from './PeriodicWave';
 import { InvalidStateError } from '../errors';
+import { EventEmptyType } from '../events/types';
 
 export default class OscillatorNode extends AudioScheduledSourceNode {
   readonly frequency: AudioParam;
@@ -34,4 +35,14 @@ export default class OscillatorNode extends AudioScheduledSourceNode {
   public setPeriodicWave(wave: PeriodicWave): void {
     (this.node as IOscillatorNode).setPeriodicWave(wave.periodicWave);
   }
+
+  public override get onEnded(): ((event: EventEmptyType) => void) | undefined {
+    return super.onEnded as ((event: EventEmptyType) => void) | undefined;
+  }
+
+  public override set onEnded(
+    callback: ((event: EventEmptyType) => void) | null
+  ) {
+    super.onEnded = callback;
+  }
 }

package/src/core/WorkletNode.ts

@@ -0,0 +1,3 @@
+import AudioNode from './AudioNode';
+
+export default class WorkletNode extends AudioNode {}

package/src/core/WorkletProcessingNode.ts

@@ -0,0 +1,3 @@
+import AudioNode from './AudioNode';
+
+export default class WorkletProcessingNode extends AudioNode {}

package/src/core/WorkletSourceNode.ts

@@ -0,0 +1,3 @@
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+
+export default class WorkletSourceNode extends AudioScheduledSourceNode {}

package/src/events/types.ts

@@ -46,6 +46,7 @@ type SystemEvents = RemoteCommandEvents & {
 
 export interface OnEndedEventType extends EventEmptyType {
   bufferId: string | undefined;
+  isLast: boolean | undefined;
 }
 
 export interface OnAudioReadyEventType {
@@ -56,6 +57,7 @@ export interface OnAudioReadyEventType {
 
 interface AudioAPIEvents {
   ended: OnEndedEventType;
+  loopEnded: EventEmptyType;
   audioReady: OnAudioReadyEventType;
   positionChanged: EventTypeWithValue;
   audioError: EventEmptyType; // to change

package/src/interfaces.ts

@@ -1,26 +1,69 @@
+import { AudioEventCallback, AudioEventName } from './events/types';
 import {
-  WindowType,
-  ContextState,
-  OscillatorType,
   BiquadFilterType,
   ChannelCountMode,
   ChannelInterpretation,
+  ContextState,
+  OscillatorType,
+  WindowType,
 } from './types';
-import { AudioEventName, AudioEventCallback } from './events/types';
+
+export type WorkletNodeCallback = (
+  audioData: Array<ArrayBuffer>,
+  channelCount: number
+) => void;
+
+export type WorkletSourceNodeCallback = (
+  audioData: Array<ArrayBuffer>,
+  framesToProcess: number,
+  currentTime: number,
+  startOffset: number
+) => void;
+
+export type WorkletProcessingNodeCallback = (
+  inputData: Array<ArrayBuffer>,
+  outputData: Array<ArrayBuffer>,
+  framesToProcess: number,
+  currentTime: number
+) => void;
+
+export type ShareableWorkletCallback =
+  | WorkletNodeCallback
+  | WorkletSourceNodeCallback
+  | WorkletProcessingNodeCallback;
 
 export interface IBaseAudioContext {
   readonly destination: IAudioDestinationNode;
   readonly state: ContextState;
   readonly sampleRate: number;
   readonly currentTime: number;
+  readonly decoder: IAudioDecoder;
+  readonly stretcher: IAudioStretcher;
 
   createRecorderAdapter(): IRecorderAdapterNode;
+  createWorkletSourceNode(
+    shareableWorklet: ShareableWorkletCallback,
+    shouldUseUiRuntime: boolean
+  ): IWorkletSourceNode;
+  createWorkletNode(
+    shareableWorklet: ShareableWorkletCallback,
+    shouldUseUiRuntime: boolean,
+    bufferLength: number,
+    inputChannelCount: number
+  ): IWorkletNode;
+  createWorkletProcessingNode(
+    shareableWorklet: ShareableWorkletCallback,
+    shouldUseUiRuntime: boolean
+  ): IWorkletProcessingNode;
   createOscillator(): IOscillatorNode;
+  createConstantSource(): IConstantSourceNode;
   createGain(): IGainNode;
   createStereoPanner(): IStereoPannerNode;
   createBiquadFilter: () => IBiquadFilterNode;
   createBufferSource: (pitchCorrection: boolean) => IAudioBufferSourceNode;
-  createBufferQueueSource: () => IAudioBufferQueueSourceNode;
+  createBufferQueueSource: (
+    pitchCorrection: boolean
+  ) => IAudioBufferQueueSourceNode;
   createBuffer: (
     channels: number,
     length: number,
@@ -32,12 +75,6 @@ export interface IBaseAudioContext {
     disableNormalization: boolean
   ) => IPeriodicWave;
   createAnalyser: () => IAnalyserNode;
-  decodeAudioDataSource: (sourcePath: string) => Promise<IAudioBuffer>;
-  decodeAudioData: (arrayBuffer: ArrayBuffer) => Promise<IAudioBuffer>;
-  decodePCMAudioDataInBase64: (
-    b64: string,
-    playbackRate: number
-  ) => Promise<IAudioBuffer>;
   createStreamer: () => IStreamerNode;
 }
 
@@ -119,6 +156,10 @@ export interface IStreamerNode extends IAudioNode {
   initialize(streamPath: string): boolean;
 }
 
+export interface IConstantSourceNode extends IAudioScheduledSourceNode {
+  readonly offset: IAudioParam;
+}
+
 export interface IAudioBufferSourceNode extends IAudioBufferBaseSourceNode {
   buffer: IAudioBuffer | null;
   loop: boolean;
@@ -128,6 +169,9 @@ export interface IAudioBufferSourceNode extends IAudioBufferBaseSourceNode {
 
   start: (when?: number, offset?: number, duration?: number) => void;
   setBuffer: (audioBuffer: IAudioBuffer | null) => void;
+
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onLoopEnded: string;
 }
 
 export interface IAudioBufferQueueSourceNode
@@ -200,6 +244,12 @@ export interface IAnalyserNode extends IAudioNode {
 
 export interface IRecorderAdapterNode extends IAudioNode {}
 
+export interface IWorkletNode extends IAudioNode {}
+
+export interface IWorkletSourceNode extends IAudioScheduledSourceNode {}
+
+export interface IWorkletProcessingNode extends IAudioNode {}
+
 export interface IAudioRecorder {
   start: () => void;
   stop: () => void;
@@ -210,6 +260,30 @@ export interface IAudioRecorder {
   onAudioReady: string;
 }
 
+export interface IAudioDecoder {
+  decodeWithMemoryBlock: (
+    arrayBuffer: ArrayBuffer,
+    sampleRate?: number
+  ) => Promise<IAudioBuffer>;
+  decodeWithFilePath: (
+    sourcePath: string,
+    sampleRate?: number
+  ) => Promise<IAudioBuffer>;
+  decodeWithPCMInBase64: (
+    b64: string,
+    inputSampleRate: number,
+    inputChannelCount: number,
+    interleaved?: boolean
+  ) => Promise<IAudioBuffer>;
+}
+
+export interface IAudioStretcher {
+  changePlaybackSpeed: (
+    arrayBuffer: AudioBuffer,
+    playbackSpeed: number
+  ) => Promise<IAudioBuffer>;
+}
+
 export interface IAudioEventEmitter {
   addAudioEventListener<Name extends AudioEventName>(
     name: Name,

package/src/types.ts

@@ -14,6 +14,8 @@ export type BiquadFilterType =
 
 export type ContextState = 'running' | 'closed' | `suspended`;
 
+export type AudioWorkletRuntime = 'AudioRuntime' | 'UIRuntime';
+
 export type OscillatorType =
   | 'sine'
   | 'square'
@@ -43,7 +45,7 @@ export interface AudioRecorderOptions {
 
 export type WindowType = 'blackman' | 'hann';
 
-export interface AudioBufferSourceNodeOptions {
+export interface AudioBufferBaseSourceNodeOptions {
   pitchCorrection: boolean;
 }
 

package/src/utils/index.ts

@@ -1,3 +1,24 @@
+import type { ShareableWorkletCallback } from '../interfaces';
+
+interface SimplifiedWorkletModule {
+  makeShareableCloneRecursive: (
+    workletCallback: ShareableWorkletCallback
+  ) => ShareableWorkletCallback;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  createWorkletRuntime: (options?: any) => any;
+}
+
 export function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
 }
+
+export let isWorkletsAvailable = false;
+export let workletsModule: SimplifiedWorkletModule;
+
+try {
+  workletsModule = require('react-native-worklets');
+  isWorkletsAvailable = true;
+} catch (error) {
+  isWorkletsAvailable = false;
+}

package/src/web-core/AudioBufferSourceNode.tsx

@@ -26,7 +26,7 @@ interface IStretcherNode extends globalThis.AudioNode {
   numberOfInputs: number;
   numberOfOutputs: number;
 
-  onended:
+  onEnded:
     | ((this: globalThis.AudioScheduledSourceNode, ev: Event) => unknown)
     | null;
   addEventListener: (