react-native-audio-api 0.4.12-beta.4 → 0.4.12

package/src/api.ts

@@ -0,0 +1,51 @@
+import NativeAudioAPIModule from './specs/NativeAudioAPIModule';
+import type { IAudioContext } from './interfaces';
+
+/* eslint-disable no-var */
+declare global {
+  var createAudioContext: (sampleRate?: number) => IAudioContext;
+}
+/* eslint-disable no-var */
+
+if (global.createAudioContext == null) {
+  if (!NativeAudioAPIModule) {
+    throw new Error(
+      `Failed to install react-native-audio-api: The native module could not be found.`
+    );
+  }
+
+  NativeAudioAPIModule.install();
+}
+
+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 AnalyserNode } from './core/AnalyserNode';
+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,
+  WindowType,
+  PeriodicWaveConstraints,
+  TimeStretchType,
+} from './types';
+
+export {
+  IndexSizeError,
+  InvalidAccessError,
+  InvalidStateError,
+  RangeError,
+  NotSupportedError,
+} from './errors';

package/src/{index.web.ts → api.web.ts}

@@ -11,6 +11,9 @@ export { default as BiquadFilterNode } from './web-core/BiquadFilterNode';
 export { default as GainNode } from './web-core/GainNode';
 export { default as OscillatorNode } from './web-core/OscillatorNode';
 export { default as StereoPannerNode } from './web-core/StereoPannerNode';
+export { default as StretcherNode } from './web-core/StretcherNode';
+
+export * from './web-core/custom';
 
 export {
   OscillatorType,
@@ -20,6 +23,7 @@ export {
   ContextState,
   WindowType,
   PeriodicWaveConstraints,
+  TimeStretchType,
 } from './types';
 
 export {

package/src/core/AudioBufferSourceNode.ts

@@ -4,6 +4,7 @@ import BaseAudioContext from './BaseAudioContext';
 import AudioBuffer from './AudioBuffer';
 import AudioParam from './AudioParam';
 import { InvalidStateError, RangeError } from '../errors';
+import { TimeStretchType } from '../types';
 
 export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
   readonly playbackRate: AudioParam;
@@ -57,6 +58,14 @@ export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
     (this.node as IAudioBufferSourceNode).loopEnd = value;
   }
 
+  public get timeStretch(): TimeStretchType {
+    return (this.node as IAudioBufferSourceNode).timeStretch;
+  }
+
+  public set timeStretch(value: TimeStretchType) {
+    (this.node as IAudioBufferSourceNode).timeStretch = value;
+  }
+
   public start(when: number = 0, offset: number = 0, duration?: number): void {
     if (when < 0) {
       throw new RangeError(

package/src/core/AudioScheduledSourceNode.ts

@@ -35,4 +35,9 @@ export default class AudioScheduledSourceNode extends AudioNode {
 
     (this.node as IAudioScheduledSourceNode).stop(when);
   }
+
+  // eslint-disable-next-line accessor-pairs
+  public set onended(callback: (arg?: number) => void) {
+    (this.node as IAudioScheduledSourceNode).onended = callback;
+  }
 }

package/src/core/BaseAudioContext.ts

@@ -9,7 +9,6 @@ import AudioBufferSourceNode from './AudioBufferSourceNode';
 import AudioBuffer from './AudioBuffer';
 import PeriodicWave from './PeriodicWave';
 import AnalyserNode from './AnalyserNode';
-import StretcherNode from './StretcherNode';
 import { InvalidAccessError, NotSupportedError } from '../errors';
 
 export default class BaseAudioContext {
@@ -101,10 +100,6 @@ export default class BaseAudioContext {
     return new AnalyserNode(this, this.context.createAnalyser());
   }
 
-  createStretcher(): StretcherNode {
-    return new StretcherNode(this, this.context.createStretcher());
-  }
-
   async decodeAudioDataSource(sourcePath: string): Promise<AudioBuffer> {
     // Remove the file:// prefix if it exists
     if (sourcePath.startsWith('file://')) {

package/src/index.ts

@@ -1,51 +1 @@
-import NativeAudioAPIModule from './specs/NativeAudioAPIModule';
-import type { IAudioContext } from './interfaces';
-
-/* eslint-disable no-var */
-declare global {
-  var createAudioContext: (sampleRate?: number) => IAudioContext;
-}
-/* eslint-disable no-var */
-
-if (global.createAudioContext == null) {
-  if (!NativeAudioAPIModule) {
-    throw new Error(
-      `Failed to install react-native-audio-api: The native module could not be found.`
-    );
-  }
-
-  NativeAudioAPIModule.install();
-}
-
-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 AnalyserNode } from './core/AnalyserNode';
-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 { default as StretcherNode } from './core/StretcherNode';
-
-export {
-  OscillatorType,
-  BiquadFilterType,
-  ChannelCountMode,
-  ChannelInterpretation,
-  ContextState,
-  WindowType,
-  PeriodicWaveConstraints,
-} from './types';
-
-export {
-  IndexSizeError,
-  InvalidAccessError,
-  InvalidStateError,
-  RangeError,
-  NotSupportedError,
-} from './errors';
+export * from './api';

package/src/interfaces.ts

@@ -5,6 +5,7 @@ import {
   ChannelCountMode,
   ChannelInterpretation,
   WindowType,
+  TimeStretchType,
 } from './types';
 
 export interface AudioAPIInstaller {
@@ -33,7 +34,6 @@ export interface IBaseAudioContext {
     disableNormalization: boolean
   ) => IPeriodicWave;
   createAnalyser: () => IAnalyserNode;
-  createStretcher: () => IStretcherNode;
   decodeAudioDataSource: (sourcePath: string) => Promise<IAudioBuffer>;
 }
 
@@ -82,6 +82,7 @@ export interface IAudioDestinationNode extends IAudioNode {}
 export interface IAudioScheduledSourceNode extends IAudioNode {
   start(when?: number): void;
   stop: (when: number) => void;
+  onended: (arg?: number) => void | null;
 }
 
 export interface IOscillatorNode extends IAudioScheduledSourceNode {
@@ -99,6 +100,7 @@ export interface IAudioBufferSourceNode extends IAudioScheduledSourceNode {
   loopEnd: number;
   detune: IAudioParam;
   playbackRate: IAudioParam;
+  timeStretch: TimeStretchType;
 
   start: (when?: number, offset?: number, duration?: number) => void;
 }
@@ -160,8 +162,3 @@ export interface IAnalyserNode extends IAudioNode {
   getFloatTimeDomainData: (array: number[]) => void;
   getByteTimeDomainData: (array: number[]) => void;
 }
-
-export interface IStretcherNode extends IAudioNode {
-  readonly rate: IAudioParam;
-  readonly semitones: IAudioParam;
-}

package/src/types.ts

@@ -30,3 +30,5 @@ export interface AudioContextOptions {
 }
 
 export type WindowType = 'blackman' | 'hann';
+
+export type TimeStretchType = 'linear' | 'speech-music';

package/src/web-core/AudioBuffer.tsx

@@ -17,14 +17,14 @@ export default class AudioBuffer {
     this.numberOfChannels = buffer.numberOfChannels;
   }
 
-  public getChannelData(channel: number): number[] {
+  public getChannelData(channel: number): Float32Array {
     if (channel < 0 || channel >= this.numberOfChannels) {
       throw new IndexSizeError(
         `The channel number provided (${channel}) is outside the range [0, ${this.numberOfChannels - 1}]`
       );
     }
 
-    return Array.from(this.buffer.getChannelData(channel));
+    return this.buffer.getChannelData(channel);
   }
 
   public copyFromChannel(

package/src/web-core/AudioBufferSourceNode.tsx

@@ -3,6 +3,7 @@ import AudioParam from './AudioParam';
 import AudioBuffer from './AudioBuffer';
 import { InvalidStateError, RangeError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
+import { TimeStretchType } from '../types';
 
 export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
   readonly playbackRate: AudioParam;
@@ -61,6 +62,16 @@ export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
     (this.node as globalThis.AudioBufferSourceNode).loopEnd = value;
   }
 
+  public get timeStretch(): TimeStretchType {
+    return 'linear';
+  }
+
+  public set timeStretch(value: TimeStretchType) {
+    console.log(
+      'React Native Audio API: setting timeStretch is not supported on web'
+    );
+  }
+
   public start(when?: number, offset?: number, duration?: number): void {
     if (when && when < 0) {
       throw new RangeError(

package/src/web-core/AudioContext.tsx

@@ -14,6 +14,9 @@ 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';
 
 export default class AudioContext implements BaseAudioContext {
   readonly context: globalThis.AudioContext;
@@ -110,6 +113,14 @@ 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/AudioScheduledSourceNode.tsx

@@ -34,4 +34,13 @@ export default class AudioScheduledSourceNode extends AudioNode {
 
     (this.node as globalThis.AudioScheduledSourceNode).stop(when);
   }
+
+  // eslint-disable-next-line accessor-pairs
+  public set onended(callback: (arg?: number) => void) {
+    const eventCallback = (_event: Event) => {
+      callback();
+    };
+
+    (this.node as globalThis.AudioScheduledSourceNode).onended = eventCallback;
+  }
 }

package/src/web-core/StretcherNode.tsx

@@ -0,0 +1,125 @@
+import BaseAudioContext from './BaseAudioContext';
+import AudioBuffer from './AudioBuffer';
+import AudioNode from './AudioNode';
+
+import { globalTag } from './custom/LoadCustomWasm';
+
+interface ScheduleOptions {
+  rate?: number;
+  active?: boolean;
+  outputTime?: number;
+  semitones?: number;
+  loopStart?: number;
+  loopEnd?: number;
+}
+
+declare class IStretcherNode {
+  addBuffers(channels: Float32Array[]): 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): void;
+  disconnect(destination: globalThis.AudioNode): void;
+}
+
+declare global {
+  interface Window {
+    [globalTag]: (
+      audioContext: globalThis.BaseAudioContext
+    ) => Promise<IStretcherNode>;
+  }
+}
+
+export default class StretcherNode extends AudioNode {
+  _buffer: AudioBuffer | null = null;
+
+  _playbackRate: number = 1;
+  _loopStart: number = -1;
+  _loopEnd: number = -1;
+  _isPlaying = false;
+
+  constructor(context: BaseAudioContext, node: IStretcherNode) {
+    super(context, node as unknown as globalThis.AudioNode);
+    this._buffer = null;
+  }
+
+  public get buffer(): AudioBuffer | null {
+    return this._buffer;
+  }
+
+  public set buffer(buffer: AudioBuffer) {
+    this._buffer = buffer;
+    const channelArrays = [];
+
+    for (let i = 0; i < buffer.numberOfChannels; i += 1) {
+      channelArrays.push(buffer.getChannelData(i));
+    }
+
+    (this.node as unknown as IStretcherNode).addBuffers(channelArrays);
+  }
+
+  public get playbackRate(): number {
+    return this._playbackRate;
+  }
+
+  public set playbackRate(value: number) {
+    this._playbackRate = value;
+
+    if (this._isPlaying) {
+      (this.node as unknown as IStretcherNode).schedule({ rate: value });
+    }
+  }
+
+  public get loopStart(): number {
+    return this._loopStart;
+  }
+
+  public set loopStart(value: number) {
+    this._loopStart = value;
+
+    (this.node as unknown as IStretcherNode).schedule({ loopStart: value });
+  }
+
+  public get loopEnd(): number {
+    return this._loopEnd;
+  }
+
+  public set loopEnd(value: number) {
+    this._loopEnd = value;
+
+    (this.node as unknown as IStretcherNode).schedule({ loopEnd: value });
+  }
+
+  public start(
+    when?: number,
+    offset?: number,
+    duration?: number,
+    rate?: number,
+    semitones?: number
+  ): void {
+    this._isPlaying = true;
+
+    (this.node as unknown as IStretcherNode).start(
+      when,
+      offset,
+      duration,
+      rate,
+      semitones
+    );
+  }
+
+  public stop(when?: number): void {
+    this._isPlaying = false;
+    (this.node as unknown as IStretcherNode).stop(when);
+  }
+}

package/src/web-core/custom/LoadCustomWasm.ts

@@ -0,0 +1,39 @@
+export const globalTag = '__rnaaCstStretch';
+const eventTitle = 'rnaaCstStretchLoaded';
+
+export let globalWasmPromise: Promise<void> | null = null;
+
+const LoadCustomWasm = async () => {
+  if (typeof window === 'undefined') {
+    return null;
+  }
+
+  if (globalWasmPromise) {
+    return globalWasmPromise;
+  }
+
+  globalWasmPromise = new Promise<void>((resolve) => {
+    const loadScript = document.createElement('script');
+    document.head.appendChild(loadScript);
+    loadScript.type = 'module';
+
+    loadScript.textContent = `
+      import SignalsmithStretch from '/signalsmithStretch.mjs';
+      window.${globalTag} = SignalsmithStretch;
+      window.postMessage('${eventTitle}');
+    `;
+
+    function onScriptLoaded(event: MessageEvent<string>) {
+      if (event.data !== eventTitle) {
+        return;
+      }
+
+      resolve();
+      window.removeEventListener('message', onScriptLoaded);
+    }
+
+    window.addEventListener('message', onScriptLoaded);
+  });
+};
+
+export default LoadCustomWasm;

package/src/web-core/custom/index.ts

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

package/src/web-core/custom/signalsmithStretch/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Geraint Luff / Signalsmith Audio Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,46 @@
+# Signalsmith Stretch Web
+
+This is an official release of the Signalsmith Stretch library for Web Audio, using WASM/AudioWorklet. It includes both plain `.js` (UMD), and ES6 `.mjs` versions.
+
+## How to use it
+
+Call `SignalsmithStretch(audioContext, ?channelOptions)` from the main thread. This returns a Promise which resolves to an `AudioNode`, with extra methods attached to it.
+
+It can operate either on live/streaming input, or on a sample buffer you load into it.
+
+### `stretch.inputTime`
+
+The current input time, within the sample buffer. You can change how often this is updated, with an optional callback function, using `stretch.setUpdateInterval(seconds, ?callback)`.
+
+### `stretch.schedule({...})`
+
+This adds a scheduled change, removing any scheduled changes occuring 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
+- `input` (seconds): position in input buffer
+- `rate` (number): playback rate, e.g. 0.5 == half speed
+- `semitones` (number): pitch shift
+- `loopStart` / `loopEnd`: sets a section of the input to auto-loop. Disabled if both are set to the same value.
+
+### `stretch.start(?when)` / `stretch.stop(?when)`
+
+Starts/stops playback or processing, immediately or at some future time. These are convenience methods which call `.schedule(...)` under the hood.
+
+`.start()` actually has more parameters, presenting a similar interface to [AudioBufferSourceNode](https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode/start).
+
+### `stretch.addBuffers([...])`
+
+This adds buffers to the end of the current input. Buffers should be typed arrays of equal length, one per channel.
+
+It can be called multiple times, and the new buffers are inserted after the existing ones, which lets you start playback before the entire audio is loaded. It returns (as a Promise) the new end time for the stored input, in seconds.
+
+### `stretch.dropBuffers()`
+
+This drops all input buffers, and resets the input buffer start time to 0.
+
+### `stretch.dropBuffers(toSeconds)`
+
+This drops all input buffers before the given time. It returns (as a Promise) the an object with the current input buffer extent: `{start: ..., end: ...}`.
+
+This can be useful when processing streams or very long audio files, letting the Stretch node release old buffers once that section of the input will no longer be played back.