@fluex/fluexgl-dsp 0.3.4 → 0.4.0

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

@@ -1,289 +1,156 @@
 import { v4 } from "uuid";
-
-import { Effector } from "./Effector";
+import { Debug } from "../../utilities/debugger";
+import { AudioClipPlayer } from "./AudioClipPlayer";
 import { AudioClip } from "./AudioClip";
 import { Master } from "./Master";
 
-import { ChannelOptions } from "../../typings";
-import { Debug } from "../../utilities/debugger";
-
 export class Channel {
 
     public id: string = v4();
-    public effects: Effector[] = [];
-    public label: string | null;
-
-    public parentialContext: AudioContext | null = null;
-    public parentialMasterChannel: Master | null = null;
+    public label: string = "Channel";
 
-    public audioClips: AudioClip[] = [];
-
-    public gainNode: GainNode | null = null;
+    public input: AudioNode | null = null;
     public stereoPannerNode: StereoPannerNode | null = null;
     public analyserNode: AnalyserNode | null = null;
-    public channelSplitterNode: ChannelSplitterNode | null = null;
-
-    public analyserFloatArrayBuffer = new Float32Array();
-    public analyserByteArrayBuffer = new Uint8Array();
-
-    public audioClipsInputGainNode: GainNode | null = null;
-
-    public analyserOptions: AnalyserOptions = { fftSize: 32 };
-
-    constructor(public options: Partial<ChannelOptions> = { maxAudioNodes: 8, maxEffects: 8 }) {
-        this.label = options.label ?? null;
-    }
-
-    private rebuildEffectChain() {
-        Debug.Log("Attempting to rebuild effect chain.");
-
-        if (!this.audioClipsInputGainNode || !this.stereoPannerNode) {
-            return Debug.Error(
-                "Could not rebuild effect chain, because one or more nodes on this channel are undefined.",
-                [
-                    `Channel id: ${this.id}.`,
-                    `Current amount of effects: ${this.effects.length}.`
-                ]
-            );
-        }
-        this.audioClipsInputGainNode.disconnect();
-
-        for (const effect of this.effects) {
-            effect.audioWorkletNode?.disconnect();
-        }
-
-        const activeEffects = this.effects.filter(function (e) {
-            return !!e.audioWorkletNode;
-        });
-
-        if (activeEffects.length === 0) {
-            this.audioClipsInputGainNode.connect(this.stereoPannerNode);
-        } else {
-            this.audioClipsInputGainNode.connect(activeEffects[0].audioWorkletNode!);
-
-            for (let i = 0; i < activeEffects.length - 1; i++) {
-                const current = activeEffects[i].audioWorkletNode!;
-                const next = activeEffects[i + 1].audioWorkletNode!;
-                current.connect(next);
-            }
+    public gainNode: GainNode | null = null;
+    public output: AudioNode | null = null;
 
-            const lastEffectNode = activeEffects[activeEffects.length - 1].audioWorkletNode!;
-            lastEffectNode.connect(this.stereoPannerNode);
-        }
+    public context: AudioContext | null = null;
 
-        Debug.Success("Successfully rebuilt effect chain.", [
-            `Channel id: ${this.id}.`,
-            `Current amount of effects: ${this.effects.length}`
-        ]);
-    }
+    private sends: Channel[] = [];
+    private audioClipPlayer: AudioClipPlayer | null = null;
 
-    public InitializeChannelOnMasterAttachment(master: Master) {
+    constructor(context: AudioContext) {
+        this.context = context;
 
-        this.parentialMasterChannel = master;
-        this.parentialContext = master.context;
+        this.disconnectAudioNodes(true);
 
-        this.gainNode = new GainNode(this.parentialContext);
-        this.stereoPannerNode = new StereoPannerNode(this.parentialContext);
-        this.analyserNode = new AnalyserNode(this.parentialContext, this.analyserOptions);
+        this.input = new GainNode(context);
+        this.stereoPannerNode = new StereoPannerNode(context);
+        this.analyserNode = new AnalyserNode(context);
+        this.gainNode = new GainNode(context);
+        this.output = new GainNode(context);
 
-        this.analyserFloatArrayBuffer = new Float32Array(this.analyserNode.fftSize);
-        this.analyserByteArrayBuffer = new Uint8Array(this.analyserNode.fftSize);
+        this.audioClipPlayer = new AudioClipPlayer(context);
 
-        this.audioClipsInputGainNode = new GainNode(this.parentialContext);
+        this.input.connect(this.stereoPannerNode);
+        this.stereoPannerNode.connect(this.analyserNode);
+        this.analyserNode.connect(this.gainNode);
+        this.gainNode.connect(this.output);
 
-        this.audioClipsInputGainNode.connect(this.stereoPannerNode);
-        this.stereoPannerNode.connect(this.gainNode);
-        this.gainNode.connect(this.analyserNode);
-        this.analyserNode.connect(this.parentialMasterChannel.gainNode);
+        this.audioClipPlayer.Send(this);
     }
 
-    public SetLabel(label: string): void {
-
-        this.options.label = label;
-        this.label = label;
-    }
+    private disconnectAudioNodes(gc?: boolean) {
 
-    public ClearLabel(): void {
+        this.input?.disconnect();
+        this.stereoPannerNode?.disconnect();
+        this.analyserNode?.disconnect();
+        this.gainNode?.disconnect();
+        this.output?.disconnect();
 
-        this.options.label = "";
-        this.label = null;
+        if (gc) {
+            this.input = null;
+            this.stereoPannerNode = null;
+            this.analyserNode = null;
+            this.gainNode = null;
+            this.output = null;
+        }
     }
 
-    public AttachAudioClip(clip: AudioClip) {
-
-        if (this.audioClips.includes(clip)) return Debug.Error("Could not attach audio clip because it is already part of this channel", [
-            "Call .DetachAudioClip([clip AudioClip]) before attaching audio clip."
-        ]);
-
-        clip.InitializeAudioClipOnAttaching(this);
-        this.audioClips.push(clip);
+    private isInitialized(): boolean {
+        return !!(this.context && this.input && this.output);
     }
 
-    public DetachAudioClip(clip: AudioClip) {
+    private isReachable(target: Channel): boolean {
 
-        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 deattaching audio clip."
-        ]);
-
-        const self: Channel = this;
+        const visited: Set<string> = new Set<string>();
+        const stack: Channel[] = [this];
 
-        clip.parentialAudioContext = null;
-        clip.parentialChannel = null;
-        clip.hasAttachedToChannel = false;
+        while (stack.length > 0) {
 
-        clip.stereoPannerNode?.disconnect();
-        clip.gainNode?.disconnect();
+            const current: Channel = stack.pop() as Channel;
 
-        clip.DisconnectAllAudioBufferSourceNodes();
+            if (current.id === target.id)
+                return true;
 
-        this.audioClips.forEach(function (_clip: AudioClip, index: number) {
-            if (clip.id === _clip.id)
-                return self.audioClips.splice(index, 1);
-        });
-    }
+            if (visited.has(current.id))
+                continue;
 
-    public HasAudioClip(clip: AudioClip): boolean {
+            visited.add(current.id);
 
-        for (let _clip of this.audioClips) {
-            if (_clip.id === clip.id) return true;
+            for (let i: number = 0; i < current.sends.length; i++)
+                stack.push(current.sends[i]);
         }
 
         return false;
     }
 
-    public SetVolume(volume: number): void {
-
-        if (!this.gainNode) return Debug.Error("Could not set channel volume because the channel is not attached to a master channel.", [
-            "Attach the channel to a master channel before setting the volume."
-        ]);
-
-        this.gainNode.gain.setValueAtTime(volume, this.parentialContext!.currentTime);
-    }
+    public Send(channel: Channel | Master) {
 
-    public SetPanLevel(pan: number): void {
+        if (channel instanceof Master) return (channel as Master).AttachChannel(this);
 
-        if (!this.stereoPannerNode) return Debug.Error("Could not set channel pan level because the channel is not attached to a master channel.", [
-            "Attach the channel to a master channel before setting the pan level."
+        if (channel.id === this.id) return Debug.Error("Could not link channel to itself.", [
+            `This channel id: ${this.id}`
         ]);
 
-        this.stereoPannerNode.pan.setValueAtTime(pan, this.parentialContext!.currentTime);
-    }
-
-    public AddEffect(effect: Effector): void {
-
-        if (!this.parentialContext) return Debug.Error("Could not add effect on channel, because the parential context is undefined.", [
-            `Channel ID: ${this.id}`,
-            `Effect ID: ${effect.id}`,
-            `Effect name: ${effect.constructor.name}`
-        ])
-
-        if (this.effects.includes(effect)) return Debug.Error("Could not add effect because it is already part of this channel", [
-            "Call .RemoveEffect([effect Effector]) before adding effect."
+        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()}`
         ]);
 
-        effect.InitializeOnAttachment(this.parentialContext);
-
-        this.effects.push(effect);
-        this.rebuildEffectChain();
-    }
-
-    public AttachEffect(effect: Effector): void {
-        return this.AddEffect(effect);
-    }
-
-    public RemoveEffect(effect: Effector): void {
+        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"}`
+        ]);
 
-        if (!this.effects.includes(effect)) return Debug.Error("Could not remove effect, because it is not part of this channel.", [
-            "Call .AddEffect([effect Effector]) before removing effect."
+        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}`
         ]);
 
-        const self: Channel = this;
+        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}`
+        ]);
 
-        this.effects.forEach(function (_effect: Effector, index: number) {
-            if (effect.id === _effect.id)
-                return self.effects.splice(index, 1);
-        });
+        (this.output as AudioNode).connect(channel.input as AudioNode);
 
-        this.rebuildEffectChain();
+        this.sends.push(channel);
     }
 
-    public DetachEffect(effect: Effector): void {
-        return this.RemoveEffect(effect);
-    }
+    public Unsend(channel: Channel | Master) {
 
-    public SetAnalyserFftSize(value: number): number | null {
+        if(channel instanceof Master) 
+            return (channel as Master).DetachChannel(this);
 
-        if (!this.analyserNode) {
-            Debug.Error("Could not set FFT size on analyser because the analyser has not been defined.");
-            return null;
-        }
+        const idx: number = this.sends.indexOf(channel);
 
-        this.analyserNode.fftSize = value;
+        if (idx === -1) return;
 
-        this.analyserFloatArrayBuffer = new Float32Array(this.analyserNode.fftSize);
-        this.analyserByteArrayBuffer = new Uint8Array(this.analyserNode.fftSize);
+        if (this.output && channel.input)
+            this.output.disconnect(channel.input);
 
-        return this.analyserNode.fftSize;
+        this.sends.splice(idx, 1);
     }
 
-    public GetWaveformFloatData(): Float32Array | null {
-
-        if (!this.analyserNode) {
-            Debug.Error("Could not get waveform float data, because the analyser has not been defined.");
-            return null;
-        }
-
-        if (this.analyserFloatArrayBuffer.length !== this.analyserNode.fftSize) {
-            this.analyserFloatArrayBuffer = new Float32Array(this.analyserNode.fftSize);
-        }
-
-        this.analyserNode.getFloatTimeDomainData(this.analyserFloatArrayBuffer);
-        return this.analyserFloatArrayBuffer;
+    public HasAudioClipPlayer(): boolean {
+        return !!this.audioClipPlayer;
     }
 
-    public GetWaveformByteData(): Uint8Array | null {
+    public UnsendToAllChannels() {
 
-        if (!this.analyserNode) {
-            Debug.Error("Could not get waveform byte data, because the analyser has not been defined.");
-            return null;
-        }
+        for (var i: number = 0; i < this.sends.length; i++) {
 
-        if (this.analyserByteArrayBuffer.length !== this.analyserNode.fftSize) {
-            this.analyserByteArrayBuffer = new Uint8Array(this.analyserNode.fftSize);
+            this.Unsend(this.sends[i]);
+            i--;
         }
-
-        this.analyserNode.getByteTimeDomainData(this.analyserByteArrayBuffer);
-        return this.analyserByteArrayBuffer;
-    }
-
-    public SetAnalyserOptions(options: AnalyserOptions): Channel | null {
-
-        this.analyserOptions = { ...options };
-
-        if (!this.analyserNode) return null;
-
-        this.analyserNode.minDecibels = options.minDecibels ?? this.analyserNode.minDecibels;
-        this.analyserNode.maxDecibels = options.maxDecibels ?? this.analyserNode.maxDecibels;
-        this.analyserNode.fftSize = options.fftSize ?? 32;
-        this.analyserNode.smoothingTimeConstant = options.smoothingTimeConstant ?? this.analyserNode.smoothingTimeConstant;
-
-        this.analyserByteArrayBuffer = new Uint8Array(this.analyserNode.fftSize);
-        this.analyserFloatArrayBuffer = new Float32Array(this.analyserNode.fftSize);
-
-        return this;
     }
 
-    // Public getters and setters
-
-    public get volume(): number | null {
-
-        if (!this.gainNode) return null;
-        return this.gainNode.gain.value;
-    }
+    public AttachAudioClip(audioClip: AudioClip) {
 
-    public get panLevel(): number | null {
+        if (!this.audioClipPlayer) return Debug.Error("Cannot not link AudioClip to this channel because this channel's AudioClipPlayer is undefined.");
 
-        if (!this.stereoPannerNode) return null;
-        return this.stereoPannerNode.pan.value;
+        this.audioClipPlayer.AttachAudioClip(audioClip);
     }
-}
+}

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

@@ -3,7 +3,7 @@ import { v4 } from "uuid";
 import { AudioDevice } from "./AudioDevice";
 import { Debug } from "../../utilities/debugger";
 import { LoadWebAssemblyModule } from "../../utilities/web-assembly";
-import { ConstructProcessorWorklet, LoadWorkletOnMasterChannel } from "../../utilities/helpers";
+import { ConstructProcessorWorklet, LoadWorkletOnAudioDevice } from "../../utilities/helpers";
 
 import { ErrorCodes, WarningCodes } from "../../console-codes";
 import { DspPipelineInitializationOptions } from "../../typings";
@@ -142,7 +142,7 @@ export class DspPipeline {
 
         if (!defaultAudioDevice) return null;
 
-        await LoadWorkletOnMasterChannel(defaultAudioDevice.masterChannel, this.blobUrl);
+        await LoadWorkletOnAudioDevice(defaultAudioDevice, this.blobUrl);
 
         return defaultAudioDevice;
     }

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

@@ -24,9 +24,7 @@ export abstract class Effector {
     private handleIncomingMessages(event: MessageEvent) {
 
         const messageData = event.data as IncomingProcessorMessage;
-
-        console.log(messageData);
-
+        
         switch (messageData.type) {
             case "message":
                 return this.events["incoming-processor-message"].forEach(ev => ev(messageData));

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

@@ -3,48 +3,60 @@ import { v4 } from "uuid";
 import { Channel } from "./Channel";
 
 import { Debug } from "../../utilities/debugger";
+import { AudioClipPlayer } from "./AudioClipPlayer";
 
 export class Master {
 
     public id: string = v4();
     public channels: Channel[] = [];
-    public context: AudioContext = new AudioContext();
 
-    public gainNode: GainNode = this.context.createGain();
-    public analyserNode: AnalyserNode = this.context.createAnalyser();
+    public gainNode: GainNode | null = null;
+    public analyserNode: AnalyserNode | null = null;
+
+    public context: AudioContext | null = null;
+
+    constructor(context: AudioContext) {
+
+        this.context = context;
+
+        this.gainNode = new GainNode(context);
+        this.analyserNode = new AnalyserNode(context);
 
-    constructor() {
-     
         this.gainNode.connect(this.analyserNode);
         this.analyserNode.connect(this.context.destination);
     }
 
     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.",[
+        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."
         ]);
 
-        channel.InitializeChannelOnMasterAttachment(this);
-
         this.channels.push(channel);
+
+        if (channel.output && this.gainNode)
+            channel.output.connect(this.gainNode);
+        
         return;
     }
 
     public DetachChannel(channel: Channel): void {
 
-        if(!this.channels.includes(channel)) return Debug.Error("Could not detach the channel because it is not part of this master channel.", [
+        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."
         ]);
 
+        if (channel.output && this.gainNode)
+            channel.output.disconnect(this.gainNode);
+
         const self = this;
 
-        this.channels.forEach(function(_channel: Channel, index: number) {
-            if(channel.id === _channel.id) {
+        this.channels.forEach(function (_channel: Channel, index: number) {
+            if (channel.id === _channel.id) {
 
                 self.channels.splice(index, 1);
                 return;
             }
         });
     }
-}
+}

package/lib/src/core/exports.ts

@@ -3,4 +3,5 @@ export { Channel } from "./classes/Channel";
 export { Effector } from "./classes/Effector";
 export { Master } from "./classes/Master";
 export { AudioClip } from "./classes/AudioClip";
-export { DspPipeline } from "./classes/DpsPipeline";
+export { DspPipeline } from "./classes/DpsPipeline";
+export { AudioClipPlayer } from "./classes/AudioClipPlayer";

package/lib/src/core/functions/rebuild-effect-chain.ts

@@ -0,0 +1,5 @@
+import { Channel } from "../classes/Channel";
+
+export function rebuildEffectChain(channel: Channel) {
+
+}

package/lib/src/index.ts

@@ -54,7 +54,8 @@ export {
     Effector,
     Master,
     AudioClip,
-    DspPipeline
+    DspPipeline,
+    AudioClipPlayer
 } from "./core/exports";
 
 export {
@@ -65,7 +66,7 @@ export {
     ResolveDefaultAudioOutputDevice,
     LoadAudioSource,
     LoadAudioSourceFromBlob,
-    LoadWorkletOnMasterChannel,
+    LoadWorkletOnAudioDevice,
     SendMessageToWorklet
 } from "./utilities/helpers";
 

package/lib/src/utilities/helpers.ts

@@ -113,7 +113,7 @@ export async function ResolveDefaultAudioOutputDevice(init: DspPipelineInitializ
 
     if (!defaultAudioDevice) return null;
 
-    await LoadWorkletOnMasterChannel(defaultAudioDevice.masterChannel, init.workletBlobUrl);
+    await LoadWorkletOnAudioDevice(defaultAudioDevice, init.workletBlobUrl);
 
     return defaultAudioDevice;
 }
@@ -138,7 +138,7 @@ export async function ResolveDefaultAudioInputDevice(init: DspPipelineInitializa
 
     if (!defaultAudioDevice) return null;
 
-    await LoadWorkletOnMasterChannel(defaultAudioDevice.masterChannel, init.workletBlobUrl);
+    await LoadWorkletOnAudioDevice(defaultAudioDevice, init.workletBlobUrl);
 
     return defaultAudioDevice;
 }
@@ -213,10 +213,10 @@ export function ConstructProcessorWorklet(code: string): string {
     return URL.createObjectURL(blob);
 }
 
-export async function LoadWorkletOnMasterChannel(master: Master, workletBlobUrl: string) {
-    Debug.Log("Loading worklet modules on master channel...", [`Channel ID: ${master.id}`]);
+export async function LoadWorkletOnAudioDevice(audioDevice: AudioDevice, workletBlobUrl: string) {
+    Debug.Log("Loading worklet modules on master channel...", [`Channel ID: ${audioDevice.id}`]);
 
-    const context: AudioContext = master.context,
+    const context: AudioContext = audioDevice.context,
         start: number = Date.now();
 
     await context.audioWorklet.addModule(workletBlobUrl);

package/package.json

@@ -1,12 +1,13 @@
 {
     "name": "@fluex/fluexgl-dsp",
-    "version": "0.3.4",
+    "version": "0.4.0",
     "description": "An open-source, web-based DSP library developed alongside FluexGL, designed for creating and manipulating sounds in various contexts.",
     "main": "lib/dist/index.js",
     "types": "lib/dist/index.d.ts",
     "scripts": {
         "typecheck": "tsc -p lib/tsconfig.json --noEmit",
         "build": "tsc --build",
+        "watch": "tsc --watch",
         "build-and-deploy": "node ./scripts/build-and-deploy.js"
     },
     "keywords": [