react-native-audio-api 0.4.12 → 0.5.0-rc.1

package/src/web-core/AnalyserNode.tsx

@@ -29,41 +29,19 @@ export default class AnalyserNode extends AudioNode {
     );
   }
 
-  public getByteFrequencyData(array: number[]): void {
-    const data = new Uint8Array(array);
-
-    (this.node as globalThis.AnalyserNode).getByteFrequencyData(data);
-
-    for (let i = 0; i < array.length; i++) {
-      array[i] = data[i];
-    }
+  public getByteFrequencyData(array: Uint8Array): void {
+    (this.node as globalThis.AnalyserNode).getByteFrequencyData(array);
   }
 
-  public getByteTimeDomainData(array: number[]): void {
-    const data = new Uint8Array(array);
-
-    (this.node as globalThis.AnalyserNode).getByteTimeDomainData(data);
-
-    for (let i = 0; i < array.length; i++) {
-      array[i] = data[i];
-    }
+  public getByteTimeDomainData(array: Uint8Array): void {
+    (this.node as globalThis.AnalyserNode).getByteTimeDomainData(array);
   }
 
-  public getFloatFrequencyData(array: number[]): void {
-    const data = new Float32Array(array);
-    (this.node as globalThis.AnalyserNode).getFloatFrequencyData(data);
-
-    for (let i = 0; i < array.length; i++) {
-      array[i] = data[i];
-    }
+  public getFloatFrequencyData(array: Float32Array): void {
+    (this.node as globalThis.AnalyserNode).getFloatFrequencyData(array);
   }
 
-  public getFloatTimeDomainData(array: number[]): void {
-    const data = new Float32Array(array);
-    (this.node as globalThis.AnalyserNode).getFloatTimeDomainData(data);
-
-    for (let i = 0; i < array.length; i++) {
-      array[i] = data[i];
-    }
+  public getFloatTimeDomainData(array: Float32Array): void {
+    (this.node as globalThis.AnalyserNode).getFloatTimeDomainData(array);
   }
 }

package/src/web-core/AudioBuffer.tsx

@@ -28,7 +28,7 @@ export default class AudioBuffer {
   }
 
   public copyFromChannel(
-    destination: number[],
+    destination: Float32Array,
     channelNumber: number,
     startInChannel: number = 0
   ): void {
@@ -44,17 +44,11 @@ export default class AudioBuffer {
       );
     }
 
-    const array = new Float32Array(destination);
-
-    this.buffer.copyFromChannel(array, channelNumber, startInChannel);
-
-    for (let i = 0; i < destination.length; i++) {
-      destination[i] = array[i];
-    }
+    this.buffer.copyFromChannel(destination, channelNumber, startInChannel);
   }
 
   public copyToChannel(
-    source: number[],
+    source: Float32Array,
     channelNumber: number,
     startInChannel: number = 0
   ): void {
@@ -70,10 +64,6 @@ export default class AudioBuffer {
       );
     }
 
-    this.buffer.copyToChannel(
-      new Float32Array(source),
-      channelNumber,
-      startInChannel
-    );
+    this.buffer.copyToChannel(source, channelNumber, startInChannel);
   }
 }

package/src/web-core/AudioBufferSourceNode.tsx

@@ -1,26 +1,274 @@
-import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import { InvalidStateError, RangeError } from '../errors';
+
 import AudioParam from './AudioParam';
 import AudioBuffer from './AudioBuffer';
-import { InvalidStateError, RangeError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
-import { TimeStretchType } from '../types';
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
 
-export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
-  readonly playbackRate: AudioParam;
-  readonly detune: AudioParam;
+import { clamp } from '../utils';
+import { globalTag } from './custom/LoadCustomWasm';
+
+interface ScheduleOptions {
+  rate?: number;
+  active?: boolean;
+  output?: number;
+  input?: number;
+  semitones?: number;
+  loopStart?: number;
+  loopEnd?: number;
+}
+
+interface IStretcherNode extends globalThis.AudioNode {
+  channelCount: number;
+  channelCountMode: globalThis.ChannelCountMode;
+  channelInterpretation: globalThis.ChannelInterpretation;
+  context: globalThis.BaseAudioContext;
+  numberOfInputs: number;
+  numberOfOutputs: number;
+
+  onended:
+    | ((this: globalThis.AudioScheduledSourceNode, ev: Event) => unknown)
+    | null;
+  addEventListener: (
+    type: string,
+    listener: EventListenerOrEventListenerObject | null,
+    options?: boolean | AddEventListenerOptions | undefined
+  ) => void;
+  dispatchEvent: (event: Event) => boolean;
+  removeEventListener: (
+    type: string,
+    callback: EventListenerOrEventListenerObject | null,
+    options?: boolean | EventListenerOptions | undefined
+  ) => void;
+
+  addBuffers(channels: Float32Array[]): void;
+  dropBuffers(): void;
+
+  schedule(options: ScheduleOptions): void;
+
+  start(
+    when?: number,
+    offset?: number,
+    duration?: number,
+    rate?: number,
+    semitones?: number
+  ): void;
+
+  stop(when?: number): void;
+
+  connect(
+    destination: globalThis.AudioNode,
+    output?: number,
+    input?: number
+  ): globalThis.AudioNode;
+  connect(destination: globalThis.AudioParam, output?: number): void;
+
+  disconnect(): void;
+  disconnect(output: number): void;
+
+  disconnect(destination: globalThis.AudioNode): globalThis.AudioNode;
+  disconnect(destination: globalThis.AudioNode, output: number): void;
+  disconnect(
+    destination: globalThis.AudioNode,
+    output: number,
+    input: number
+  ): void;
+
+  disconnect(destination: globalThis.AudioParam): void;
+  disconnect(destination: globalThis.AudioParam, output: number): void;
+}
+
+class IStretcherNodeAudioParam implements globalThis.AudioParam {
+  private _value: number;
+  private _setter: (value: number, when?: number) => void;
+
+  public automationRate: AutomationRate;
+  public defaultValue: number;
+  public maxValue: number;
+  public minValue: number;
 
   constructor(
-    context: BaseAudioContext,
-    node: globalThis.AudioBufferSourceNode
+    value: number,
+    setter: (value: number, when?: number) => void,
+    automationRate: AutomationRate,
+    minValue: number,
+    maxValue: number,
+    defaultValue: number
   ) {
+    this._value = value;
+    this.automationRate = automationRate;
+    this.minValue = minValue;
+    this.maxValue = maxValue;
+    this.defaultValue = defaultValue;
+    this._setter = setter;
+  }
+
+  public get value(): number {
+    return this._value;
+  }
+
+  public set value(value: number) {
+    this._value = value;
+
+    this._setter(value);
+  }
+
+  cancelAndHoldAtTime(cancelTime: number): globalThis.AudioParam {
+    this._setter(this.defaultValue, cancelTime);
+    return this;
+  }
+
+  cancelScheduledValues(cancelTime: number): globalThis.AudioParam {
+    this._setter(this.defaultValue, cancelTime);
+    return this;
+  }
+
+  exponentialRampToValueAtTime(
+    _value: number,
+    _endTime: number
+  ): globalThis.AudioParam {
+    console.warn(
+      'exponentialRampToValueAtTime is not implemented for pitch correction mode'
+    );
+    return this;
+  }
+
+  linearRampToValueAtTime(
+    _value: number,
+    _endTime: number
+  ): globalThis.AudioParam {
+    console.warn(
+      'linearRampToValueAtTime is not implemented for pitch correction mode'
+    );
+    return this;
+  }
+
+  setTargetAtTime(
+    _target: number,
+    _startTime: number,
+    _timeConstant: number
+  ): globalThis.AudioParam {
+    console.warn(
+      'setTargetAtTime is not implemented for pitch correction mode'
+    );
+    return this;
+  }
+
+  setValueAtTime(value: number, startTime: number): globalThis.AudioParam {
+    this._setter(value, startTime);
+    return this;
+  }
+
+  setValueCurveAtTime(
+    _values: Float32Array,
+    _startTime: number,
+    _duration: number
+  ): globalThis.AudioParam {
+    console.warn(
+      'setValueCurveAtTime is not implemented for pitch correction mode'
+    );
+    return this;
+  }
+}
+
+type DefaultSource = globalThis.AudioBufferSourceNode;
+
+type IAudioBufferSourceNode = DefaultSource | IStretcherNode;
+
+declare global {
+  interface Window {
+    [globalTag]: (
+      audioContext: globalThis.BaseAudioContext
+    ) => Promise<IStretcherNode>;
+  }
+}
+
+export default class AudioBufferSourceNode<
+  T extends IAudioBufferSourceNode = DefaultSource,
+> extends AudioScheduledSourceNode {
+  private _pitchCorrection: boolean;
+  readonly playbackRate: AudioParam;
+  readonly detune: AudioParam;
+
+  private _loop: boolean = false;
+  private _loopStart: number = -1;
+  private _loopEnd: number = -1;
+
+  private _buffer: AudioBuffer | null = null;
+
+  constructor(context: BaseAudioContext, node: T, pitchCorrection: boolean) {
     super(context, node);
 
-    this.detune = new AudioParam(node.detune);
-    this.playbackRate = new AudioParam(node.playbackRate);
+    this._pitchCorrection = pitchCorrection;
+
+    if (pitchCorrection) {
+      this.detune = new AudioParam(
+        new IStretcherNodeAudioParam(
+          0,
+          this.setDetune.bind(this),
+          'a-rate',
+          -1200,
+          1200,
+          0
+        )
+      );
+
+      this.playbackRate = new AudioParam(
+        new IStretcherNodeAudioParam(
+          1,
+          this.setPlaybackRate.bind(this),
+          'a-rate',
+          0,
+          Infinity,
+          1
+        )
+      );
+    } else {
+      this.detune = new AudioParam((node as DefaultSource).detune);
+      this.playbackRate = new AudioParam((node as DefaultSource).playbackRate);
+    }
+  }
+
+  private isStretcherNode() {
+    return this._pitchCorrection;
+  }
+
+  private asStretcher(): IStretcherNode {
+    return this.node as IStretcherNode;
+  }
+
+  private asBufferSource(): DefaultSource {
+    return this.node as DefaultSource;
+  }
+
+  public setDetune(value: number, when: number = 0): void {
+    if (!this.isStretcherNode() || !this.hasBeenStarted) {
+      return;
+    }
+
+    this.asStretcher().schedule({
+      semitones: Math.floor(clamp(value / 100, -12, 12)),
+      output: when,
+    });
+  }
+
+  public setPlaybackRate(value: number, when: number = 0): void {
+    if (!this.isStretcherNode() || !this.hasBeenStarted) {
+      return;
+    }
+
+    this.asStretcher().schedule({
+      rate: value,
+      output: when,
+    });
   }
 
   public get buffer(): AudioBuffer | null {
-    const buffer = (this.node as globalThis.AudioBufferSourceNode).buffer;
+    if (this.isStretcherNode()) {
+      return this._buffer;
+    }
+
+    const buffer = this.asBufferSource().buffer;
 
     if (!buffer) {
       return null;
@@ -30,46 +278,83 @@ export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
   }
 
   public set buffer(buffer: AudioBuffer | null) {
+    if (this.isStretcherNode()) {
+      this._buffer = buffer;
+
+      const stretcher = this.asStretcher();
+      stretcher.dropBuffers();
+
+      if (!buffer) {
+        return;
+      }
+
+      const channelArrays: Float32Array[] = [];
+
+      for (let i = 0; i < buffer.numberOfChannels; i++) {
+        channelArrays.push(buffer.getChannelData(i));
+      }
+
+      stretcher.addBuffers(channelArrays);
+      return;
+    }
+
     if (!buffer) {
-      (this.node as globalThis.AudioBufferSourceNode | null) = null;
+      this.asBufferSource().buffer = null;
       return;
     }
 
-    (this.node as globalThis.AudioBufferSourceNode).buffer = buffer.buffer;
+    this.asBufferSource().buffer = buffer.buffer;
   }
 
   public get loop(): boolean {
-    return (this.node as globalThis.AudioBufferSourceNode).loop;
+    if (this.isStretcherNode()) {
+      return this._loop;
+    }
+
+    return this.asBufferSource().loop;
   }
 
   public set loop(value: boolean) {
-    (this.node as globalThis.AudioBufferSourceNode).loop = value;
+    if (this.isStretcherNode()) {
+      this._loop = value;
+      return;
+    }
+
+    this.asBufferSource().loop = value;
   }
 
   public get loopStart(): number {
-    return (this.node as globalThis.AudioBufferSourceNode).loopStart;
+    if (this.isStretcherNode()) {
+      return this._loopStart;
+    }
+
+    return this.asBufferSource().loopStart;
   }
 
   public set loopStart(value: number) {
-    (this.node as globalThis.AudioBufferSourceNode).loopStart = value;
+    if (this.isStretcherNode()) {
+      this._loopStart = value;
+      return;
+    }
+
+    this.asBufferSource().loopStart = value;
   }
 
   public get loopEnd(): number {
-    return (this.node as globalThis.AudioBufferSourceNode).loopEnd;
-  }
+    if (this.isStretcherNode()) {
+      return this._loopEnd;
+    }
 
-  public set loopEnd(value: number) {
-    (this.node as globalThis.AudioBufferSourceNode).loopEnd = value;
+    return this.asBufferSource().loopEnd;
   }
 
-  public get timeStretch(): TimeStretchType {
-    return 'linear';
-  }
+  public set loopEnd(value: number) {
+    if (this.isStretcherNode()) {
+      this._loopEnd = value;
+      return;
+    }
 
-  public set timeStretch(value: TimeStretchType) {
-    console.log(
-      'React Native Audio API: setting timeStretch is not supported on web'
-    );
+    this.asBufferSource().loopEnd = value;
   }
 
   public start(when?: number, offset?: number, duration?: number): void {
@@ -96,10 +381,51 @@ export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
     }
 
     this.hasBeenStarted = true;
-    (this.node as globalThis.AudioBufferSourceNode).start(
-      when,
+
+    if (!this.isStretcherNode()) {
+      this.asBufferSource().start(when, offset, duration);
+      return;
+    }
+
+    const startAt =
+      !when || when < this.context.currentTime
+        ? this.context.currentTime
+        : when;
+
+    if (this.loop && this._loopStart !== -1 && this._loopEnd !== -1) {
+      this.asStretcher().schedule({
+        loopStart: this._loopStart,
+        loopEnd: this._loopEnd,
+      });
+    }
+
+    this.asStretcher().start(
+      startAt,
       offset,
-      duration
+      duration,
+      this.playbackRate.value,
+      Math.floor(clamp(this.detune.value / 100, -12, 12))
     );
   }
+
+  public stop(when: number = 0): void {
+    if (when < 0) {
+      throw new RangeError(
+        `when must be a finite non-negative number: ${when}`
+      );
+    }
+
+    if (!this.hasBeenStarted) {
+      throw new InvalidStateError(
+        'Cannot call stop without calling start first'
+      );
+    }
+
+    if (!this.isStretcherNode()) {
+      this.asBufferSource().stop(when);
+      return;
+    }
+
+    this.asStretcher().stop(when);
+  }
 }

package/src/web-core/AudioContext.tsx

@@ -2,6 +2,7 @@ import {
   ContextState,
   PeriodicWaveConstraints,
   AudioContextOptions,
+  AudioBufferSourceNodeOptions,
 } from '../types';
 import { InvalidAccessError, NotSupportedError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
@@ -14,7 +15,6 @@ import GainNode from './GainNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
-import StretcherNode from './StretcherNode';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 
@@ -61,8 +61,22 @@ export default class AudioContext implements BaseAudioContext {
     return new BiquadFilterNode(this, this.context.createBiquadFilter());
   }
 
-  createBufferSource(): AudioBufferSourceNode {
-    return new AudioBufferSourceNode(this, this.context.createBufferSource());
+  async createBufferSource(
+    options?: AudioBufferSourceNodeOptions
+  ): Promise<AudioBufferSourceNode> {
+    if (!options || !options.pitchCorrection) {
+      return new AudioBufferSourceNode(
+        this,
+        this.context.createBufferSource(),
+        false
+      );
+    }
+
+    await globalWasmPromise;
+
+    const wasmStretch = await window[globalTag](this.context);
+
+    return new AudioBufferSourceNode(this, wasmStretch, true);
   }
 
   createBuffer(
@@ -94,8 +108,8 @@ export default class AudioContext implements BaseAudioContext {
   }
 
   createPeriodicWave(
-    real: number[],
-    imag: number[],
+    real: Float32Array,
+    imag: Float32Array,
     constraints?: PeriodicWaveConstraints
   ): PeriodicWave {
     if (real.length !== imag.length) {
@@ -113,14 +127,6 @@ export default class AudioContext implements BaseAudioContext {
     return new AnalyserNode(this, this.context.createAnalyser());
   }
 
-  async createStretcher(): Promise<StretcherNode> {
-    await globalWasmPromise;
-
-    const wasmStretch = await window[globalTag](this.context);
-
-    return new StretcherNode(this, wasmStretch);
-  }
-
   async decodeAudioDataSource(source: string): Promise<AudioBuffer> {
     const arrayBuffer = await fetch(source).then((response) =>
       response.arrayBuffer()

package/src/web-core/AudioParam.tsx

@@ -84,7 +84,7 @@ export default class AudioParam {
   }
 
   public setValueCurveAtTime(
-    values: number[],
+    values: Float32Array,
     startTime: number,
     duration: number
   ): AudioParam {
@@ -104,11 +104,7 @@ export default class AudioParam {
       throw new InvalidStateError(`values must contain at least two values`);
     }
 
-    this.param.setValueCurveAtTime(
-      new Float32Array(values),
-      startTime,
-      duration
-    );
+    this.param.setValueCurveAtTime(values, startTime, duration);
 
     return this;
   }

package/src/web-core/BaseAudioContext.tsx

@@ -21,15 +21,15 @@ export default interface BaseAudioContext {
   createGain(): GainNode;
   createStereoPanner(): StereoPannerNode;
   createBiquadFilter(): BiquadFilterNode;
-  createBufferSource(): AudioBufferSourceNode;
+  createBufferSource(): Promise<AudioBufferSourceNode>;
   createBuffer(
     numOfChannels: number,
     length: number,
     sampleRate: number
   ): AudioBuffer;
   createPeriodicWave(
-    real: number[],
-    imag: number[],
+    real: Float32Array,
+    imag: Float32Array,
     constraints?: PeriodicWaveConstraints
   ): PeriodicWave;
   createAnalyser(): AnalyserNode;

package/src/web-core/BiquadFilterNode.tsx

@@ -30,9 +30,9 @@ export default class BiquadFilterNode extends AudioNode {
   }
 
   public getFrequencyResponse(
-    frequencyArray: number[],
-    magResponseOutput: number[],
-    phaseResponseOutput: number[]
+    frequencyArray: Float32Array,
+    magResponseOutput: Float32Array,
+    phaseResponseOutput: Float32Array
   ) {
     if (
       frequencyArray.length !== magResponseOutput.length ||
@@ -42,21 +42,11 @@ export default class BiquadFilterNode extends AudioNode {
         `The lengths of the arrays are not the same frequencyArray: ${frequencyArray.length}, magResponseOutput: ${magResponseOutput.length}, phaseResponseOutput: ${phaseResponseOutput.length}`
       );
     }
-    const magData = new Float32Array(magResponseOutput);
-    const phaseData = new Float32Array(phaseResponseOutput);
 
     (this.node as globalThis.BiquadFilterNode).getFrequencyResponse(
-      new Float32Array(frequencyArray),
-      magData,
-      phaseData
+      frequencyArray,
+      magResponseOutput,
+      phaseResponseOutput
     );
-
-    for (let i = 0; i < magData.length; i++) {
-      magResponseOutput[i] = magData[i];
-    }
-
-    for (let i = 0; i < phaseData.length; i++) {
-      phaseResponseOutput[i] = phaseData[i];
-    }
   }
 }

package/src/web-core/custom/signalsmithStretch/README.md

@@ -14,7 +14,7 @@ The current input time, within the sample buffer. You can change how often this
 
 ### `stretch.schedule({...})`
 
-This adds a scheduled change, removing any scheduled changes occuring after this one. The object properties are:
+This adds a scheduled change, removing any scheduled changes occurring after this one. The object properties are:
 
 - `output` (seconds): audio context time for this change. The node compensates for its own latency, but this means you might want to schedule some things ahead of time, otherwise you'll have a softer transition as it catches up.
 - `active` (bool): processing audio