react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.2

package/src/core/IIRFilterNode.ts

@@ -0,0 +1,25 @@
+import { NotSupportedError } from '../errors';
+import { IIIRFilterNode } from '../interfaces';
+import AudioNode from './AudioNode';
+
+export default class IIRFilterNode extends AudioNode {
+  public getFrequencyResponse(
+    frequencyArray: Float32Array,
+    magResponseOutput: Float32Array,
+    phaseResponseOutput: Float32Array
+  ) {
+    if (
+      frequencyArray.length !== magResponseOutput.length ||
+      frequencyArray.length !== phaseResponseOutput.length
+    ) {
+      throw new NotSupportedError(
+        `The lengths of the arrays are not the same frequencyArray: ${frequencyArray.length}, magResponseOutput: ${magResponseOutput.length}, phaseResponseOutput: ${phaseResponseOutput.length}`
+      );
+    }
+    (this.node as IIIRFilterNode).getFrequencyResponse(
+      frequencyArray,
+      magResponseOutput,
+      phaseResponseOutput
+    );
+  }
+}

package/src/core/OfflineAudioContext.ts

@@ -1,9 +1,9 @@
+import AudioAPIModule from '../AudioAPIModule';
+import { InvalidStateError, NotSupportedError } from '../errors';
 import { IOfflineAudioContext } from '../interfaces';
-import BaseAudioContext from './BaseAudioContext';
 import { OfflineAudioContextOptions } from '../types';
-import { InvalidStateError, NotSupportedError } from '../errors';
 import AudioBuffer from './AudioBuffer';
-import { isWorkletsAvailable, workletsModule } from '../utils';
+import BaseAudioContext from './BaseAudioContext';
 
 export default class OfflineAudioContext extends BaseAudioContext {
   private isSuspended: boolean;
@@ -17,10 +17,7 @@ export default class OfflineAudioContext extends BaseAudioContext {
     arg1?: number,
     arg2?: number
   ) {
-    let audioRuntime = null;
-    if (isWorkletsAvailable) {
-      audioRuntime = workletsModule.createWorkletRuntime('AudioWorkletRuntime');
-    }
+    const audioRuntime = AudioAPIModule.createAudioRuntime();
 
     if (typeof arg0 === 'object') {
       const { numberOfChannels, length, sampleRate } = arg0;

package/src/events/types.ts

@@ -23,6 +23,10 @@ interface OnRouteChangeEventType {
     | 'NoSuitableRouteForCategory';
 }
 
+export interface OnRecorderErrorEventType {
+  message: string;
+}
+
 interface RemoteCommandEvents {
   remotePlay: EventEmptyType;
   remotePause: EventEmptyType;
@@ -80,6 +84,7 @@ interface AudioAPIEvents {
   positionChanged: EventTypeWithValue;
   audioError: EventEmptyType; // to change
   systemStateChanged: EventEmptyType; // to change
+  recorderError: OnRecorderErrorEventType;
 }
 
 type AudioEvents = SystemEvents & AudioAPIEvents;

package/src/interfaces.ts

@@ -1,14 +1,19 @@
 import { AudioEventCallback, AudioEventName } from './events/types';
 import type {
+  AudioRecorderCallbackOptions,
+  AudioRecorderFileOptions,
   BiquadFilterType,
   ChannelCountMode,
   ChannelInterpretation,
   ContextState,
   FileInfo,
   OscillatorType,
+  Result,
   WindowType,
 } from './types';
 
+// IMPORTANT: use only IClass, because it is a part of contract between cpp host object and js layer
+
 export type WorkletNodeCallback = (
   audioData: Array<ArrayBuffer>,
   channelCount: number
@@ -59,8 +64,13 @@ export interface IBaseAudioContext {
   createOscillator(): IOscillatorNode;
   createConstantSource(): IConstantSourceNode;
   createGain(): IGainNode;
+  createDelay(maxDelayTime: number): IDelayNode;
   createStereoPanner(): IStereoPannerNode;
   createBiquadFilter: () => IBiquadFilterNode;
+  createIIRFilter: (
+    feedforward: number[],
+    feedback: number[]
+  ) => IIIRFilterNode;
   createBufferSource: (pitchCorrection: boolean) => IAudioBufferSourceNode;
   createBufferQueueSource: (
     pitchCorrection: boolean
@@ -76,7 +86,11 @@ export interface IBaseAudioContext {
     disableNormalization: boolean
   ) => IPeriodicWave;
   createAnalyser: () => IAnalyserNode;
-  createStreamer: () => IStreamerNode;
+  createConvolver: (
+    buffer: IAudioBuffer | undefined,
+    disableNormalization: boolean
+  ) => IConvolverNode;
+  createStreamer: () => IStreamerNode | null; // null when FFmpeg is not enabled
 }
 
 export interface IAudioContext extends IBaseAudioContext {
@@ -103,6 +117,11 @@ export interface IAudioNode {
   disconnect: (destination?: IAudioNode | IAudioParam) => void;
 }
 
+export interface IDelayNode extends IAudioNode {
+  readonly delayTime: IAudioParam;
+  maxDelayTime: number;
+}
+
 export interface IGainNode extends IAudioNode {
   readonly gain: IAudioParam;
 }
@@ -125,6 +144,14 @@ export interface IBiquadFilterNode extends IAudioNode {
   ): void;
 }
 
+export interface IIIRFilterNode extends IAudioNode {
+  getFrequencyResponse(
+    frequencyArray: Float32Array,
+    magResponseOutput: Float32Array,
+    phaseResponseOutput: Float32Array
+  ): void;
+}
+
 export interface IAudioDestinationNode extends IAudioNode {}
 
 export interface IAudioScheduledSourceNode extends IAudioNode {
@@ -139,6 +166,9 @@ export interface IAudioBufferBaseSourceNode extends IAudioScheduledSourceNode {
   detune: IAudioParam;
   playbackRate: IAudioParam;
 
+  getInputLatency: () => number;
+  getOutputLatency: () => number;
+
   // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
   onPositionChanged: string;
   // set how often the onPositionChanged event is called
@@ -182,9 +212,17 @@ export interface IAudioBufferQueueSourceNode
 
   // returns bufferId
   enqueueBuffer: (audioBuffer: IAudioBuffer) => string;
+  start: (when?: number, offset?: number) => void;
   pause: () => void;
 }
 
+export interface IConvolverNode extends IAudioNode {
+  readonly buffer: IAudioBuffer | null;
+  normalize: boolean;
+
+  setBuffer: (audioBuffer: IAudioBuffer | null) => void;
+}
+
 export interface IAudioBuffer {
   readonly length: number;
   readonly duration: number;
@@ -251,46 +289,21 @@ export interface IWorkletSourceNode extends IAudioScheduledSourceNode {}
 
 export interface IWorkletProcessingNode extends IAudioNode {}
 
-type IOSAudioRecorderFileDescriptor = number;
-type AndroidAudioRecorderFileDescriptor = number;
-
-interface IAudioRecorderFileOptions {
-  sampleRate: number;
-  channels: number;
-  bitRate: number;
-  /**
-   * IOS specific file recording options
-   *
-   * - `format` - IOSFormat, bitmask 0 x 0000000F
-   * - `quality` - IOSAudioQuality, bitmask 0 x 000000F0
-   * - `flacCompressionLevel` - FlacCompressionLevel, bitmask 0 x 00000F00
-   * - `directory` - FileDirectory, bitmask 0 x 0000F000
-   * - `bitDepth` - BitDepth, bitmask 0 x 000F0000
-   */
-  ios: IOSAudioRecorderFileDescriptor;
-  /**
-   * Android specific file recording options
-   *
-   * - He he
-   */
-  android: AndroidAudioRecorderFileDescriptor;
-}
-
-interface IAudioRecorderCallbackOptions {
-  sampleRate: number;
-  bufferLength: number;
-  channelCount: number;
+export interface IAudioRecorderCallbackOptions
+  extends AudioRecorderCallbackOptions {
   callbackId: string;
 }
 
 export interface IAudioRecorder {
   // default recorder methods
-  start: () => string | void;
-  stop: () => FileInfo;
+  start: () => Result<{ path: string }>;
+  stop: () => Result<FileInfo>;
   isRecording: () => boolean;
   isPaused: () => boolean;
 
-  enableFileOutput: (options: IAudioRecorderFileOptions) => void;
+  enableFileOutput: (
+    options: AudioRecorderFileOptions
+  ) => Result<{ path: string }>;
   disableFileOutput: () => void;
 
   // pause and resume methods for file recording
@@ -301,10 +314,14 @@ export interface IAudioRecorder {
   connect: (node: IRecorderAdapterNode) => void;
   disconnect: () => void;
 
-  setOnAudioReady: (options: IAudioRecorderCallbackOptions) => void;
+  setOnAudioReady: (options: IAudioRecorderCallbackOptions) => Result<void>;
   clearOnAudioReady: () => void;
 
+  setOnError: (options: { callbackId: string }) => void;
+  clearOnError: () => void;
+
   getCurrentDuration: () => number;
+  getFilePath: () => string | null;
 }
 
 export interface IAudioDecoder {

package/src/plugin/withAudioAPI.ts

@@ -4,6 +4,8 @@ import {
   ConfigPlugin,
   withInfoPlist,
   withAndroidManifest,
+  withGradleProperties,
+  withPodfile,
 } from '@expo/config-plugins';
 const pkg = require('react-native-audio-api/package.json');
 
@@ -13,6 +15,7 @@ interface Options {
   androidPermissions: string[];
   androidForegroundService: boolean;
   androidFSTypes: string[];
+  disableFFmpeg: boolean;
 }
 
 const withDefaultOptions = (options: Partial<Options>): Options => {
@@ -24,6 +27,7 @@ const withDefaultOptions = (options: Partial<Options>): Options => {
     ],
     androidForegroundService: true,
     androidFSTypes: ['mediaPlayback'],
+    disableFFmpeg: false,
     ...options,
   };
 };
@@ -88,6 +92,59 @@ const withForegroundService: ConfigPlugin<Options> = (
   });
 };
 
+const withFFmpegConfig: ConfigPlugin<Options> = (config, options) => {
+  const iosConf = withPodfile(config, (mod) => {
+    let contents = mod.modResults.contents;
+    const ffmpegRegex = /^.*ENV\['DISABLE_AUDIOAPI_FFMPEG'\].*$/gm;
+    const podfileString = options.disableFFmpeg
+      ? `ENV['DISABLE_AUDIOAPI_FFMPEG'] = '1'`
+      : '';
+    // No existing setting
+    if (contents.search(ffmpegRegex) === -1) {
+      if (options.disableFFmpeg) {
+        if (contents.endsWith('\n')) {
+          contents = `${contents}${podfileString}`;
+        } else {
+          contents = `${contents}\n${podfileString}`;
+        }
+        mod.modResults.contents = contents;
+      }
+    } else {
+      // Existing setting found, will replace
+      contents = contents.replace(ffmpegRegex, podfileString);
+    }
+
+    mod.modResults.contents = contents;
+    return mod;
+  });
+
+  const finalConf = withGradleProperties(iosConf, (mod) => {
+    const gradleProperties = mod.modResults;
+
+    const existingIndex = gradleProperties.findIndex(
+      (prop) => prop.type === 'property' && prop.key === 'disableAudioapiFFmpeg'
+    );
+    if (existingIndex !== -1) {
+      gradleProperties.splice(existingIndex, 1);
+    } else if (!options.disableFFmpeg) {
+      // No existing setting and FFmpeg is enabled, do nothing.
+      return mod;
+    }
+
+    if (options.disableFFmpeg) {
+      gradleProperties.push({
+        type: 'property',
+        key: 'disableAudioapiFFmpeg',
+        value: options.disableFFmpeg ? 'true' : 'false',
+      });
+    }
+
+    return mod;
+  });
+
+  return finalConf;
+};
+
 const withAudioAPI: ConfigPlugin<Options> = (config, optionsIn) => {
   const options = withDefaultOptions(optionsIn ?? {});
 
@@ -105,6 +162,10 @@ const withAudioAPI: ConfigPlugin<Options> = (config, optionsIn) => {
     config = withIosMicrophonePermission(config, options);
   }
 
+  if (options.disableFFmpeg !== undefined) {
+    config = withFFmpegConfig(config, options);
+  }
+
   return config;
 };
 

package/src/specs/NativeAudioAPIModule.ts

@@ -1,7 +1,7 @@
 'use strict';
-import { TurboModuleRegistry } from 'react-native';
 import type { TurboModule } from 'react-native';
-import { PermissionStatus, AudioDevicesInfo } from '../system/types';
+import { TurboModuleRegistry } from 'react-native';
+import { AudioDevicesInfo, PermissionStatus } from '../system/types';
 
 interface Spec extends TurboModule {
   install(): boolean;
@@ -15,6 +15,7 @@ interface Spec extends TurboModule {
     options: Array<string>,
     allowHaptics: boolean
   ): void;
+  disableSessionManagement(): void;
 
   // Lock Screen Info
   setLockScreenInfo(info: {

package/src/system/AudioManager.ts

@@ -1,26 +1,16 @@
+import { AudioEventEmitter, AudioEventSubscription } from '../events';
 import {
-  SessionOptions,
-  LockScreenInfo,
-  PermissionStatus,
-  AudioDevicesInfo,
-} from './types';
-import {
-  SystemEventName,
-  SystemEventCallback,
   RemoteCommandEventName,
+  SystemEventCallback,
+  SystemEventName,
 } from '../events/types';
 import { NativeAudioAPIModule } from '../specs';
-import { AudioEventEmitter, AudioEventSubscription } from '../events';
-
-if (global.AudioEventEmitter == null) {
-  if (!NativeAudioAPIModule) {
-    throw new Error(
-      `Failed to install react-native-audio-api: The native module could not be found.`
-    );
-  }
-
-  NativeAudioAPIModule.install();
-}
+import {
+  AudioDevicesInfo,
+  LockScreenInfo,
+  PermissionStatus,
+  SessionOptions,
+} from './types';
 
 class AudioManager {
   private readonly audioEventEmitter: AudioEventEmitter;
@@ -45,6 +35,10 @@ class AudioManager {
     );
   }
 
+  disableSessionManagement() {
+    NativeAudioAPIModule!.disableSessionManagement();
+  }
+
   setLockScreenInfo(info: LockScreenInfo) {
     NativeAudioAPIModule!.setLockScreenInfo(info);
   }

package/src/types.ts

@@ -1,3 +1,9 @@
+import AudioBuffer from './core/AudioBuffer';
+
+export type Result<T> =
+  | ({ status: 'success' } & T)
+  | { status: 'error'; message: string };
+
 export type ChannelCountMode = 'max' | 'clamped-max' | 'explicit';
 
 export type ChannelInterpretation = 'speakers' | 'discrete';
@@ -29,7 +35,6 @@ export interface PeriodicWaveConstraints {
 
 export interface AudioContextOptions {
   sampleRate?: number;
-  initSuspended?: boolean;
 }
 
 export interface OfflineAudioContextOptions {
@@ -43,7 +48,7 @@ export enum FileDirectory {
   Cache = 2,
 }
 
-export enum IOSFormat {
+export enum FileFormat {
   Wav = 1,
   Caf = 2,
   M4A = 3,
@@ -58,23 +63,16 @@ export enum IOSAudioQuality {
   Max = 5,
 }
 
-export enum AndroidFormat {
-  Wav = 1,
-  Caf = 2,
-  M4A = 3,
-  Flac = 4,
-}
-
 export enum FlacCompressionLevel {
-  L0 = 1,
-  L1 = 2,
-  L2 = 3,
-  L3 = 4,
-  L4 = 5,
-  L5 = 6,
-  L6 = 7,
-  L7 = 8,
-  L8 = 9,
+  L0 = 0,
+  L1 = 1,
+  L2 = 2,
+  L3 = 3,
+  L4 = 4,
+  L5 = 5,
+  L6 = 6,
+  L7 = 7,
+  L8 = 8,
 }
 
 export enum BitDepth {
@@ -83,24 +81,31 @@ export enum BitDepth {
   Bit32 = 3,
 }
 
-export interface AudioRecorderFileOptionsIOS {
-  format?: IOSFormat;
-  quality?: IOSAudioQuality;
-  flacCompressionLevel?: FlacCompressionLevel;
-}
-
-export interface AudioRecorderFileOptionsAndroid {
-  format?: AndroidFormat;
+export interface FilePresetType {
+  bitRate: number;
+  sampleRate: number;
+  bitDepth: BitDepth;
+  iosQuality: IOSAudioQuality;
+  flacCompressionLevel: FlacCompressionLevel;
 }
 
 export interface AudioRecorderFileOptions {
+  channelCount?: number;
+  batchDurationSeconds?: number;
+
+  format?: FileFormat;
+  preset?: FilePresetType;
+
   directory?: FileDirectory;
-  sampleRate?: number;
-  channels?: number;
-  bitRate?: number;
-  bitDepth?: BitDepth;
-  ios?: AudioRecorderFileOptionsIOS;
-  android?: AudioRecorderFileOptionsAndroid;
+  subDirectory?: string;
+  fileNamePrefix?: string;
+  androidFlushIntervalMs?: number;
+}
+
+export interface FileInfo {
+  path: string;
+  size: number;
+  duration: number;
 }
 
 export type WindowType = 'blackman' | 'hann';
@@ -111,6 +116,11 @@ export interface AudioBufferBaseSourceNodeOptions {
 
 export type ProcessorMode = 'processInPlace' | 'processThrough';
 
+export interface ConvolverNodeOptions {
+  buffer?: AudioBuffer | null;
+  disableNormalization?: boolean;
+}
+
 export interface AudioRecorderCallbackOptions {
   /**
    * The desired sample rate (in Hz) for audio buffers delivered to the
@@ -133,8 +143,7 @@ export interface AudioRecorderCallbackOptions {
   channelCount: number;
 }
 
-export interface FileInfo {
-  path: string;
-  size: number;
-  duration: number;
+export interface IIRFilterNodeOptions {
+  feedforward: number[];
+  feedback: number[];
 }

package/src/utils/filePresets.ts

@@ -0,0 +1,47 @@
+import {
+  BitDepth,
+  FilePresetType,
+  FlacCompressionLevel,
+  IOSAudioQuality,
+} from '../types';
+
+const LowQuality: FilePresetType = {
+  sampleRate: 22050,
+  bitRate: 48000,
+  bitDepth: BitDepth.Bit16,
+  flacCompressionLevel: FlacCompressionLevel.L0,
+  iosQuality: IOSAudioQuality.Low,
+};
+
+const MediumQuality: FilePresetType = {
+  sampleRate: 44100,
+  bitRate: 128000,
+  bitDepth: BitDepth.Bit16,
+  flacCompressionLevel: FlacCompressionLevel.L3,
+  iosQuality: IOSAudioQuality.Medium,
+};
+
+const HighQuality: FilePresetType = {
+  sampleRate: 48000,
+  bitRate: 192000,
+  bitDepth: BitDepth.Bit24,
+  flacCompressionLevel: FlacCompressionLevel.L5,
+  iosQuality: IOSAudioQuality.High,
+};
+
+const LosslessQuality: FilePresetType = {
+  sampleRate: 48000,
+  bitRate: 320000,
+  bitDepth: BitDepth.Bit24,
+  flacCompressionLevel: FlacCompressionLevel.L8,
+  iosQuality: IOSAudioQuality.High,
+};
+
+const FilePreset = {
+  Low: LowQuality,
+  Medium: MediumQuality,
+  High: HighQuality,
+  Lossless: LosslessQuality,
+} as const;
+
+export default FilePreset;

package/src/utils/index.ts

@@ -1,26 +1,20 @@
-import type { ShareableWorkletCallback } from '../interfaces';
-export * from './bitEnums';
+import AudioAPIModule from '../AudioAPIModule';
 
-interface SimplifiedWorkletModule {
-  makeShareableCloneRecursive: (
-    workletCallback: ShareableWorkletCallback
-  ) => ShareableWorkletCallback;
+export function assertWorkletsEnabled() {
+  if (!AudioAPIModule.areWorkletsAvailable) {
+    throw new Error(
+      '[react-native-audio-api]: Worklets are not available. Please install react-native-worklets to use this feature.'
+    );
+  }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  createWorkletRuntime: (options?: any) => any;
+  if (!AudioAPIModule.isWorkletsVersionSupported) {
+    throw new Error(
+      `[react-native-audio-api]: Worklets version ${AudioAPIModule.workletsVersion} is not supported.
+      Please install react-native-worklets of one of the following versions: [${AudioAPIModule.supportedWorkletsVersion.join(', ')}] to use this feature.`
+    );
+  }
 }
 
 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;
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-} catch (error) {
-  isWorkletsAvailable = false;
-}

package/src/web-core/AudioContext.tsx

@@ -3,6 +3,7 @@ import {
   PeriodicWaveConstraints,
   AudioContextOptions,
   AudioBufferBaseSourceNodeOptions,
+  IIRFilterNodeOptions,
 } from '../types';
 import { InvalidAccessError, NotSupportedError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
@@ -11,10 +12,14 @@ import AudioDestinationNode from './AudioDestinationNode';
 import AudioBuffer from './AudioBuffer';
 import AudioBufferSourceNode from './AudioBufferSourceNode';
 import BiquadFilterNode from './BiquadFilterNode';
+import IIRFilterNode from './IIRFilterNode';
 import GainNode from './GainNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
+import ConvolverNode from './ConvolverNode';
+import DelayNode from './DelayNode';
+import { ConvolverNodeOptions } from './ConvolverNodeOptions';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 import ConstantSourceNode from './ConstantSourceNode';
@@ -25,7 +30,7 @@ export default class AudioContext implements BaseAudioContext {
   readonly destination: AudioDestinationNode;
   readonly sampleRate: number;
 
-  constructor(options?: AudioContextOptions, _initSuspended: boolean = false) {
+  constructor(options?: AudioContextOptions) {
     if (
       options &&
       options.sampleRate &&
@@ -62,6 +67,10 @@ export default class AudioContext implements BaseAudioContext {
     return new GainNode(this, this.context.createGain());
   }
 
+  createDelay(maxDelayTime?: number): DelayNode {
+    return new DelayNode(this, this.context.createDelay(maxDelayTime));
+  }
+
   createStereoPanner(): StereoPannerNode {
     return new StereoPannerNode(this, this.context.createStereoPanner());
   }
@@ -70,6 +79,36 @@ export default class AudioContext implements BaseAudioContext {
     return new BiquadFilterNode(this, this.context.createBiquadFilter());
   }
 
+  createIIRFilter(options: IIRFilterNodeOptions): IIRFilterNode {
+    return new IIRFilterNode(
+      this,
+      this.context.createIIRFilter(options.feedforward, options.feedback)
+    );
+  }
+
+  createConvolver(options?: ConvolverNodeOptions): ConvolverNode {
+    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.`
+        );
+      }
+    }
+    const buffer = options?.buffer ?? null;
+    const disableNormalization = options?.disableNormalization ?? false;
+    return new ConvolverNode(
+      this,
+      this.context.createConvolver(),
+      buffer,
+      disableNormalization
+    );
+  }
+
   async createBufferSource(
     options?: AudioBufferBaseSourceNodeOptions
   ): Promise<AudioBufferSourceNode> {