react-native-audio-api 0.1.0 → 0.2.0

package/lib/typescript/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../src/interfaces.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/core/AudioBuffer.ts

@@ -0,0 +1,68 @@
+import { IAudioBuffer } from '../interfaces';
+import { IndexSizeError } from '../errors';
+
+export default class AudioBuffer {
+  readonly length: number;
+  readonly duration: number;
+  readonly sampleRate: number;
+  readonly numberOfChannels: number;
+  /** @internal */
+  public readonly buffer: IAudioBuffer;
+
+  constructor(buffer: IAudioBuffer) {
+    this.buffer = buffer;
+    this.length = buffer.length;
+    this.duration = buffer.duration;
+    this.sampleRate = buffer.sampleRate;
+    this.numberOfChannels = buffer.numberOfChannels;
+  }
+
+  public getChannelData(channel: number): number[] {
+    if (channel < 0 || channel >= this.numberOfChannels) {
+      throw new IndexSizeError(
+        `The channel number provided (${channel}) is outside the range [0, ${this.numberOfChannels - 1}]`
+      );
+    }
+    return this.buffer.getChannelData(channel);
+  }
+
+  public copyFromChannel(
+    destination: number[],
+    channelNumber: number,
+    startInChannel: number = 0
+  ): void {
+    if (channelNumber < 0 || channelNumber >= this.numberOfChannels) {
+      throw new IndexSizeError(
+        `The channel number provided (${channelNumber}) is outside the range [0, ${this.numberOfChannels - 1}]`
+      );
+    }
+
+    if (startInChannel < 0 || startInChannel >= this.length) {
+      throw new IndexSizeError(
+        `The startInChannel number provided (${startInChannel}) is outside the range [0, ${this.length - 1}]`
+      );
+    }
+
+    this.buffer.copyFromChannel(destination, channelNumber, startInChannel);
+  }
+
+  public copyToChannel(
+    source: number[],
+    channelNumber: number,
+    startInChannel: number = 0
+  ): void {
+    if (channelNumber < 0 || channelNumber >= this.numberOfChannels) {
+      throw new IndexSizeError(
+        `The channel number provided (${channelNumber}) is outside the range [0, ${this.numberOfChannels - 1}]`
+      );
+    }
+
+    if (startInChannel < 0 || startInChannel >= this.length) {
+      throw new IndexSizeError(
+        `The startInChannel number provided (${startInChannel}) is outside the range [0, ${this.length - 1}]`
+      );
+    }
+
+    this.buffer.copyToChannel(source, channelNumber, startInChannel);
+  }
+}

package/src/core/AudioBufferSourceNode.ts

@@ -0,0 +1,35 @@
+import { IAudioBufferSourceNode } from '../interfaces';
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import BaseAudioContext from './BaseAudioContext';
+import AudioBuffer from './AudioBuffer';
+
+export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
+  constructor(context: BaseAudioContext, node: IAudioBufferSourceNode) {
+    super(context, node);
+  }
+
+  public get buffer(): AudioBuffer | null {
+    const buffer = (this.node as IAudioBufferSourceNode).buffer;
+    if (!buffer) {
+      return null;
+    }
+    return new AudioBuffer(buffer);
+  }
+
+  public set buffer(buffer: AudioBuffer | null) {
+    if (!buffer) {
+      (this.node as IAudioBufferSourceNode).buffer = null;
+      return;
+    }
+
+    (this.node as IAudioBufferSourceNode).buffer = buffer.buffer;
+  }
+
+  public get loop(): boolean {
+    return (this.node as IAudioBufferSourceNode).loop;
+  }
+
+  public set loop(value: boolean) {
+    (this.node as IAudioBufferSourceNode).loop = value;
+  }
+}

package/src/core/AudioContext.ts

@@ -0,0 +1,12 @@
+import { IAudioContext } from '../interfaces';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class AudioContext extends BaseAudioContext {
+  constructor() {
+    super(global.__AudioAPIInstaller.createAudioContext());
+  }
+
+  close(): void {
+    (this.context as IAudioContext).close();
+  }
+}

package/src/core/AudioDestinationNode.ts

@@ -0,0 +1,9 @@
+import { IAudioDestinationNode } from '../interfaces';
+import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class AudioDestinationNode extends AudioNode {
+  constructor(context: BaseAudioContext, destination: IAudioDestinationNode) {
+    super(context, destination);
+  }
+}

package/src/core/AudioNode.ts

@@ -0,0 +1,38 @@
+import { IAudioNode } from '../interfaces';
+import { ChannelCountMode, ChannelInterpretation } from './types';
+import BaseAudioContext from './BaseAudioContext';
+import { InvalidAccessError } from '../errors';
+
+export default class AudioNode {
+  readonly context: BaseAudioContext;
+  readonly numberOfInputs: number;
+  readonly numberOfOutputs: number;
+  readonly channelCount: number;
+  readonly channelCountMode: ChannelCountMode;
+  readonly channelInterpretation: ChannelInterpretation;
+  protected readonly node: IAudioNode;
+
+  constructor(context: BaseAudioContext, node: IAudioNode) {
+    this.context = context;
+    this.node = node;
+    this.numberOfInputs = this.node.numberOfInputs;
+    this.numberOfOutputs = this.node.numberOfOutputs;
+    this.channelCount = this.node.channelCount;
+    this.channelCountMode = this.node.channelCountMode;
+    this.channelInterpretation = this.node.channelInterpretation;
+  }
+
+  public connect(node: AudioNode): void {
+    if (this.context !== node.context) {
+      throw new InvalidAccessError(
+        'The AudioNodes are from different BaseAudioContexts'
+      );
+    }
+
+    this.node.connect(node.node);
+  }
+
+  public disconnect(node: AudioNode): void {
+    this.node.disconnect(node.node);
+  }
+}

package/src/core/AudioParam.ts

@@ -0,0 +1,55 @@
+import { IAudioParam } from '../interfaces';
+import { RangeError } from '../errors';
+
+export default class AudioParam {
+  readonly defaultValue: number;
+  readonly minValue: number;
+  readonly maxValue: number;
+  private readonly audioParam: IAudioParam;
+
+  constructor(audioParam: IAudioParam) {
+    this.audioParam = audioParam;
+    this.value = audioParam.value;
+    this.defaultValue = audioParam.defaultValue;
+    this.minValue = audioParam.minValue;
+    this.maxValue = audioParam.maxValue;
+  }
+
+  public get value(): number {
+    return this.audioParam.value;
+  }
+
+  public set value(value: number) {
+    this.audioParam.value = value;
+  }
+
+  public setValueAtTime(value: number, startTime: number): void {
+    if (startTime < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${startTime}`
+      );
+    }
+
+    this.audioParam.setValueAtTime(value, startTime);
+  }
+
+  public linearRampToValueAtTime(value: number, endTime: number): void {
+    if (endTime < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${endTime}`
+      );
+    }
+
+    this.audioParam.linearRampToValueAtTime(value, endTime);
+  }
+
+  public exponentialRampToValueAtTime(value: number, endTime: number): void {
+    if (endTime < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${endTime}`
+      );
+    }
+
+    this.audioParam.exponentialRampToValueAtTime(value, endTime);
+  }
+}

package/src/core/AudioScheduledSourceNode.ts

@@ -0,0 +1,43 @@
+import { IAudioScheduledSourceNode } from '../interfaces';
+import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
+import { InvalidStateError, RangeError } from '../errors';
+
+export default class AudioScheduledSourceNode extends AudioNode {
+  private hasBeenStarted: boolean = false;
+
+  constructor(context: BaseAudioContext, node: IAudioScheduledSourceNode) {
+    super(context, node);
+  }
+
+  public start(when: number = 0): void {
+    if (when < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${when}`
+      );
+    }
+
+    if (this.hasBeenStarted) {
+      throw new InvalidStateError('Cannot call start more than once');
+    }
+
+    this.hasBeenStarted = true;
+    (this.node as IAudioScheduledSourceNode).start(when);
+  }
+
+  public stop(when: number = 0): void {
+    if (when < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${when}`
+      );
+    }
+
+    if (!this.hasBeenStarted) {
+      throw new InvalidStateError(
+        'Cannot call stop without calling start first'
+      );
+    }
+
+    (this.node as IAudioScheduledSourceNode).stop(when);
+  }
+}

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

@@ -1,79 +1,25 @@
-import type {
-  BaseAudioContext,
-  AudioDestinationNode,
-  GainNode,
-  StereoPannerNode,
-  OscillatorNode,
-  BiquadFilterNode,
-  AudioBufferSourceNode,
-  AudioBuffer,
-  WaveType,
-} from './types';
 import { installModule } from './utils/install';
 
 if (global.__AudioAPIInstaller == null) {
   installModule();
 }
 
-export class AudioContext implements BaseAudioContext {
-  readonly destination: AudioDestinationNode;
-  readonly sampleRate: number;
-  private readonly __AudioContext: BaseAudioContext;
-
-  constructor() {
-    this.__AudioContext = global.__AudioAPIInstaller.createAudioContext();
-
-    this.destination = this.__AudioContext.destination;
-    this.sampleRate = this.__AudioContext.sampleRate;
-  }
-
-  public get currentTime() {
-    return this.__AudioContext.currentTime;
-  }
-
-  public get state() {
-    return this.__AudioContext.state;
-  }
-
-  createOscillator(): OscillatorNode {
-    return this.__AudioContext.createOscillator();
-  }
-
-  createGain(): GainNode {
-    return this.__AudioContext.createGain();
-  }
-
-  createStereoPanner(): StereoPannerNode {
-    return this.__AudioContext.createStereoPanner();
-  }
-
-  createBiquadFilter(): BiquadFilterNode {
-    return this.__AudioContext.createBiquadFilter();
-  }
-
-  createBufferSource(): AudioBufferSourceNode {
-    return this.__AudioContext.createBufferSource();
-  }
-
-  createBuffer(
-    numOfChannels: number,
-    length: number,
-    sampleRate: number
-  ): AudioBuffer {
-    return this.__AudioContext.createBuffer(numOfChannels, length, sampleRate);
-  }
-
-  close(): void {
-    this.__AudioContext.close();
-  }
-}
-
-export type {
-  GainNode,
-  StereoPannerNode,
-  OscillatorNode,
-  BiquadFilterNode,
-  AudioBufferSourceNode,
-  AudioBuffer,
-  WaveType,
-};
+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';