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

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/src/web-system/index.ts

@@ -0,0 +1 @@
+export * from './notification';

package/src/web-system/notification/PlaybackNotificationManager.ts

@@ -0,0 +1,64 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-useless-constructor */
+/* eslint-disable @typescript-eslint/require-await */
+
+import type { AudioEventSubscription } from '../../events';
+import type {
+  NotificationEvents,
+  NotificationManager,
+  PlaybackControlName,
+  PlaybackNotificationEventName,
+  PlaybackNotificationInfo,
+} from '../../system';
+
+/// Mock Manager for playback notifications. Does nothing.
+class PlaybackNotificationManager
+  implements
+    NotificationManager<
+      PlaybackNotificationInfo,
+      PlaybackNotificationInfo,
+      PlaybackNotificationEventName
+    >
+{
+  private isRegistered_ = false;
+  private isShown_ = false;
+
+  constructor() {}
+
+  async register(): Promise<void> {}
+
+  async show(info: PlaybackNotificationInfo): Promise<void> {}
+
+  async update(info: PlaybackNotificationInfo): Promise<void> {}
+
+  async hide(): Promise<void> {}
+
+  async unregister(): Promise<void> {}
+
+  async enableControl(
+    control: PlaybackControlName,
+    enabled: boolean
+  ): Promise<void> {}
+
+  async isActive(): Promise<boolean> {
+    return this.isShown_;
+  }
+
+  isRegistered(): boolean {
+    return this.isRegistered_;
+  }
+
+  addEventListener<T extends PlaybackNotificationEventName>(
+    eventName: T,
+    callback: (event: NotificationEvents[T]) => void
+  ): AudioEventSubscription {
+    // dummy subscription object with a no-op remove method
+    return {
+      remove: () => {},
+    } as unknown as AudioEventSubscription;
+  }
+
+  removeEventListener(subscription: AudioEventSubscription): void {}
+}
+
+export default new PlaybackNotificationManager();

package/src/web-system/notification/RecordingNotificationManager.ts

@@ -0,0 +1,64 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-useless-constructor */
+/* eslint-disable @typescript-eslint/require-await */
+
+import type { AudioEventSubscription } from '../../events';
+import type {
+  NotificationEvents,
+  NotificationManager,
+  RecordingControlName,
+  RecordingNotificationEventName,
+  RecordingNotificationInfo,
+} from '../../system';
+
+/// Mock Manager for recording notifications. Does nothing.
+class RecordingNotificationManager
+  implements
+    NotificationManager<
+      RecordingNotificationInfo,
+      RecordingNotificationInfo,
+      RecordingNotificationEventName
+    >
+{
+  private isRegistered_ = false;
+  private isShown_ = false;
+
+  constructor() {}
+
+  async register(): Promise<void> {}
+
+  async show(info: RecordingNotificationInfo): Promise<void> {}
+
+  async update(info: RecordingNotificationInfo): Promise<void> {}
+
+  async hide(): Promise<void> {}
+
+  async unregister(): Promise<void> {}
+
+  async enableControl(
+    control: RecordingControlName,
+    enabled: boolean
+  ): Promise<void> {}
+
+  async isActive(): Promise<boolean> {
+    return this.isShown_;
+  }
+
+  isRegistered(): boolean {
+    return this.isRegistered_;
+  }
+
+  addEventListener<T extends RecordingNotificationEventName>(
+    eventName: T,
+    callback: (event: NotificationEvents[T]) => void
+  ): AudioEventSubscription {
+    // dummy subscription object with a no-op remove method
+    return {
+      remove: () => {},
+    } as unknown as AudioEventSubscription;
+  }
+
+  removeEventListener(subscription: AudioEventSubscription): void {}
+}
+
+export default new RecordingNotificationManager();

package/src/web-system/notification/index.ts

@@ -0,0 +1,2 @@
+export { default as PlaybackNotificationManager } from './PlaybackNotificationManager';
+export { default as RecordingNotificationManager } from './RecordingNotificationManager';

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