react-native-audio-api 0.3.2 → 0.4.0

package/src/core/AnalyserNode.ts

@@ -0,0 +1,85 @@
+import { IndexSizeError } from '../errors';
+import { IAnalyserNode } from '../interfaces';
+import AudioNode from './AudioNode';
+
+export default class AnalyserNode extends AudioNode {
+  private static allowedFFTSize: number[] = [
+    32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768,
+  ];
+
+  public get fftSize(): number {
+    return (this.node as IAnalyserNode).fftSize;
+  }
+
+  public set fftSize(value: number) {
+    if (!AnalyserNode.allowedFFTSize.includes(value)) {
+      throw new IndexSizeError(
+        `Provided value (${value}) must be a power of 2 between 32 and 32768`
+      );
+    }
+
+    (this.node as IAnalyserNode).fftSize = value;
+  }
+
+  public get minDecibels(): number {
+    return (this.node as IAnalyserNode).minDecibels;
+  }
+
+  public set minDecibels(value: number) {
+    if (value >= this.maxDecibels) {
+      throw new IndexSizeError(
+        `The minDecibels value (${value}) must be less than maxDecibels`
+      );
+    }
+
+    (this.node as IAnalyserNode).minDecibels = value;
+  }
+
+  public get maxDecibels(): number {
+    return (this.node as IAnalyserNode).maxDecibels;
+  }
+
+  public set maxDecibels(value: number) {
+    if (value <= this.minDecibels) {
+      throw new IndexSizeError(
+        `The maxDecibels value (${value}) must be greater than minDecibels`
+      );
+    }
+
+    (this.node as IAnalyserNode).maxDecibels = value;
+  }
+
+  public get smoothingTimeConstant(): number {
+    return (this.node as IAnalyserNode).smoothingTimeConstant;
+  }
+
+  public set smoothingTimeConstant(value: number) {
+    if (value < 0 || value > 1) {
+      throw new IndexSizeError(
+        `The smoothingTimeConstant value (${value}) must be between 0 and 1`
+      );
+    }
+
+    (this.node as IAnalyserNode).smoothingTimeConstant = value;
+  }
+
+  public get frequencyBinCount(): number {
+    return (this.node as IAnalyserNode).frequencyBinCount;
+  }
+
+  public getFloatFrequencyData(array: number[]): void {
+    (this.node as IAnalyserNode).getFloatFrequencyData(array);
+  }
+
+  public getByteFrequencyData(array: number[]): void {
+    (this.node as IAnalyserNode).getByteFrequencyData(array);
+  }
+
+  public getFloatTimeDomainData(array: number[]): void {
+    (this.node as IAnalyserNode).getFloatTimeDomainData(array);
+  }
+
+  public getByteTimeDomainData(array: number[]): void {
+    (this.node as IAnalyserNode).getByteTimeDomainData(array);
+  }
+}

package/src/core/BaseAudioContext.ts

@@ -8,6 +8,7 @@ import BiquadFilterNode from './BiquadFilterNode';
 import AudioBufferSourceNode from './AudioBufferSourceNode';
 import AudioBuffer from './AudioBuffer';
 import PeriodicWave from './PeriodicWave';
+import AnalyserNode from './AnalyserNode';
 import { InvalidAccessError } from '../errors';
 
 export default class BaseAudioContext {
@@ -95,7 +96,16 @@ export default class BaseAudioContext {
     );
   }
 
+  createAnalyser(): AnalyserNode {
+    return new AnalyserNode(this, this.context.createAnalyser());
+  }
+
   async decodeAudioDataSource(sourcePath: string): Promise<AudioBuffer> {
+    // Remove the file:// prefix if it exists
+    if (sourcePath.startsWith('file://')) {
+      sourcePath = sourcePath.replace('file://', '');
+    }
+
     const buffer = await this.context.decodeAudioDataSource(sourcePath);
 
     return new AudioBuffer(buffer);

package/src/index.native.ts

@@ -9,6 +9,7 @@ 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';

package/src/index.ts

@@ -110,6 +110,48 @@ export class AudioNode {
   }
 }
 
+export class AnalyserNode extends AudioNode {
+  fftSize: number;
+  readonly frequencyBinCount: number;
+  minDecibels: number;
+  maxDecibels: number;
+  smoothingTimeConstant: number;
+
+  constructor(context: AudioContext, node: globalThis.AnalyserNode) {
+    super(context, node);
+
+    this.fftSize = node.fftSize;
+    this.frequencyBinCount = node.frequencyBinCount;
+    this.minDecibels = node.minDecibels;
+    this.maxDecibels = node.maxDecibels;
+    this.smoothingTimeConstant = node.smoothingTimeConstant;
+  }
+
+  public getByteFrequencyData(array: number[]): void {
+    (this.node as globalThis.AnalyserNode).getByteFrequencyData(
+      new Uint8Array(array)
+    );
+  }
+
+  public getByteTimeDomainData(array: number[]): void {
+    (this.node as globalThis.AnalyserNode).getByteTimeDomainData(
+      new Uint8Array(array)
+    );
+  }
+
+  public getFloatFrequencyData(array: number[]): void {
+    (this.node as globalThis.AnalyserNode).getFloatFrequencyData(
+      new Float32Array(array)
+    );
+  }
+
+  public getFloatTimeDomainData(array: number[]): void {
+    (this.node as globalThis.AnalyserNode).getFloatTimeDomainData(
+      new Float32Array(array)
+    );
+  }
+}
+
 export class AudioScheduledSourceNode extends AudioNode {
   private hasBeenStarted: boolean = false;
 
@@ -428,6 +470,10 @@ export class AudioContext {
     );
   }
 
+  createAnalyser(): AnalyserNode {
+    return new AnalyserNode(this, this.context.createAnalyser());
+  }
+
   async decodeAudioDataSource(source: string): Promise<AudioBuffer> {
     const arrayBuffer = await fetch(source).then((response) =>
       response.arrayBuffer()

package/src/interfaces.ts

@@ -27,6 +27,7 @@ export interface IBaseAudioContext {
     imag: number[],
     disableNormalization: boolean
   ) => IPeriodicWave;
+  createAnalyser: () => IAnalyserNode;
   decodeAudioDataSource: (sourcePath: string) => Promise<IAudioBuffer>;
 }
 
@@ -136,3 +137,16 @@ export interface IAudioParam {
 }
 
 export interface IPeriodicWave {}
+
+export interface IAnalyserNode extends IAudioNode {
+  fftSize: number;
+  readonly frequencyBinCount: number;
+  minDecibels: number;
+  maxDecibels: number;
+  smoothingTimeConstant: number;
+
+  getFloatFrequencyData: (array: number[]) => void;
+  getByteFrequencyData: (array: number[]) => void;
+  getFloatTimeDomainData: (array: number[]) => void;
+  getByteTimeDomainData: (array: number[]) => void;
+}