react-native-audio-api 0.0.1 → 0.2.0

package/src/core/BaseAudioContext.ts

@@ -0,0 +1,97 @@
+import { IBaseAudioContext } from '../interfaces';
+import { ContextState, PeriodicWaveConstraints } from './types';
+import AudioDestinationNode from './AudioDestinationNode';
+import OscillatorNode from './OscillatorNode';
+import GainNode from './GainNode';
+import StereoPannerNode from './StereoPannerNode';
+import BiquadFilterNode from './BiquadFilterNode';
+import AudioBufferSourceNode from './AudioBufferSourceNode';
+import AudioBuffer from './AudioBuffer';
+import PeriodicWave from './PeriodicWave';
+import { InvalidAccessError } from '../errors';
+
+export default class BaseAudioContext {
+  readonly destination: AudioDestinationNode;
+  readonly sampleRate: number;
+  protected readonly context: IBaseAudioContext;
+
+  constructor(context: IBaseAudioContext) {
+    this.context = context;
+    this.destination = new AudioDestinationNode(this, context.destination);
+    this.sampleRate = context.sampleRate;
+  }
+
+  public get currentTime(): number {
+    return this.context.currentTime;
+  }
+
+  public get state(): ContextState {
+    return this.context.state;
+  }
+
+  createOscillator(): OscillatorNode {
+    return new OscillatorNode(this, this.context.createOscillator());
+  }
+
+  createGain(): GainNode {
+    return new GainNode(this, this.context.createGain());
+  }
+
+  createStereoPanner(): StereoPannerNode {
+    return new StereoPannerNode(this, this.context.createStereoPanner());
+  }
+
+  createBiquadFilter(): BiquadFilterNode {
+    return new BiquadFilterNode(this, this.context.createBiquadFilter());
+  }
+
+  createBufferSource(): AudioBufferSourceNode {
+    return new AudioBufferSourceNode(this, this.context.createBufferSource());
+  }
+
+  createBuffer(
+    numOfChannels: number,
+    length: number,
+    sampleRate: number
+  ): AudioBuffer {
+    if (numOfChannels < 1 || numOfChannels > 3) {
+      throw new RangeError(
+        `The number of channels provided (${numOfChannels}) is outside the range [1, 2]`
+      );
+    }
+
+    if (length <= 0) {
+      throw new RangeError(
+        `The number of frames provided (${length}) is less than or equal to the minimum bound (0)`
+      );
+    }
+
+    if (sampleRate <= 0) {
+      throw new RangeError(
+        `The sample rate provided (${sampleRate}) is outside the range [3000, 768000]`
+      );
+    }
+
+    return new AudioBuffer(
+      this.context.createBuffer(numOfChannels, length, sampleRate)
+    );
+  }
+
+  createPeriodicWave(
+    real: number[],
+    imag: number[],
+    constraints?: PeriodicWaveConstraints
+  ): PeriodicWave {
+    if (real.length !== imag.length) {
+      throw new InvalidAccessError(
+        `The lengths of the real (${real.length}) and imaginary (${imag.length}) arrays must match.`
+      );
+    }
+
+    const disableNormalization = constraints?.disableNormalization ?? false;
+
+    return new PeriodicWave(
+      this.context.createPeriodicWave(real, imag, disableNormalization)
+    );
+  }
+}

package/src/core/BiquadFilterNode.ts

@@ -0,0 +1,49 @@
+import { InvalidAccessError } from '../errors';
+import { IBiquadFilterNode } from '../interfaces';
+import AudioNode from './AudioNode';
+import AudioParam from './AudioParam';
+import BaseAudioContext from './BaseAudioContext';
+import { BiquadFilterType } from './types';
+
+export default class BiquadFilterNode extends AudioNode {
+  readonly frequency: AudioParam;
+  readonly detune: AudioParam;
+  readonly Q: AudioParam;
+  readonly gain: AudioParam;
+
+  constructor(context: BaseAudioContext, biquadFilter: IBiquadFilterNode) {
+    super(context, biquadFilter);
+    this.frequency = new AudioParam(biquadFilter.frequency);
+    this.detune = new AudioParam(biquadFilter.detune);
+    this.Q = new AudioParam(biquadFilter.Q);
+    this.gain = new AudioParam(biquadFilter.gain);
+  }
+
+  public get type(): BiquadFilterType {
+    return (this.node as IBiquadFilterNode).type;
+  }
+
+  public set type(value: BiquadFilterType) {
+    (this.node as IBiquadFilterNode).type = value;
+  }
+
+  public getFrequencyResponse(
+    frequencyArray: number[],
+    magResponseOutput: number[],
+    phaseResponseOutput: number[]
+  ) {
+    if (
+      frequencyArray.length !== magResponseOutput.length ||
+      frequencyArray.length !== phaseResponseOutput.length
+    ) {
+      throw new InvalidAccessError(
+        `The lengths of the arrays are not the same frequencyArray: ${frequencyArray.length}, magResponseOutput: ${magResponseOutput.length}, phaseResponseOutput: ${phaseResponseOutput.length}`
+      );
+    }
+    (this.node as IBiquadFilterNode).getFrequencyResponse(
+      frequencyArray,
+      magResponseOutput,
+      phaseResponseOutput
+    );
+  }
+}

package/src/core/GainNode.ts

@@ -0,0 +1,13 @@
+import { IGainNode } from '../interfaces';
+import AudioNode from './AudioNode';
+import AudioParam from './AudioParam';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class GainNode extends AudioNode {
+  readonly gain: AudioParam;
+
+  constructor(context: BaseAudioContext, gain: IGainNode) {
+    super(context, gain);
+    this.gain = new AudioParam(gain.gain);
+  }
+}

package/src/core/OscillatorNode.ts

@@ -0,0 +1,37 @@
+import { IOscillatorNode } from '../interfaces';
+import { OscillatorType } from './types';
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import AudioParam from './AudioParam';
+import BaseAudioContext from './BaseAudioContext';
+import PeriodicWave from './PeriodicWave';
+import { InvalidStateError } from '../errors';
+
+export default class OscillatorNode extends AudioScheduledSourceNode {
+  readonly frequency: AudioParam;
+  readonly detune: AudioParam;
+
+  constructor(context: BaseAudioContext, node: IOscillatorNode) {
+    super(context, node);
+    this.frequency = new AudioParam(node.frequency);
+    this.detune = new AudioParam(node.detune);
+    this.type = node.type;
+  }
+
+  public get type(): OscillatorType {
+    return (this.node as IOscillatorNode).type;
+  }
+
+  public set type(value: OscillatorType) {
+    if (value === 'custom') {
+      throw new InvalidStateError(
+        "'type' cannot be set directly to 'custom'.  Use setPeriodicWave() to create a custom Oscillator type."
+      );
+    }
+
+    (this.node as IOscillatorNode).type = value;
+  }
+
+  public setPeriodicWave(wave: PeriodicWave): void {
+    (this.node as IOscillatorNode).setPeriodicWave(wave.periodicWave);
+  }
+}

package/src/core/PeriodicWave.ts

@@ -0,0 +1,10 @@
+import { IPeriodicWave } from '../interfaces';
+
+export default class PeriodicWave {
+  /** @internal */
+  public readonly periodicWave: IPeriodicWave;
+
+  constructor(periodicWave: IPeriodicWave) {
+    this.periodicWave = periodicWave;
+  }
+}

package/src/core/StereoPannerNode.ts

@@ -0,0 +1,13 @@
+import { IStereoPannerNode } from '../interfaces';
+import AudioNode from './AudioNode';
+import AudioParam from './AudioParam';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class StereoPannerNode extends AudioNode {
+  readonly pan: AudioParam;
+
+  constructor(context: BaseAudioContext, pan: IStereoPannerNode) {
+    super(context, pan);
+    this.pan = new AudioParam(pan.pan);
+  }
+}

package/src/core/types.ts

@@ -0,0 +1,26 @@
+export type ChannelCountMode = 'max' | 'clamped-max' | 'explicit';
+
+export type ChannelInterpretation = 'speakers' | 'discrete';
+
+export type BiquadFilterType =
+  | 'lowpass'
+  | 'highpass'
+  | 'bandpass'
+  | 'lowshelf'
+  | 'highshelf'
+  | 'peaking'
+  | 'notch'
+  | 'allpass';
+
+export type ContextState = 'running' | 'closed';
+
+export type OscillatorType =
+  | 'sine'
+  | 'square'
+  | 'sawtooth'
+  | 'triangle'
+  | 'custom';
+
+export interface PeriodicWaveConstraints {
+  disableNormalization: boolean;
+}

package/src/errors/IndexSizeError.ts

@@ -0,0 +1,8 @@
+class IndexSizeError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'IndexSizeError';
+  }
+}
+
+export default IndexSizeError;

package/src/errors/InvalidAccessError.ts

@@ -0,0 +1,8 @@
+class InvalidAccessError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InvalidAccessError';
+  }
+}
+
+export default InvalidAccessError;

package/src/errors/InvalidStateError.ts

@@ -0,0 +1,8 @@
+class InvalidStateError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InvalidStateError';
+  }
+}
+
+export default InvalidStateError;

package/src/errors/RangeError.ts

@@ -0,0 +1,8 @@
+class RangeError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'RangeError';
+  }
+}
+
+export default RangeError;

package/src/errors/index.ts

@@ -0,0 +1,4 @@
+export { default as IndexSizeError } from './IndexSizeError';
+export { default as InvalidAccessError } from './InvalidAccessError';
+export { default as InvalidStateError } from './InvalidStateError';
+export { default as RangeError } from './RangeError';

package/src/index.ts

@@ -0,0 +1,25 @@
+import { installModule } from './utils/install';
+
+if (global.__AudioAPIInstaller == null) {
+  installModule();
+}
+
+export { default as AudioBuffer } from './core/AudioBuffer';
+export { default as AudioBufferSourceNode } from './core/AudioBufferSourceNode';
+export { default as AudioContext } from './core/AudioContext';
+export { default as AudioDestinationNode } from './core/AudioDestinationNode';
+export { default as AudioNode } from './core/AudioNode';
+export { default as AudioParam } from './core/AudioParam';
+export { default as AudioScheduledSourceNode } from './core/AudioScheduledSourceNode';
+export { default as BaseAudioContext } from './core/BaseAudioContext';
+export { default as BiquadFilterNode } from './core/BiquadFilterNode';
+export { default as GainNode } from './core/GainNode';
+export { default as OscillatorNode } from './core/OscillatorNode';
+export { default as StereoPannerNode } from './core/StereoPannerNode';
+export {
+  OscillatorType,
+  BiquadFilterType,
+  ChannelCountMode,
+  ChannelInterpretation,
+  ContextState,
+} from './core/types';

package/src/interfaces.ts

@@ -0,0 +1,120 @@
+import {
+  ContextState,
+  BiquadFilterType,
+  OscillatorType,
+  ChannelCountMode,
+  ChannelInterpretation,
+} from './core/types';
+
+export interface IBaseAudioContext {
+  readonly destination: IAudioDestinationNode;
+  readonly state: ContextState;
+  readonly sampleRate: number;
+  readonly currentTime: number;
+
+  createOscillator(): IOscillatorNode;
+  createGain(): IGainNode;
+  createStereoPanner(): IStereoPannerNode;
+  createBiquadFilter: () => IBiquadFilterNode;
+  createBufferSource: () => IAudioBufferSourceNode;
+  createBuffer: (
+    channels: number,
+    length: number,
+    sampleRate: number
+  ) => IAudioBuffer;
+  createPeriodicWave: (
+    real: number[],
+    imag: number[],
+    disableNormalization: boolean
+  ) => IPeriodicWave;
+}
+
+export interface IAudioContext extends IBaseAudioContext {
+  close(): void;
+}
+
+export interface IAudioNode {
+  readonly context: BaseAudioContext;
+  readonly numberOfInputs: number;
+  readonly numberOfOutputs: number;
+  readonly channelCount: number;
+  readonly channelCountMode: ChannelCountMode;
+  readonly channelInterpretation: ChannelInterpretation;
+
+  connect: (node: IAudioNode) => void;
+  disconnect: (node: IAudioNode) => void;
+}
+
+export interface IGainNode extends IAudioNode {
+  readonly gain: IAudioParam;
+}
+
+export interface IStereoPannerNode extends IAudioNode {
+  readonly pan: IAudioParam;
+}
+
+export interface IBiquadFilterNode extends IAudioNode {
+  readonly frequency: AudioParam;
+  readonly detune: AudioParam;
+  readonly Q: AudioParam;
+  readonly gain: AudioParam;
+  type: BiquadFilterType;
+
+  getFrequencyResponse(
+    frequencyArray: number[],
+    magResponseOutput: number[],
+    phaseResponseOutput: number[]
+  ): void;
+}
+
+export interface IAudioDestinationNode extends IAudioNode {}
+
+export interface IAudioScheduledSourceNode extends IAudioNode {
+  start: (time: number) => void;
+  stop: (time: number) => void;
+}
+
+export interface IOscillatorNode extends IAudioScheduledSourceNode {
+  readonly frequency: IAudioParam;
+  readonly detune: IAudioParam;
+  type: OscillatorType;
+
+  setPeriodicWave(periodicWave: IPeriodicWave): void;
+}
+
+export interface IAudioBufferSourceNode extends IAudioScheduledSourceNode {
+  buffer: IAudioBuffer | null;
+  loop: boolean;
+}
+
+export interface IAudioBuffer {
+  readonly length: number;
+  readonly duration: number;
+  readonly sampleRate: number;
+  readonly numberOfChannels: number;
+
+  getChannelData(channel: number): number[];
+  copyFromChannel(
+    destination: number[],
+    channelNumber: number,
+    startInChannel: number
+  ): void;
+  copyToChannel(
+    source: number[],
+    channelNumber: number,
+    startInChannel: number
+  ): void;
+}
+
+export interface IAudioParam {
+  value: number;
+  defaultValue: number;
+  minValue: number;
+  maxValue: number;
+
+  setValueAtTime: (value: number, startTime: number) => void;
+  linearRampToValueAtTime: (value: number, endTime: number) => void;
+  exponentialRampToValueAtTime: (value: number, endTime: number) => void;
+}
+
+export interface IPeriodicWave {}

package/src/modules/global.d.ts

@@ -0,0 +1,10 @@
+import type { IAudioContext } from '../interfaces';
+
+type AudioAPIInstaller = {
+  createAudioContext: () => IAudioContext;
+};
+
+declare global {
+  function nativeCallSyncHook(): unknown;
+  var __AudioAPIInstaller: AudioAPIInstaller;
+}

package/src/utils/install.ts

@@ -0,0 +1,39 @@
+import { TurboModuleRegistry, TurboModule } from 'react-native';
+
+interface AudioAPIModuleSpec extends TurboModule {
+  install(): boolean;
+}
+
+export function installModule() {
+  const AudioAPIModule =
+    TurboModuleRegistry.getEnforcing<AudioAPIModuleSpec>('AudioAPIModule');
+
+  if (AudioAPIModule == null) {
+    throw new Error(
+      `Failed to install react-native-audio-api: The native module could not be found.`
+    );
+  }
+
+  runInstall(AudioAPIModule);
+  verifyInstallation();
+
+  return AudioAPIModule;
+}
+
+function runInstall(Module: any) {
+  const result = Module.install();
+
+  if (result !== true) {
+    throw new Error(
+      `Failed to install react-native-audio-api: The native Audio API Module could not be installed! Looks like something went wrong when installing JSI bindings: ${result}`
+    );
+  }
+}
+
+function verifyInstallation() {
+  if (global.__AudioAPIInstaller == null) {
+    throw new Error(
+      'Failed to install react-native-audio-api, the native initializer private does not exist. Are you trying to use Audio API from different JS Runtimes?'
+    );
+  }
+}

package/index.ts

@@ -1 +0,0 @@
-export default {};