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

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/SignalsmithStretch.mjs

@@ -510,8 +510,7 @@ function registerWorkletProcessor(Module, audioNodeKey) {
           return result;
         },
         schedule: (objIn, adjustPrevious) => {
-          let outputTime =
-            'outputTime' in objIn ? objIn.outputTime : currentTime;
+          let outputTime = 'output' in objIn ? objIn.output : currentTime;
 
           let latestSegment = this.timeMap[this.timeMap.length - 1];
           while (
@@ -524,13 +523,15 @@ function registerWorkletProcessor(Module, audioNodeKey) {
           let obj = {
             active: latestSegment.active,
             input: null,
-            output: outputTime,
             rate: latestSegment.rate,
             semitones: latestSegment.semitones,
             loopStart: latestSegment.loopStart,
             loopEnd: latestSegment.loopEnd,
           };
+
           Object.assign(obj, objIn);
+          obj.output = outputTime;
+
           if (obj.input === null) {
             let rate = latestSegment.active ? latestSegment.rate : 0;
             obj.input =

package/common/cpp/audioapi/core/types/TimeStretchType.h

@@ -1,7 +0,0 @@
-#pragma once
-
-namespace audioapi {
-
-enum class TimeStretchType { LINEAR, SPEECH_MUSIC };
-
-}

package/lib/module/web-core/StretcherNode.js

@@ -1,81 +0,0 @@
-"use strict";
-
-import AudioNode from "./AudioNode.js";
-import { globalTag } from "./custom/LoadCustomWasm.js";
-export default class StretcherNode extends AudioNode {
-  _buffer = null;
-  _playbackRate = 1;
-  _loopStart = -1;
-  _loopEnd = -1;
-  _loop = false;
-  _isPlaying = false;
-  constructor(context, node) {
-    super(context, node);
-    this._buffer = null;
-  }
-  get buffer() {
-    return this._buffer;
-  }
-  set buffer(buffer) {
-    this._buffer = buffer;
-    const channelArrays = [];
-    for (let i = 0; i < buffer.numberOfChannels; i += 1) {
-      channelArrays.push(buffer.getChannelData(i));
-    }
-    this.node.addBuffers(channelArrays);
-  }
-  get playbackRate() {
-    return this._playbackRate;
-  }
-  set playbackRate(value) {
-    this._playbackRate = value;
-    if (this._isPlaying) {
-      this.node.schedule({
-        rate: value
-      });
-    }
-  }
-  get loopStart() {
-    return this._loopStart;
-  }
-  set loopStart(value) {
-    this._loopStart = value;
-    if (this._isPlaying) {
-      this.node.schedule({
-        loopStart: value
-      });
-    }
-  }
-  get loopEnd() {
-    return this._loopEnd;
-  }
-  set loopEnd(value) {
-    this._loopEnd = value;
-    if (this._isPlaying) {
-      this.node.schedule({
-        loopEnd: value
-      });
-    }
-  }
-  get loop() {
-    return this._loop;
-  }
-  set loop(value) {
-    this._loop = value;
-  }
-  start(when, offset, duration, rate, semitones) {
-    this._isPlaying = true;
-    if (this.loop && this._loopStart !== -1 && this._loopEnd !== -1) {
-      this.node.schedule({
-        loopStart: this._loopStart,
-        loopEnd: this._loopEnd
-      });
-    }
-    this.node.start(when ?? 0, offset ?? 0, duration ?? this._buffer?.duration ?? 0, rate ?? this._playbackRate ?? 0, semitones ?? 0);
-  }
-  stop(when) {
-    this._isPlaying = false;
-    this.node.stop(when);
-  }
-}
-//# sourceMappingURL=StretcherNode.js.map