react-native-audio-api 0.11.0-alpha.1 → 0.11.0-nightly-9f40b78-20251108

package/src/interfaces.ts

@@ -1,14 +1,15 @@
 import { AudioEventCallback, AudioEventName } from './events/types';
-import type {
+import {
   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
@@ -76,6 +77,10 @@ export interface IBaseAudioContext {
     disableNormalization: boolean
   ) => IPeriodicWave;
   createAnalyser: () => IAnalyserNode;
+  createConvolver: (
+    buffer: IAudioBuffer | undefined,
+    disableNormalization: boolean
+  ) => IConvolverNode;
   createStreamer: () => IStreamerNode;
 }
 
@@ -185,6 +190,11 @@ export interface IAudioBufferQueueSourceNode
   pause: () => void;
 }
 
+export interface IConvolverNode extends IAudioNode {
+  buffer: IAudioBuffer | null;
+  normalize: boolean;
+}
+
 export interface IAudioBuffer {
   readonly length: number;
   readonly duration: number;
@@ -251,60 +261,14 @@ 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 {
-  // 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
+  start: () => void;
+  stop: () => void;
   connect: (node: IRecorderAdapterNode) => void;
   disconnect: () => void;
 
-  setOnAudioReady: (options: IAudioRecorderCallbackOptions) => void;
-  clearOnAudioReady: () => void;
-
-  getCurrentDuration: () => number;
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onAudioReady: string;
 }
 
 export interface IAudioDecoder {

package/src/specs/NativeAudioAPIModule.ts

@@ -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

@@ -45,6 +45,10 @@ class AudioManager {
     );
   }
 
+  disableSessionManagement() {
+    NativeAudioAPIModule!.disableSessionManagement();
+  }
+
   setLockScreenInfo(info: LockScreenInfo) {
     NativeAudioAPIModule!.setLockScreenInfo(info);
   }

package/src/types.ts

@@ -1,3 +1,5 @@
+import AudioBuffer from './core/AudioBuffer';
+
 export type ChannelCountMode = 'max' | 'clamped-max' | 'explicit';
 
 export type ChannelInterpretation = 'speakers' | 'discrete';
@@ -12,7 +14,7 @@ export type BiquadFilterType =
   | 'notch'
   | 'allpass';
 
-export type ContextState = 'running' | 'closed' | 'suspended';
+export type ContextState = 'running' | 'closed' | `suspended`;
 
 export type AudioWorkletRuntime = 'AudioRuntime' | 'UIRuntime';
 
@@ -38,69 +40,9 @@ export interface OfflineAudioContextOptions {
   sampleRate: 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 interface AudioRecorderOptions {
+  sampleRate: number;
+  bufferLengthInSamples: number;
 }
 
 export type WindowType = 'blackman' | 'hann';
@@ -111,30 +53,7 @@ export interface AudioBufferBaseSourceNodeOptions {
 
 export type ProcessorMode = 'processInPlace' | 'processThrough';
 
-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;
+export interface ConvolverNodeOptions {
+  buffer?: AudioBuffer | null;
+  disableNormalization?: boolean;
 }

package/src/utils/index.ts

@@ -1,5 +1,4 @@
 import type { ShareableWorkletCallback } from '../interfaces';
-export * from './bitEnums';
 
 interface SimplifiedWorkletModule {
   makeShareableCloneRecursive: (
@@ -14,12 +13,33 @@ export function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
 }
 
-export let isWorkletsAvailable = false;
+let isWorkletsAvailable = false;
+export let isWorkletsVersionSupported = false;
+export let workletsVersion = 'unknown';
+export const supportedWorkletsVersions = ['0.6.0', '0.6.1'];
 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,6 +15,8 @@ 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';
@@ -70,6 +72,29 @@ 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,6 +9,7 @@ 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;
@@ -23,6 +24,7 @@ export default interface BaseAudioContext {
   createGain(): GainNode;
   createStereoPanner(): StereoPannerNode;
   createBiquadFilter(): BiquadFilterNode;
+  createConvolver(): ConvolverNode;
   createBufferSource(): Promise<AudioBufferSourceNode>;
   createBuffer(
     numOfChannels: number,

package/src/web-core/ConvolverNode.tsx

@@ -0,0 +1,43 @@
+import BaseAudioContext from './BaseAudioContext';
+import AudioNode from './AudioNode';
+import AudioBuffer from './AudioBuffer';
+
+export default class ConvolverNode extends AudioNode {
+  constructor(
+    context: BaseAudioContext,
+    node: globalThis.ConvolverNode,
+    buffer: AudioBuffer | null = null,
+    disableNormalization: boolean = false
+  ) {
+    super(context, node);
+
+    (this.node as globalThis.ConvolverNode).normalize = !disableNormalization;
+    if (buffer) {
+      (this.node as globalThis.ConvolverNode).buffer = buffer.buffer;
+    }
+  }
+
+  public get buffer(): AudioBuffer | null {
+    const buffer = (this.node as globalThis.ConvolverNode).buffer;
+    if (!buffer) {
+      return null;
+    }
+    return new AudioBuffer(buffer);
+  }
+
+  public set buffer(buffer: AudioBuffer | null) {
+    if (!buffer) {
+      (this.node as globalThis.ConvolverNode).buffer = null;
+    } else {
+      (this.node as globalThis.ConvolverNode).buffer = buffer.buffer;
+    }
+  }
+
+  public get normalize(): boolean {
+    return (this.node as globalThis.ConvolverNode).normalize;
+  }
+
+  public set normalize(value: boolean) {
+    (this.node as globalThis.ConvolverNode).normalize = value;
+  }
+}

package/src/web-core/ConvolverNodeOptions.tsx

@@ -0,0 +1,6 @@
+import AudioBuffer from './AudioBuffer';
+
+export interface ConvolverNodeOptions {
+  buffer?: AudioBuffer | null;
+  disableNormalization?: boolean;
+}

package/src/web-core/OfflineAudioContext.tsx

@@ -18,6 +18,8 @@ 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;
@@ -76,6 +78,29 @@ 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/android/src/main/cpp/audioapi/android/core/utils/AndroidFileWriterBackend.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include <tuple>
-#include <string>
-#include <memory>
-
-namespace audioapi {
-
-class AndroidFileWriterBackend {
- public:
-  AndroidFileWriterBackend(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t androidFlags) {}
-
-  virtual ~AndroidFileWriterBackend() = default;
-
-  virtual std::string openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
-  virtual std::tuple<double, double> closeFile() = 0;
-
-  virtual bool writeAudioData(void *data, int numFrames) = 0;
-
-  std::string getFilePath() const { return filePath_; }
-
-  double getCurrentDuration() const { return static_cast<double>(framesWritten_.load()) / streamSampleRate_; }
-
- protected:
-  std::string filePath_{""};
-  std::atomic<size_t> framesWritten_{0};
-
-  int32_t streamSampleRate_{0};
-  int32_t streamChannelCount_{0};
-  int32_t streamMaxBufferSize_{0};
-};
-
-} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.cpp

@@ -1,187 +0,0 @@
-#include <android/log.h>
-#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
-#include <audioapi/android/core/utils/AndroidRecorderCallback.h>
-#include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/libs/miniaudio/miniaudio.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
-#include <audioapi/utils/CircularAudioArray.h>
-
-#include <memory>
-
-namespace audioapi {
-
-AndroidRecorderCallback::AndroidRecorderCallback(
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-    float sampleRate,
-    size_t bufferLength,
-    size_t channelCount,
-    uint64_t callbackId)
-    : sampleRate_(sampleRate),
-      bufferLength_(bufferLength),
-      channelCount_(channelCount),
-      callbackId_(callbackId),
-      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-  ringBufferSize_ = std::max((int)bufferLength * 2, 8192);
-  circularBus_.resize(channelCount_);
-
-  for (size_t i = 0; i < channelCount_; ++i) {
-    auto busArray = std::make_shared<CircularAudioArray>(ringBufferSize_);
-    circularBus_[i] = busArray;
-  }
-}
-
-AndroidRecorderCallback::~AndroidRecorderCallback() {
-  for (size_t i = 0; i < circularBus_.size(); ++i) {
-    circularBus_[i].reset();
-  }
-}
-
-void AndroidRecorderCallback::prepare(
-    int32_t streamSampleRate,
-    int32_t streamChannelCount,
-    size_t maxInputBufferLength) {
-  ma_result result;
-
-  streamSampleRate_ = streamSampleRate;
-  streamChannelCount_ = streamChannelCount;
-  maxInputBufferLength_ = maxInputBufferLength;
-
-  ma_data_converter_config converterConfig = ma_data_converter_config_init(
-      ma_format_f32,
-      ma_format_f32,
-      streamChannelCount_,
-      channelCount_,
-      streamSampleRate_,
-      static_cast<int32_t>(sampleRate_));
-
-  converter_ = std::make_unique<ma_data_converter>();
-  result = ma_data_converter_init(&converterConfig, NULL, converter_.get());
-
-  if (result != MA_SUCCESS) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AndroidRecorderCallback",
-        "Failed to initialize miniaudio data converter");
-    return;
-  }
-
-  ma_data_converter_get_expected_output_frame_count(
-      converter_.get(), maxInputBufferLength_, &processingBufferLength_);
-
-  processingBufferLength_ =
-      std::max(processingBufferLength_, (ma_uint64)maxInputBufferLength_);
-
-  deinterleavingArray_ = std::make_shared<AudioArray>(processingBufferLength_);
-  processingBuffer_ = ma_malloc(
-      processingBufferLength_ * channelCount_ *
-          ma_get_bytes_per_sample(ma_format_f32),
-      NULL);
-}
-
-void AndroidRecorderCallback::cleanup() {
-  if (converter_ != nullptr) {
-    ma_data_converter_uninit(converter_.get(), NULL);
-    converter_.reset();
-  }
-
-  if (processingBuffer_ != nullptr) {
-    ma_free(processingBuffer_, NULL);
-    processingBuffer_ = nullptr;
-    processingBufferLength_ = 0;
-  }
-
-  for (size_t i = 0; i < circularBus_.size(); ++i) {
-    circularBus_[i].reset();
-  }
-}
-
-void AndroidRecorderCallback::receiveAudioData(void *data, int numFrames) {
-  ma_uint64 inputFrameCount = numFrames;
-  ma_uint64 outputFrameCount = 0;
-
-  if ((float)streamSampleRate_ == sampleRate_ ||
-      streamChannelCount_ == channelCount_) {
-    deinterleaveAndWriteAudioData(data, numFrames);
-    emitAudioData();
-    return;
-  }
-
-  ma_data_converter_get_expected_output_frame_count(
-      converter_.get(), inputFrameCount, &outputFrameCount);
-
-  ma_data_converter_process_pcm_frames(
-      converter_.get(),
-      data,
-      &inputFrameCount,
-      processingBuffer_,
-      &outputFrameCount);
-
-  deinterleaveAndWriteAudioData(
-      processingBuffer_, static_cast<int>(outputFrameCount));
-  emitAudioData();
-}
-
-void AndroidRecorderCallback::deinterleaveAndWriteAudioData(
-    void *data,
-    int numFrames) {
-  auto *inputData = static_cast<float *>(data);
-
-  for (size_t channel = 0; channel < channelCount_; ++channel) {
-    float *channelData = deinterleavingArray_->getData();
-
-    for (int frame = 0; frame < numFrames; ++frame) {
-      channelData[frame] = inputData[frame * streamChannelCount_ + channel];
-    }
-
-    circularBus_[channel]->push_back(channelData, numFrames);
-  }
-}
-
-void AndroidRecorderCallback::emitAudioData() {
-  while (circularBus_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
-    auto bus =
-        std::make_shared<AudioBus>(bufferLength_, channelCount_, sampleRate_);
-
-    for (int i = 0; i < channelCount_; ++i) {
-      auto *outputChannel = bus->getChannel(i)->getData();
-      circularBus_[i]->pop_front(outputChannel, bufferLength_);
-    }
-
-    invokeCallback(bus, (int)bufferLength_);
-  }
-}
-
-void AndroidRecorderCallback::invokeCallback(
-    const std::shared_ptr<AudioBus> &bus,
-    int numFrames) {
-  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
-  auto audioBufferHostObject =
-      std::make_shared<AudioBufferHostObject>(audioBuffer);
-
-  std::unordered_map<std::string, EventValue> eventPayload = {};
-  eventPayload.insert({"buffer", audioBufferHostObject});
-  eventPayload.insert({"numFrames", numFrames});
-
-  if (audioEventHandlerRegistry_) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "audioReady", callbackId_, eventPayload);
-  }
-}
-
-void AndroidRecorderCallback::sendRemainingData() {
-  auto numberOfFrames = circularBus_[0]->getNumberOfAvailableFrames();
-  auto bus = std::make_shared<AudioBus>(
-      circularBus_[0]->getNumberOfAvailableFrames(),
-      channelCount_,
-      sampleRate_);
-
-  for (int i = 0; i < channelCount_; ++i) {
-    auto *outputChannel = bus->getChannel(i)->getData();
-    circularBus_[i]->pop_front(outputChannel, numberOfFrames);
-  }
-
-  invokeCallback(bus, (int)numberOfFrames);
-}
-
-} // namespace audioapi