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

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

package/src/web-core/BaseAudioContext.tsx

@@ -1,14 +1,21 @@
-import { ContextState, PeriodicWaveConstraints } from '../types';
+import {
+  ContextState,
+  PeriodicWaveConstraints,
+  IIRFilterNodeOptions,
+} from '../types';
 import AnalyserNode from './AnalyserNode';
 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 ConstantSourceNode from './ConstantSourceNode';
+import ConvolverNode from './ConvolverNode';
+import DelayNode from './DelayNode';
 
 export default interface BaseAudioContext {
   readonly context: globalThis.BaseAudioContext;
@@ -21,8 +28,11 @@ export default interface BaseAudioContext {
   createOscillator(): OscillatorNode;
   createConstantSource(): ConstantSourceNode;
   createGain(): GainNode;
+  createDelay(maxDelayTime?: number): DelayNode;
   createStereoPanner(): StereoPannerNode;
   createBiquadFilter(): BiquadFilterNode;
+  createIIRFilter(options: IIRFilterNodeOptions): IIRFilterNode;
+  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/DelayNode.tsx

@@ -0,0 +1,12 @@
+import BaseAudioContext from './BaseAudioContext';
+import AudioNode from './AudioNode';
+import AudioParam from './AudioParam';
+
+export default class DelayNode extends AudioNode {
+  readonly delayTime: AudioParam;
+
+  constructor(context: BaseAudioContext, delay: globalThis.DelayNode) {
+    super(context, delay);
+    this.delayTime = new AudioParam(delay.delayTime, context);
+  }
+}

package/src/web-core/IIRFilterNode.tsx

@@ -0,0 +1,25 @@
+import { NotSupportedError } from '../errors';
+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 globalThis.IIRFilterNode).getFrequencyResponse(
+      frequencyArray,
+      magResponseOutput,
+      phaseResponseOutput
+    );
+  }
+}

package/src/web-core/OfflineAudioContext.tsx

@@ -3,6 +3,7 @@ import {
   PeriodicWaveConstraints,
   OfflineAudioContextOptions,
   AudioBufferBaseSourceNodeOptions,
+  IIRFilterNodeOptions,
 } from '../types';
 import { InvalidAccessError, NotSupportedError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
@@ -11,6 +12,7 @@ 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';
@@ -18,6 +20,9 @@ import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
+import ConvolverNode from './ConvolverNode';
+import { ConvolverNodeOptions } from './ConvolverNodeOptions';
+import DelayNode from './DelayNode';
 
 export default class OfflineAudioContext implements BaseAudioContext {
   readonly context: globalThis.OfflineAudioContext;
@@ -68,6 +73,10 @@ export default class OfflineAudioContext 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());
   }
@@ -76,6 +85,36 @@ export default class OfflineAudioContext 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> {

package/android/src/main/cpp/audioapi/android/core/utils/FileUtils.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include <string>
-
-namespace audioapi::android::fileutils {
-
-enum class FileDirectory {
-  FILES_DIR,
-  CACHE_DIR,
-};
-
-enum class FileFormat {
-  WAV,
-  CAF,
-  M4A,
-  FLAC,
-};
-
-enum class BitDepth {
-  BIT_16,
-  BIT_24,
-  BIT_32,
-};
-
-bool createDirectoryIfNotExists(const std::string &directoryPath);
-std::string getTimestampString();
-std::string getISODateString();
-FileFormat formatFromFlags(size_t flags);
-FileDirectory directoryFromFlags(size_t flags);
-BitDepth bitDepthFromFlags(size_t flags);
-std::string getDirectory(FileDirectory dir);
-std::string getFilePath(const FileDirectory &directory, const std::string &baseFileName, const std::string &extension);
-
-} // namespace audioapi::android::fileutils

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

@@ -1,133 +0,0 @@
-
-#include <android/log.h>
-#include <audioapi/android/core/utils/FileUtils.h>
-#include <audioapi/android/system/NativeFileInfo.hpp>
-#include <chrono>
-#include <filesystem>
-#include <format>
-#include <iostream>
-
-namespace audioapi::android::fileutils {
-
-bool createDirectoryIfNotExists(const std::string &directoryPath) {
-  std::error_code ec;
-
-  if (!std::filesystem::exists(directoryPath, ec)) {
-    bool created = std::filesystem::create_directories(directoryPath, ec);
-
-    if (ec) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FileUtils",
-          "Error creating directory at path: %s, error: %s",
-          directoryPath.c_str(),
-          ec.message().c_str());
-
-      return false;
-    }
-
-    return created;
-  }
-
-  if (ec) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FileUtils",
-        "Error checking existence of directory at path: %s, error: %s",
-        directoryPath.c_str(),
-        ec.message().c_str());
-
-    return false;
-  }
-
-  return true;
-}
-
-std::string getTimestampString() {
-  auto tNow = std::chrono::system_clock::now();
-  return std::format(
-      "{:%Y%m%d_%H%M%S}", std::chrono::floor<std::chrono::seconds>(tNow));
-}
-
-std::string getISODateString() {
-  auto tNow = std::chrono::system_clock::now();
-  return std::format(
-      "{:%Y-%m-%d}", std::chrono::floor<std::chrono::days>(tNow));
-}
-
-FileFormat formatFromFlags(size_t flags) {
-  uint8_t formatFlag = static_cast<uint8_t>(flags & 0xF);
-
-  switch (formatFlag) {
-    case 1:
-      return FileFormat::WAV;
-    case 2:
-      return FileFormat::CAF;
-    case 3:
-      return FileFormat::M4A;
-    case 4:
-      return FileFormat::FLAC;
-    default:
-      return FileFormat::M4A;
-  }
-}
-
-FileDirectory directoryFromFlags(size_t flags) {
-  uint8_t directoryFlag = static_cast<uint8_t>((flags >> 4) & 0xF);
-
-  switch (directoryFlag) {
-    case 1:
-      return FileDirectory::FILES_DIR;
-    case 2:
-      return FileDirectory::CACHE_DIR;
-    default:
-      return FileDirectory::CACHE_DIR;
-  }
-}
-
-BitDepth bitDepthFromFlags(size_t flags) {
-  uint8_t bitDepthFlag = static_cast<uint8_t>((flags >> 8) & 0xF);
-
-  switch (bitDepthFlag) {
-    case 1:
-      return BitDepth::BIT_16;
-    case 2:
-      return BitDepth::BIT_24;
-    case 3:
-      return BitDepth::BIT_32;
-    default:
-      return BitDepth::BIT_32;
-  }
-}
-
-std::string getDirectory(FileDirectory dir) {
-  switch (dir) {
-    case FileDirectory::FILES_DIR:
-      return NativeFileInfo::getFilesDir();
-    case FileDirectory::CACHE_DIR:
-      return NativeFileInfo::getCacheDir();
-    default:
-      return NativeFileInfo::getCacheDir();
-  }
-}
-
-std::string getFilePath(
-    const FileDirectory &directory,
-    const std::string &baseFileName,
-    const std::string &extension) {
-  std::string basePath = getDirectory(directory);
-  std::string subDirectory = getISODateString();
-  std::string fileTimestamp = getTimestampString();
-
-  std::string subDirectoryPath =
-      std::format("{}/AudioAPI/{}", basePath, subDirectory);
-
-  if (!createDirectoryIfNotExists(subDirectoryPath)) {
-    return "";
-  }
-
-  return std::format(
-      "{}/{}_{}.{}", subDirectoryPath, baseFileName, fileTimestamp, extension);
-}
-
-} // namespace audioapi::android::fileutils

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegAudioFileOptions.cpp

@@ -1,154 +0,0 @@
-
-#include <audioapi/android/core/utils/FileUtils.h>
-#include <audioapi/android/core/utils/ffmpegBackend/FFmpegAudioFileOptions.h>
-
-namespace audioapi {
-
-FFmpegAudioFileOptions::FFmpegAudioFileOptions(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t flags)
-    : sampleRate_(sampleRate),
-      channelCount_(channelCount),
-      bitRate_(bitRate),
-      flags_(flags) {}
-
-std::string FFmpegAudioFileOptions::getFileExtension() const {
-  android::fileutils::FileFormat format =
-      android::fileutils::formatFromFlags(flags_);
-
-  switch (format) {
-    // WAV is encoded using miniaudio, so it is not necessary here
-    // but lets leave it for convenience
-    // when using FFmpeg we will use M4A as default format
-    case android::fileutils::FileFormat::WAV:
-      return "wav";
-    case android::fileutils::FileFormat::CAF:
-      return "caf";
-    case android::fileutils::FileFormat::M4A:
-      return "m4a";
-    case android::fileutils::FileFormat::FLAC:
-      return "flac";
-    default:
-      return "m4a";
-  }
-}
-
-AVCodecID FFmpegAudioFileOptions::getPCMCodecID() const {
-  android::fileutils::BitDepth bitDepth =
-      android::fileutils::bitDepthFromFlags(flags_);
-
-  switch (bitDepth) {
-    case android::fileutils::BitDepth::BIT_16:
-      return AV_CODEC_ID_PCM_S16LE;
-    case android::fileutils::BitDepth::BIT_24:
-      return AV_CODEC_ID_PCM_S24LE;
-    case android::fileutils::BitDepth::BIT_32:
-      return AV_CODEC_ID_PCM_F32LE;
-    default:
-      return AV_CODEC_ID_PCM_F32LE;
-  }
-}
-
-AVCodecID FFmpegAudioFileOptions::getCodecID() const {
-  android::fileutils::FileFormat format =
-      android::fileutils::formatFromFlags(flags_);
-
-  switch (format) {
-    case android::fileutils::FileFormat::WAV:
-    case android::fileutils::FileFormat::CAF:
-      return getPCMCodecID();
-    case android::fileutils::FileFormat::M4A:
-      return AV_CODEC_ID_AAC;
-    case android::fileutils::FileFormat::FLAC:
-      return AV_CODEC_ID_FLAC;
-    default:
-      return AV_CODEC_ID_AAC;
-  }
-}
-
-AVSampleFormat FFmpegAudioFileOptions::getSampleFormat() const {
-  android::fileutils::FileFormat format =
-      android::fileutils::formatFromFlags(flags_);
-  android::fileutils::BitDepth bitDepth =
-      android::fileutils::bitDepthFromFlags(flags_);
-
-  if (format == android::fileutils::FileFormat::M4A) {
-    return AV_SAMPLE_FMT_FLTP;
-  }
-
-  switch (bitDepth) {
-    case android::fileutils::BitDepth::BIT_16:
-      return AV_SAMPLE_FMT_S16;
-    case android::fileutils::BitDepth::BIT_24:
-      return AV_SAMPLE_FMT_S32;
-    case android::fileutils::BitDepth::BIT_32:
-      return AV_SAMPLE_FMT_FLT;
-    default:
-      return AV_SAMPLE_FMT_FLT;
-  }
-}
-
-const AVCodec *FFmpegAudioFileOptions::getCodec() {
-  return avcodec_find_encoder(getCodecID());
-}
-
-std::string FFmpegAudioFileOptions::getFilePath(
-    const std::string &baseFileName) const {
-  std::string extension = getFileExtension();
-
-  return android::fileutils::getFilePath(
-      android::fileutils::directoryFromFlags(flags_), baseFileName, extension);
-}
-
-float FFmpegAudioFileOptions::getSampleRate() const {
-  return sampleRate_;
-}
-
-size_t FFmpegAudioFileOptions::getChannelCount() const {
-  return channelCount_;
-}
-
-size_t FFmpegAudioFileOptions::getBitRate() const {
-  android::fileutils::FileFormat format =
-      android::fileutils::formatFromFlags(flags_);
-
-  if (format != android::fileutils::FileFormat::M4A) {
-    return 0; // bit rate is not used for PCM formats
-  } else
-
-    return bitRate_;
-}
-
-int FFmpegAudioFileOptions::getFlacCompressionLevel() const {
-  android::fileutils::FileFormat format =
-      android::fileutils::formatFromFlags(flags_);
-
-  if (format != android::fileutils::FileFormat::FLAC) {
-    return -1; // compression level is not used for non-FLAC formats
-  }
-
-  // TODO: extract compression level from flags
-  return 5; // default compression level
-}
-
-std::string FFmpegAudioFileOptions::getMuxerName() const {
-  android::fileutils::FileFormat format =
-      android::fileutils::formatFromFlags(flags_);
-
-  switch (format) {
-    case android::fileutils::FileFormat::WAV:
-      return "wav";
-    case android::fileutils::FileFormat::CAF:
-      return "caf";
-    case android::fileutils::FileFormat::M4A:
-      return "mp4";
-    case android::fileutils::FileFormat::FLAC:
-      return "flac";
-    default:
-      return "mp4";
-  }
-}
-
-} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegAudioFileOptions.h

@@ -1,41 +0,0 @@
-#pragma once
-
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libswresample/swresample.h>
-}
-
-#include <cstddef>
-#include <cstdint>
-#include <string>
-
-namespace audioapi {
-
-class FFmpegAudioFileOptions {
- public:
-  FFmpegAudioFileOptions(float sampleRate, size_t channelCount, size_t bitRate, size_t flags);
-  ~FFmpegAudioFileOptions() = default;
-
-  std::string getFileExtension() const;
-  std::string getFilePath(const std::string &baseFileName) const;
-
-  float getSampleRate() const;
-  size_t getChannelCount() const;
-
-  AVCodecID getPCMCodecID() const;
-  AVCodecID getCodecID() const;
-  AVSampleFormat getSampleFormat() const;
-  const AVCodec* getCodec();
-  size_t getBitRate() const;
-  int getFlacCompressionLevel() const;
-  std::string getMuxerName() const;
-
- private:
-  float sampleRate_;
-  size_t channelCount_;
-  size_t flags_;
-  size_t bitRate_;
-};
-
-} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileOptions.cpp

@@ -1,47 +0,0 @@
-
-#include <audioapi/android/core/utils/FileUtils.h>
-#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileOptions.h>
-
-namespace audioapi {
-
-MiniAudioFileOptions::MiniAudioFileOptions(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t flags)
-    : sampleRate_(sampleRate), channelCount_(channelCount), flags_(flags) {};
-
-ma_encoding_format MiniAudioFileOptions::getFormat() const {
-  return ma_encoding_format_wav;
-}
-
-std::string MiniAudioFileOptions::getFilePath(
-    const std::string &baseFileName) const {
-  return android::fileutils::getFilePath(
-      android::fileutils::directoryFromFlags(flags_), baseFileName, "wav");
-}
-
-float MiniAudioFileOptions::getSampleRate() const {
-  return sampleRate_;
-}
-
-size_t MiniAudioFileOptions::getChannelCount() const {
-  return channelCount_;
-}
-
-ma_format MiniAudioFileOptions::getDataFormat() const {
-  android::fileutils::BitDepth bitDepth =
-      android::fileutils::bitDepthFromFlags(flags_);
-  switch (bitDepth) {
-    case android::fileutils::BitDepth::BIT_16:
-      return ma_format_s16;
-    case android::fileutils::BitDepth::BIT_24:
-      return ma_format_s24;
-    case android::fileutils::BitDepth::BIT_32:
-      return ma_format_f32;
-    default:
-      return ma_format_f32;
-  }
-}
-
-} // namespace audioapi