@fluex/fluexgl-dsp 0.4.1 → 0.4.3

package/lib/src/core/classes/AudioClipPlayer.ts

@@ -2,8 +2,9 @@ import { v4 } from "uuid";
 
 import { AudioClip } from "./AudioClip";
 import { Debug } from "../../utilities/debugger";
-import { Master } from "./Master";
 import { Channel } from "./Channel";
+import { Master } from "./Master";
+import { ErrorCodes } from "lib/src/console-codes";
 
 export class AudioClipPlayer {
 
@@ -14,32 +15,100 @@ export class AudioClipPlayer {
     public outputGainNode: GainNode | null = null;
 
     public context: AudioContext | null = null;
-    public channel: Channel | null = null;
+    public channel: Channel | Master | null = null;
 
     constructor(context: AudioContext) {
         this.context = context;
         this.outputGainNode = new GainNode(context);
     }
 
-    public AttachAudioClip(audioClip: AudioClip) {
+    public AttachAudioClip(audioClip: AudioClip): void {
 
         if (this.audioClips.includes(audioClip)) return Debug.Error("Could not attach audio clip because it is already part of this channel", [
             "Call .DetachAudioClip([clip AudioClip]) before attaching audio clip."
-        ]);
+        ], ErrorCodes.AUDIO_CLIP_ALREADY_ATTACHED);
 
         audioClip.Initialize(this);
         this.audioClips.push(audioClip);
     }
 
-    public Send(channel: Channel) {
+    public DetachAudioClip(clip: AudioClip): void {
+
+        if (!this.audioClips.includes(clip)) return Debug.Error("Could not detach audio clip because it is not part of this channel", [
+            "Call .AttachAudioClip([clip AudioClip]) before detaching audio clip."
+        ], ErrorCodes.AUDIO_CLIP_NOT_FOUND);
+
+        clip.Stop();
+
+        const self = this;
+
+        this.audioClips.forEach(function (_clip: AudioClip, index: number) {
+            if (clip.id === _clip.id)
+                return self.audioClips.splice(index, 1);
+        })
+    }
+
+    public Send(channel: Channel | Master): void {
 
-        if(!this.outputGainNode || !channel.input) return Debug.Error("Could not send AudioClipPlayer signal to a channel.");
+        if (!this.outputGainNode || !channel.input) return Debug.Error("Could not send AudioClipPlayer signal to a channel/master.");
+
+        this.Unsend();
 
         this.channel = channel;
         this.outputGainNode.connect(channel.input);
     }
 
-    public SetLabel(label: string) {
+    public Unsend(): void {
+
+        if (!this.outputGainNode) return;
+
+        if (this.channel && this.channel.input) {
+            this.outputGainNode.disconnect(this.channel.input);
+        } else {
+            this.outputGainNode.disconnect();
+        }
+
+        this.channel = null;
+    }
+
+    public SetVolume(value: number): void {
+
+        if (!this.outputGainNode) return;
+
+        if (value < 0) value = 0;
+        if (value > 1) value = 1;
+
+        this.outputGainNode.gain.value = value;
+    }
+
+    public StopAll(): void {
+
+        this.audioClips.forEach(function (clip: AudioClip) {
+            clip.Stop();
+        });
+    }
+
+    public Dispose(): void {
+
+        this.StopAll();
+        this.Unsend();
+        this.outputGainNode?.disconnect();
+        
+        this.audioClips = [];
+        this.outputGainNode = null;
+        this.channel = null;
+        this.context = null;
+    }
+
+    public SetLabel(label: string): void {
         this.label = label;
     }
-}
+
+    public get length(): number {
+        return this.audioClips.length;
+    }
+
+    public get volume(): number {
+        return this.outputGainNode?.gain.value ?? 0;
+    }
+}

package/lib/src/core/classes/AudioDevice.ts

@@ -1,6 +1,7 @@
 import { v4 } from "uuid";
 
 import { Master } from "./Master";
+import { Channel } from "./Channel";
 
 import { ErrorCodes } from "../../console-codes";
 import { Debug } from "../../utilities/debugger";
@@ -15,7 +16,7 @@ export class AudioDevice {
     public masterChannel: Master = new Master(this.context);
     public masterChannels: Master[] = [];
 
-    constructor(public deviceInfo: MediaDeviceInfo) { }
+    constructor(public deviceInfo: MediaDeviceInfo) {};
 
     public GetMasterChannel(): Master {
         return this.masterChannel;
@@ -42,4 +43,8 @@ export class AudioDevice {
     public GetContext(): AudioContext {
         return this.context;
     }
+
+    public CreateChannel(label?: string): Channel {
+        return new Channel(this.context, label);
+    }
 }

package/lib/src/core/classes/Channel.ts

@@ -3,6 +3,8 @@ import { Debug } from "../../utilities/debugger";
 import { AudioClipPlayer } from "./AudioClipPlayer";
 import { AudioClip } from "./AudioClip";
 import { Master } from "./Master";
+import { Effector } from "./Effector";
+import { ErrorCodes } from "../../console-codes";
 
 export class Channel {
 
@@ -15,13 +17,15 @@ export class Channel {
     public gainNode: GainNode | null = null;
     public output: AudioNode | null = null;
 
+    public effects: Effector[] = [];
     public context: AudioContext | null = null;
 
-    private sends: Channel[] = [];
-    private audioClipPlayer: AudioClipPlayer | null = null;
+    public sends: Channel[] = [];
+    public audioClipPlayer: AudioClipPlayer | null = null;
 
-    constructor(context: AudioContext) {
+    constructor(context: AudioContext, label?: string) {
         this.context = context;
+        this.label = label ?? this.label;
 
         this.disconnectAudioNodes(true);
 
@@ -41,6 +45,92 @@ export class Channel {
         this.audioClipPlayer.Send(this);
     }
 
+    private rebuildEffectChain(): void {
+
+        if (!this.input || !this.stereoPannerNode) {
+            Debug.Error("Could not rebuild effect chain because one or more required audio nodes are undefined.", [
+                `Channel id: ${this.id}.`,
+                `Input defined: ${!!this.input}.`,
+                `StereoPannerNode defined: ${!!this.stereoPannerNode}.`
+            ]);
+            return;
+        }
+
+        this.input.disconnect();
+
+        for (const effect of this.effects)
+            effect.audioWorkletNode?.disconnect();
+
+        const activeEffects = this.effects.filter(function (e: Effector): boolean {
+            return !!e.audioWorkletNode;
+        });
+
+        if (activeEffects.length === 0) {
+            this.input.connect(this.stereoPannerNode);
+            return;
+        }
+
+        this.input.connect(activeEffects[0].audioWorkletNode as AudioNode);
+
+        for (let i: number = 0; i < activeEffects.length - 1; i++) {
+            
+            const current = activeEffects[i].audioWorkletNode as AudioNode;
+            const next = activeEffects[i + 1].audioWorkletNode as AudioNode;
+
+            current.connect(next);
+        }
+
+        (activeEffects[activeEffects.length - 1].audioWorkletNode as AudioNode).connect(this.stereoPannerNode);
+    }
+
+    public AddEffect(effect: Effector): void {
+
+        if (!this.context) {
+            Debug.Error("Could not add effect because this channel has no AudioContext.");
+            return;
+        }
+
+        if (this.effects.includes(effect)) {
+            Debug.Error("Could not add effect because it is already part of this channel", [
+                "Call .RemoveEffect([effect Effector]) before adding effect."
+            ], ErrorCodes.EFFECT_ALREADY_ATTACHED);
+            return;
+        }
+
+        this.effects.push(effect);
+        effect.InitializeOnAttachment(this.context);
+        this.rebuildEffectChain();
+    }
+
+    public AttachEffect(effect: Effector): void {
+        return this.AddEffect(effect);
+    }
+
+    public RemoveEffect(effect: Effector): void {
+
+        if (!this.effects.includes(effect)) {
+            Debug.Error("Could not remove effect, because it is not part of this channel.", [
+                "Call .AddEffect([effect Effector]) before removing effect."
+            ], ErrorCodes.EFFECT_NOT_FOUND);
+            return;
+        }
+
+        const self: Channel = this;
+
+        this.effects.forEach(function (_effect: Effector, index: number): void {
+            if (effect.id === _effect.id)
+                self.effects.splice(index, 1);
+        });
+
+        effect.audioWorkletNode?.disconnect();
+
+        this.rebuildEffectChain();
+    }
+
+    public DetachEffect(effect: Effector): void {
+        return this.RemoveEffect(effect);
+    }
+
     private disconnectAudioNodes(gc?: boolean) {
 
         this.input?.disconnect();
@@ -49,6 +139,10 @@ export class Channel {
         this.gainNode?.disconnect();
         this.output?.disconnect();
 
+        for (const effect of this.effects) {
+            effect.audioWorkletNode?.disconnect();
+        }
+
         if (gc) {
             this.input = null;
             this.stereoPannerNode = null;
@@ -88,31 +182,32 @@ export class Channel {
 
     public Send(channel: Channel | Master) {
 
-        if (channel instanceof Master) return (channel as Master).AttachChannel(this);
+        if (channel instanceof Master)
+            return (channel as Master).AttachChannel(this);
 
         if (channel.id === this.id) return Debug.Error("Could not link channel to itself.", [
             `This channel id: ${this.id}`
-        ]);
+        ], ErrorCodes.CHANNEL_CANNOT_LINK_TO_ITSELF);
 
         if (!this.isInitialized() || !channel.isInitialized()) return Debug.Error("Could not link channels because one (or both) channels are not initialized.", [
             `This channel id: ${this.id} initialized: ${this.isInitialized()}`,
             `Target channel id: ${channel.id} initialized: ${channel.isInitialized()}`
-        ]);
+        ], ErrorCodes.CHANNEL_NOT_INITIALIZED);
 
         if (this.context !== channel.context) return Debug.Error("Could not link channels because they do not share the same AudioContext.", [
             `This channel context: ${this.context ? "set" : "null"}`,
             `Target channel context: ${channel.context ? "set" : "null"}`
-        ]);
+        ], ErrorCodes.CHANNEL_NOT_SAME_AUDIO_CONTEXT);
 
         if (this.sends.includes(channel)) return Debug.Error("Could not link channels, because the given channel is already linked with this one.", [
             `This channel id: ${this.id}`,
             `Target channel id: ${channel.id}`
-        ]);
+        ], ErrorCodes.CHANNEL_ALREADY_LINKED);
 
         if (channel.isReachable(this)) return Debug.Error("Could not link channels because it would create a feedback loop.", [
             `This channel id: ${this.id}`,
             `Target channel id: ${channel.id}`
-        ]);
+        ], ErrorCodes.CHANNEL_POSSIBLE_FEEDBACK_LOOP);
 
         (this.output as AudioNode).connect(channel.input as AudioNode);
 
@@ -121,7 +216,7 @@ export class Channel {
 
     public Unsend(channel: Channel | Master) {
 
-        if(channel instanceof Master) 
+        if (channel instanceof Master)
             return (channel as Master).DetachChannel(this);
 
         const idx: number = this.sends.indexOf(channel);
@@ -141,16 +236,34 @@ export class Channel {
     public UnsendToAllChannels() {
 
         for (var i: number = 0; i < this.sends.length; i++) {
-
             this.Unsend(this.sends[i]);
             i--;
         }
     }
 
-    public AttachAudioClip(audioClip: AudioClip) {
+    public AttachAudioClip(audioClip: AudioClip): Channel {
 
-        if (!this.audioClipPlayer) return Debug.Error("Cannot not link AudioClip to this channel because this channel's AudioClipPlayer is undefined.");
+        if (!this.audioClipPlayer) throw Error("Cannot not link AudioClip to this channel because this channel's AudioClipPlayer is undefined.");
 
         this.audioClipPlayer.AttachAudioClip(audioClip);
+        return this;
+    }
+
+    public Volume(volume?: number): number {
+
+        if(!this.context) throw new Error("Could not set volume on channel, because it's context is undefined.");
+        if(!this.gainNode) throw new Error("Could not set volume on channel, because it's GainNode is undefined.")
+
+        volume && this.gainNode.gain.setValueAtTime(volume, this.context.currentTime);
+        return volume ?? this.gainNode.gain.value;
+    }
+
+    public Pan(pan?: number): number {
+        
+        if(!this.context) throw new Error("Could not set pan on channel, because it's context is undefined.");
+        if(!this.stereoPannerNode) throw new Error("Cannot set pan on channel, because it's StereoPannerNode is undefined.");
+
+        pan && this.stereoPannerNode.pan.setValueAtTime(pan, this.context.currentTime);
+        return pan ?? this.stereoPannerNode.pan.value;
     }
 }

package/lib/src/core/classes/DpsPipeline.ts

@@ -7,6 +7,7 @@ import { ConstructProcessorWorklet, LoadWorkletOnAudioDevice } from "../../utili
 
 import { ErrorCodes, WarningCodes } from "../../console-codes";
 import { DspPipelineInitializationOptions } from "../../typings";
+import { DSP } from "../../index";
 
 /**
  * Represents the digital signal processing (DSP) pipeline responsible for initializing
@@ -45,9 +46,12 @@ export class DspPipeline {
      * @param options - Initialization options for the DSP pipeline.
      * Must include valid paths to the WebAssembly and AudioWorklet files.
      */
-    constructor(options: DspPipelineInitializationOptions) {
-        this.pathToWasm = options.pathToWasm;
-        this.pathToWorklet = options.pathToWorklet;
+    constructor({ pathToWasm, pathToWorklet, options }: DspPipelineInitializationOptions) {
+        this.pathToWasm = pathToWasm;
+        this.pathToWorklet = pathToWorklet;
+
+        // @ts-ignore
+        for(const key in options) DSP[key] = options[key];
     }
 
     /**

package/lib/src/core/classes/Effector.ts

@@ -8,8 +8,9 @@ export abstract class Effector {
     public id: string = v4();
     public label: string | null = null;
     public name: string = "Effector";
+
     public audioWorkletNode: AudioWorkletNode | null = null;
-    public parentialContext: AudioContext | null = null;
+    public context: AudioContext | null = null;
 
     private hasRegisteredMessageEventListener: boolean = false;
 
@@ -88,5 +89,5 @@ export abstract class Effector {
         return this;
     }
 
-    public abstract InitializeOnAttachment(parentialContext: AudioContext): Promise<void>;
+    public abstract InitializeOnAttachment(context: AudioContext): Promise<void>;
 }

package/lib/src/core/classes/Master.ts

@@ -1,42 +1,121 @@
 import { v4 } from "uuid";
 
 import { Channel } from "./Channel";
-
 import { Debug } from "../../utilities/debugger";
+import { Effector } from "./Effector";
 import { AudioClipPlayer } from "./AudioClipPlayer";
+import { AudioClip } from "./AudioClip";
+import { ErrorCodes } from "lib/src/console-codes";
 
 export class Master {
 
     public id: string = v4();
+
     public channels: Channel[] = [];
+    public effects: Effector[] = [];
 
+    public input: GainNode | null = null;
     public gainNode: GainNode | null = null;
     public analyserNode: AnalyserNode | null = null;
-
     public context: AudioContext | null = null;
+    public audioClipPlayer: AudioClipPlayer | null = null;
 
     constructor(context: AudioContext) {
 
         this.context = context;
 
+        this.disconnectAudioNodes();
+
+        this.audioClipPlayer = new AudioClipPlayer(context);
+
+        this.input = new GainNode(context);
         this.gainNode = new GainNode(context);
         this.analyserNode = new AnalyserNode(context);
 
+        this.input.connect(this.gainNode);
+        this.gainNode.connect(this.analyserNode);
+        this.analyserNode.connect(this.context.destination);
+
+        this.audioClipPlayer.Send(this);
+    }
+
+    private disconnectAudioNodes(): void {
+
+        if (this.input) this.input.disconnect();
+        if (this.gainNode) this.gainNode.disconnect();
+        if (this.analyserNode) this.analyserNode.disconnect();
+
+        this.effects.forEach(function (effect: Effector) {
+            if (effect.audioWorkletNode)
+                effect.audioWorkletNode.disconnect();
+        });
+    }
+
+    private rebuildEffectChain(): void {
+
+        if (!this.context) return;
+        if (!this.input || !this.gainNode || !this.analyserNode) return;
+
+        this.disconnectAudioNodes();
+
+        let currentNode: AudioNode = this.input;
+
+        this.effects.forEach(function (effect: Effector) {
+
+            if (!effect.audioWorkletNode) return;
+
+            currentNode.connect(effect.audioWorkletNode);
+            currentNode = effect.audioWorkletNode;
+        });
+
+        currentNode.connect(this.gainNode);
+
         this.gainNode.connect(this.analyserNode);
         this.analyserNode.connect(this.context.destination);
     }
 
+    public AttachEffect(effect: Effector): void {
+
+        if (this.effects.includes(effect)) return Debug.Error("Could not attach the effect because it is already part of this master channel.", [
+            "Call .DetachEffect([effect Effector]) before attaching the effect."
+        ], ErrorCodes.EFFECT_ALREADY_ATTACHED);
+
+        if(!this.context) return this.rebuildEffectChain();
+
+        this.effects.push(effect);
+        effect.InitializeOnAttachment(this.context);
+        this.rebuildEffectChain();
+    }
+
+    public DetachEffect(effect: Effector): void {
+
+        if (!this.effects.includes(effect)) return Debug.Error("Could not detach the effect because it is not part of this master channel.", [
+            "Call .AttachEffect([effect Effector]) before detaching the effect."
+        ], ErrorCodes.EFFECT_NOT_FOUND);
+
+        const self = this;
+
+        this.effects.forEach(function (_effect: Effector, index: number) {
+            if (effect.id === _effect.id) {
+                self.effects.splice(index, 1);
+                return;
+            }
+        });
+
+        this.rebuildEffectChain();
+    }
+
     public AttachChannel(channel: Channel): void {
 
         if (this.channels.includes(channel)) return Debug.Error("Could not attach the channel because it is already part of this master channel.", [
             "Call .DetachChannel([channel Channel]) before attaching the channel."
-        ]);
+        ], ErrorCodes.CHANNEL_ALREADY_ATTACHED);
 
         this.channels.push(channel);
 
-        if (channel.output && this.gainNode)
-            channel.output.connect(this.gainNode);
-        
+        if (channel.output && this.input)
+            channel.output.connect(this.input);
+
         return;
     }
 
@@ -44,19 +123,28 @@ export class Master {
 
         if (!this.channels.includes(channel)) return Debug.Error("Could not detach the channel because it is not part of this master channel.", [
             "Call .AttachChannel([channel Channel]) before detaching the channel."
-        ]);
+        ], ErrorCodes.CHANNEL_NOT_FOUND);
 
-        if (channel.output && this.gainNode)
-            channel.output.disconnect(this.gainNode);
+        if (channel.output && this.input)
+            channel.output.disconnect(this.input);
 
         const self = this;
 
         this.channels.forEach(function (_channel: Channel, index: number) {
-            if (channel.id === _channel.id) {
+            if (channel.id !== _channel.id) return;
 
-                self.channels.splice(index, 1);
-                return;
-            }
+            self.channels.splice(index, 1);
         });
     }
+
+    public HasAudioClipPlayer(): boolean {
+        return !!this.audioClipPlayer;
+    }
+
+    public AttachAudioClip(audioClip: AudioClip) {
+
+        if (!this.audioClipPlayer) return Debug.Error("Cannot not link AudioClip to this channel because this channel's AudioClipPlayer is undefined.");
+
+        this.audioClipPlayer.AttachAudioClip(audioClip);
+    }
 }

package/lib/src/effects/classes/Analyser.ts

@@ -0,0 +1,84 @@
+import { Effector } from "../../core/exports";
+
+type AnalyserOptionKeys = keyof Omit<AnalyserOptions, "channelCount" | "channelCountMode" | "channelInterpretation">;
+
+export class Analyser extends Effector {
+
+    public label: string | null = "Analyser";
+    public name: string = "Analyser";
+
+    public analyserNode: AnalyserNode | null = null;
+
+    public float32ArrayBuffer = new Float32Array();
+    public uint8ArrayBuffer = new Uint8Array();
+
+    private options: AnalyserOptions = {
+        fftSize: 32,
+        smoothingTimeConstant: 0.8,
+        minDecibels: -90,
+        maxDecibels: -10,
+    };
+
+    constructor(options?: Partial<AnalyserOptions>) {
+        super();
+
+        if (options) this.SetOptions(options);
+    }
+
+    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+
+        this.context = context;
+        this.analyserNode = new AnalyserNode(context, this.options);
+
+        this.audioWorkletNode = this.analyserNode as unknown as AudioWorkletNode;
+        this.allocateBuffers();
+    }
+
+    public SetOptions(options: Partial<AnalyserOptions>): void {
+
+        (Object.keys(options) as AnalyserOptionKeys[]).forEach((key) => {
+            const value = options[key];
+
+            if (typeof value === "undefined") return;
+
+            if (key === "fftSize" && value) {
+                const allowed = [32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768];
+                if (!allowed.includes(value)) return;
+            }
+
+            (this.options as any)[key] = value;
+
+            if (this.analyserNode) {
+                (this.analyserNode as any)[key] = value;
+            }
+        });
+
+        if (options.fftSize && this.analyserNode) {
+            this.allocateBuffers();
+        }
+    }
+
+    public GetWaveformFloatData(): Float32Array | null {
+
+        if (!this.analyserNode) return null;
+
+        this.analyserNode.getFloatTimeDomainData(this.float32ArrayBuffer);
+        return this.float32ArrayBuffer;
+    }
+
+    public GetWaveformByteData(): Uint8Array | null {
+
+        if (!this.analyserNode) return null;
+
+        this.analyserNode.getByteTimeDomainData(this.uint8ArrayBuffer);
+        return this.uint8ArrayBuffer;
+    }
+
+    private allocateBuffers(): void {
+
+        if (!this.analyserNode) return;
+
+        this.float32ArrayBuffer = new Float32Array(this.analyserNode.fftSize);
+        this.uint8ArrayBuffer = new Uint8Array(this.analyserNode.fftSize);
+    }
+}