react-native-audio-api 0.10.0-nightly-e16d7ff-20251030 → 0.11.0-alpha.1

package/src/events/types.ts

@@ -49,9 +49,27 @@ export interface OnEndedEventType extends EventEmptyType {
   isLast: boolean | undefined;
 }
 
+/**
+ * Represents the data payload received by the audio recorder callback each time
+ * a new audio buffer becomes available during recording.
+ */
 export interface OnAudioReadyEventType {
+  /**
+   * The audio buffer containing the recorded PCM data. This buffer includes one
+   * or more channels of floating-point samples in the range of -1.0 to 1.0.
+   */
   buffer: AudioBuffer;
+
+  /**
+   * The number of audio frames contained in this buffer. A frame represents a
+   * single sample across all channels.
+   */
   numFrames: number;
+
+  /**
+   * The timestamp (in seconds) indicating when this buffer was captured,
+   * relative to the start of the recording session.
+   */
   when: number;
 }
 

package/src/interfaces.ts

@@ -1,15 +1,14 @@
 import { AudioEventCallback, AudioEventName } from './events/types';
-import {
+import type {
   BiquadFilterType,
   ChannelCountMode,
   ChannelInterpretation,
   ContextState,
+  FileInfo,
   OscillatorType,
   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
@@ -77,10 +76,6 @@ export interface IBaseAudioContext {
     disableNormalization: boolean
   ) => IPeriodicWave;
   createAnalyser: () => IAnalyserNode;
-  createConvolver: (
-    buffer: IAudioBuffer | undefined,
-    disableNormalization: boolean
-  ) => IConvolverNode;
   createStreamer: () => IStreamerNode;
 }
 
@@ -190,11 +185,6 @@ export interface IAudioBufferQueueSourceNode
   pause: () => void;
 }
 
-export interface IConvolverNode extends IAudioNode {
-  buffer: IAudioBuffer | null;
-  normalize: boolean;
-}
-
 export interface IAudioBuffer {
   readonly length: number;
   readonly duration: number;
@@ -261,14 +251,60 @@ 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;
+  callbackId: string;
+}
+
 export interface IAudioRecorder {
-  start: () => void;
-  stop: () => void;
+  // default recorder methods
+  start: () => string | void;
+  stop: () => FileInfo;
+  isRecording: () => boolean;
+  isPaused: () => boolean;
+
+  enableFileOutput: (options: IAudioRecorderFileOptions) => void;
+  disableFileOutput: () => void;
+
+  // pause and resume methods for file recording
+  pause: () => void;
+  resume: () => void;
+
+  // Graph integration methods
   connect: (node: IRecorderAdapterNode) => void;
   disconnect: () => void;
 
-  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
-  onAudioReady: string;
+  setOnAudioReady: (options: IAudioRecorderCallbackOptions) => void;
+  clearOnAudioReady: () => void;
+
+  getCurrentDuration: () => number;
 }
 
 export interface IAudioDecoder {

package/src/types.ts

@@ -1,5 +1,3 @@
-import AudioBuffer from './core/AudioBuffer';
-
 export type ChannelCountMode = 'max' | 'clamped-max' | 'explicit';
 
 export type ChannelInterpretation = 'speakers' | 'discrete';
@@ -14,7 +12,7 @@ export type BiquadFilterType =
   | 'notch'
   | 'allpass';
 
-export type ContextState = 'running' | 'closed' | `suspended`;
+export type ContextState = 'running' | 'closed' | 'suspended';
 
 export type AudioWorkletRuntime = 'AudioRuntime' | 'UIRuntime';
 
@@ -40,9 +38,69 @@ export interface OfflineAudioContextOptions {
   sampleRate: number;
 }
 
-export interface AudioRecorderOptions {
-  sampleRate: number;
-  bufferLengthInSamples: number;
+export enum FileDirectory {
+  Document = 1,
+  Cache = 2,
+}
+
+export enum IOSFormat {
+  Wav = 1,
+  Caf = 2,
+  M4A = 3,
+  Flac = 4,
+}
+
+export enum IOSAudioQuality {
+  Min = 1,
+  Low = 2,
+  Medium = 3,
+  High = 4,
+  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,
+}
+
+export enum BitDepth {
+  Bit16 = 1,
+  Bit24 = 2,
+  Bit32 = 3,
+}
+
+export interface AudioRecorderFileOptionsIOS {
+  format?: IOSFormat;
+  quality?: IOSAudioQuality;
+  flacCompressionLevel?: FlacCompressionLevel;
+}
+
+export interface AudioRecorderFileOptionsAndroid {
+  format?: AndroidFormat;
+}
+
+export interface AudioRecorderFileOptions {
+  directory?: FileDirectory;
+  sampleRate?: number;
+  channels?: number;
+  bitRate?: number;
+  bitDepth?: BitDepth;
+  ios?: AudioRecorderFileOptionsIOS;
+  android?: AudioRecorderFileOptionsAndroid;
 }
 
 export type WindowType = 'blackman' | 'hann';
@@ -53,7 +111,30 @@ 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
+   * recording callback. Common values include 44100 or 48000 Hz. The actual
+   * sample rate may differ depending on hardware and system capabilities.
+   */
+  sampleRate: number;
+
+  /**
+   * The preferred size of each audio buffer, expressed as the number of samples
+   * per channel. Smaller buffers reduce latency but increase CPU load, while
+   * larger buffers improve efficiency at the cost of higher latency.
+   */
+  bufferLength: number;
+
+  /**
+   * The desired number of audio channels per buffer. Typically 1 for mono or 2
+   * for stereo recordings.
+   */
+  channelCount: number;
+}
+
+export interface FileInfo {
+  path: string;
+  size: number;
+  duration: number;
 }

package/src/utils/bitEnums.ts

@@ -0,0 +1,51 @@
+function setBitValue(
+  output: number,
+  value: number,
+  shift: number,
+  bitWidth = 4
+): number {
+  const fieldMask = (1 << bitWidth) - 1;
+
+  if ((value & ~fieldMask) !== 0) {
+    throw new Error(
+      `Value ${value} exceeds the maximum for a field with width ${bitWidth} bits.`
+    );
+  }
+
+  return (output & ~(fieldMask << shift)) | ((value & fieldMask) << shift);
+}
+
+function getBitValue(input: number, shift: number, bitWidth = 4): number {
+  const fieldMask = (1 << bitWidth) - 1;
+  return (input >> shift) & fieldMask;
+}
+
+export function setEnumValue<T extends Record<string, number>>(
+  output: number,
+  value: T[keyof T],
+  shift: number,
+  bitWidth = 4
+): number {
+  return setBitValue(output, value, shift, bitWidth);
+}
+
+export function getEnumValue<T extends Record<string, number>>(
+  input: number,
+  _enum: T,
+  shift: number,
+  bitWidth = 4
+): T[keyof T] {
+  return getBitValue(input, shift, bitWidth) as T[keyof T];
+}
+
+export function encodeFlags<T extends Record<string, number>>(
+  ...flags: Array<T[keyof T]>
+): number {
+  let output = 0;
+
+  for (let i = 0; i < flags.length; i++) {
+    output |= setEnumValue(output, flags[i], i * 4);
+  }
+
+  return output;
+}

package/src/utils/index.ts

@@ -1,4 +1,5 @@
 import type { ShareableWorkletCallback } from '../interfaces';
+export * from './bitEnums';
 
 interface SimplifiedWorkletModule {
   makeShareableCloneRecursive: (
@@ -13,33 +14,12 @@ export function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
 }
 
-let isWorkletsAvailable = false;
-export let isWorkletsVersionSupported = false;
-export let workletsVersion = 'unknown';
-export const supportedWorkletsVersions = ['0.6.0', '0.6.1'];
+export let isWorkletsAvailable = false;
 export let workletsModule: SimplifiedWorkletModule;
 
-export function assertWorkletsEnabled() {
-  if (!isWorkletsAvailable) {
-    throw new Error(
-      '[react-native-audio-api]: Worklets are not available. Please install react-native-worklets to use this feature.'
-    );
-  } else if (!isWorkletsVersionSupported) {
-    throw new Error(
-      `[react-native-audio-api]: Worklets version ${workletsVersion} is not supported.
-      Please install react-native-worklets of one of the following versions: [${supportedWorkletsVersions.join(', ')}] to use this feature.`
-    );
-  }
-}
-
 try {
   workletsModule = require('react-native-worklets');
-  const workletsModuleJson = require('react-native-worklets/package.json');
-  isWorkletsVersionSupported = supportedWorkletsVersions.includes(
-    workletsModuleJson.version
-  );
   isWorkletsAvailable = true;
-  workletsVersion = workletsModuleJson.version;
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
 } catch (error) {
   isWorkletsAvailable = false;

package/src/web-core/AudioContext.tsx

@@ -15,8 +15,6 @@ import GainNode from './GainNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
-import ConvolverNode from './ConvolverNode';
-import { ConvolverNodeOptions } from './ConvolverNodeOptions';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 import ConstantSourceNode from './ConstantSourceNode';
@@ -72,29 +70,6 @@ export default class AudioContext implements BaseAudioContext {
     return new BiquadFilterNode(this, this.context.createBiquadFilter());
   }
 
-  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> {

package/src/web-core/BaseAudioContext.tsx

@@ -9,7 +9,6 @@ import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
-import ConvolverNode from './ConvolverNode';
 
 export default interface BaseAudioContext {
   readonly context: globalThis.BaseAudioContext;
@@ -24,7 +23,6 @@ export default interface BaseAudioContext {
   createGain(): GainNode;
   createStereoPanner(): StereoPannerNode;
   createBiquadFilter(): BiquadFilterNode;
-  createConvolver(): ConvolverNode;
   createBufferSource(): Promise<AudioBufferSourceNode>;
   createBuffer(
     numOfChannels: number,

package/src/web-core/OfflineAudioContext.tsx

@@ -18,8 +18,6 @@ import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
-import ConvolverNode from './ConvolverNode';
-import { ConvolverNodeOptions } from './ConvolverNodeOptions';
 
 export default class OfflineAudioContext implements BaseAudioContext {
   readonly context: globalThis.OfflineAudioContext;
@@ -78,29 +76,6 @@ export default class OfflineAudioContext implements BaseAudioContext {
     return new BiquadFilterNode(this, this.context.createBiquadFilter());
   }
 
-  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> {

package/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp

@@ -1,47 +0,0 @@
-#include <audioapi/HostObjects/effects/ConvolverNodeHostObject.h>
-
-#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
-#include <audioapi/core/effects/ConvolverNode.h>
-
-namespace audioapi {
-
-ConvolverNodeHostObject::ConvolverNodeHostObject(
-    const std::shared_ptr<ConvolverNode> &node)
-    : AudioNodeHostObject(node) {
-  addGetters(
-      JSI_EXPORT_PROPERTY_GETTER(ConvolverNodeHostObject, normalize),
-      JSI_EXPORT_PROPERTY_GETTER(ConvolverNodeHostObject, buffer));
-  addSetters(
-      JSI_EXPORT_PROPERTY_SETTER(ConvolverNodeHostObject, normalize),
-      JSI_EXPORT_PROPERTY_SETTER(ConvolverNodeHostObject, buffer));
-}
-
-JSI_PROPERTY_GETTER_IMPL(ConvolverNodeHostObject, normalize) {
-  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
-  return {convolverNode->getNormalize_()};
-}
-
-JSI_PROPERTY_GETTER_IMPL(ConvolverNodeHostObject, buffer) {
-  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
-  auto buffer = convolverNode->getBuffer();
-  auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
-  return jsi::Object::createFromHostObject(runtime, bufferHostObject);
-}
-
-JSI_PROPERTY_SETTER_IMPL(ConvolverNodeHostObject, normalize) {
-  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
-  convolverNode->setNormalize(value.getBool());
-}
-
-JSI_PROPERTY_SETTER_IMPL(ConvolverNodeHostObject, buffer) {
-  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
-  if (value.isNull()) {
-    convolverNode->setBuffer(nullptr);
-    return;
-  }
-
-  auto bufferHostObject =
-      value.getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
-  convolverNode->setBuffer(bufferHostObject->audioBuffer_);
-}
-} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.h

@@ -1,20 +0,0 @@
-#pragma once
-
-#include <audioapi/HostObjects/AudioNodeHostObject.h>
-
-#include <memory>
-
-namespace audioapi {
-using namespace facebook;
-
-class ConvolverNode;
-
-class ConvolverNodeHostObject : public AudioNodeHostObject {
- public:
-  explicit ConvolverNodeHostObject(const std::shared_ptr<ConvolverNode> &node);
-  JSI_PROPERTY_GETTER_DECL(normalize);
-  JSI_PROPERTY_GETTER_DECL(buffer);
-  JSI_PROPERTY_SETTER_DECL(normalize);
-  JSI_PROPERTY_SETTER_DECL(buffer);
-};
-} // namespace audioapi