@fluex/fluexgl-dsp 0.1.2

package/README.md

@@ -0,0 +1,87 @@
+# 🎚️ FluexGL DSP
+An open-source, web-based DSP library developed alongside FluexGL, with the purpose of creating and manipulating sound in various contexts.
+
+This open-source project is part of the Fluex ecosystem and is maintained by Rohan Kanhaisingh, the lead developer of this library.
+
+**Note: this project is still under development and may not work yet.**
+
+## 🧩 About
+FluexGL DSP is a modern, TypeScript-based Web Audio library for creating and manipulating sound. Inspired by and based on DAW-style workflows, it provides a flexible, object-oriented channel system with master and sub channels.
+
+It integrates smoothly with FluexGL, making it ideal for use in games, interactive web experiences, and multimedia projects.
+
+## 📦 Installation
+
+See down below for more details.
+
+```
+$ npm install @fluexgl/dsp
+```
+
+## ⚡ Quick start
+
+```ts
+import { 
+    AudioDevice, 
+    InitializeDspPipeline, 
+    LoadAudioSource, 
+    ResolveDefaultAudioOutputDevice, 
+    Channel, 
+    AudioSourceData, 
+    AudioClip 
+} from "@fluexgl/dsp";
+
+(async function() {
+
+    // Make sure that FluexGL can access audio devices.
+    const hasInitialized = await InitializeDspPipeline();
+
+    if(!hasInitialized) return null;
+
+    // Resolves the default audio output device.
+    const audioDevice: AudioDevice | null = await ResolveDefaultAudioOutputDevice({
+        pathToWasm: "/wasm/fluexgl-dsp-wasm_bg.wasm"
+    });
+
+    if(!audioDevice) return;
+
+    // Get the master channel from the default audio output device.
+    const masterChannel = audioDevice.GetMasterChannel();
+
+    // Create a new empty channel.
+    const channel = new Channel();
+
+    // Label the channel as 'BackgroundMusic'.
+    channel.SetLabel("BackgroundMusic");
+
+    // Attach the 'BackgroundMusic' channel, to the device's master channel.
+    masterChannel.AttachChannel(channel);
+
+    // Load the data from the audio source.
+    const audioSourceData: AudioSourceData | null = await LoadAudioSource("/assets/data/bruh.mp3");
+
+    if(!audioSourceData) return;
+
+    // Create a audio node based on the data.
+    const audioClip = new AudioClip(audioSourceData);
+
+    // Attach the audio node to the channel.
+    channel.AttachAudioClip(audioClip);
+
+    // Click event listener on window.
+    window.addEventListener("click", function() {
+
+        // Play the audio clip
+        audioClip.Play();
+    });
+})();
+```
+
+## 💡 Effects, tools and more
+FluexGL DSP provides built-in such as effects, tools, and utilities for advanced web audio processing, such as reverbs, delays, and stereo imaging effects.
+
+The library also includes a powerful debugging system that allows developers to inspect and analyze the audio pipeline for easier troubleshooting and optimization.
+
+## Web Assembly
+
+FluexGL DSP is partially made using Web Assembly, and Rust as programming language. In order to use FluexGL DSP, the wasm source code must be provided when initializing the DSP pipeline. The source code can be found at the [FluexGL DSP WebAssembly Github repository](https://github.com/rohankanhaisingh/FluexGL-DSP-WebAssembly).

package/lib/dist/console-codes.d.ts

@@ -0,0 +1,14 @@
+export declare enum ErrorCodes {
+    NO_CONTEXT_PERMISSION = "FLUEXGL@AUDIO_ERROR_0001",
+    NO_FILE_TYPE_FOUND = "FLUEXGL@AUDIO_ERROR_0002",
+    PATH_TO_FILE_NOT_FOUND = "FLUEXGL@AUDIO_ERROR_0003",
+    SAME_MASTER_CHANNEL = "FLUEXGL@AUDIO_ERROR_0004",
+    WASM_MODULE_INITIALIZATION_FAILED = "FLUEXGL@AUDIO_ERROR_0005",
+    PATH_TO_WASM_FILE_NOT_FOUND = "FLUEXGL@AUDIO_ERROR_0006"
+}
+export declare enum WarningCodes {
+    NO_DEFAULT_AUDIO_DEVICE_FOUND = "FLUEXGL@AUDIO_WARNING_0001"
+}
+export declare enum SuccessCodes {
+}
+//# sourceMappingURL=console-codes.d.ts.map

package/lib/dist/console-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-codes.d.ts","sourceRoot":"","sources":["../src/console-codes.ts"],"names":[],"mappings":"AAAA,oBAAY,UAAU;IAClB,qBAAqB,6BAA6B;IAClD,kBAAkB,6BAA6B;IAC/C,sBAAsB,6BAA6B;IACnD,mBAAmB,6BAA6B;IAChD,iCAAiC,6BAA6B;IAC9D,2BAA2B,6BAA6B;CAC3D;AAED,oBAAY,YAAY;IACpB,6BAA6B,+BAA+B;CAC/D;AAED,oBAAY,YAAY;CAEvB"}

package/lib/dist/console-codes.js

@@ -0,0 +1,16 @@
+export var ErrorCodes;
+(function (ErrorCodes) {
+    ErrorCodes["NO_CONTEXT_PERMISSION"] = "FLUEXGL@AUDIO_ERROR_0001";
+    ErrorCodes["NO_FILE_TYPE_FOUND"] = "FLUEXGL@AUDIO_ERROR_0002";
+    ErrorCodes["PATH_TO_FILE_NOT_FOUND"] = "FLUEXGL@AUDIO_ERROR_0003";
+    ErrorCodes["SAME_MASTER_CHANNEL"] = "FLUEXGL@AUDIO_ERROR_0004";
+    ErrorCodes["WASM_MODULE_INITIALIZATION_FAILED"] = "FLUEXGL@AUDIO_ERROR_0005";
+    ErrorCodes["PATH_TO_WASM_FILE_NOT_FOUND"] = "FLUEXGL@AUDIO_ERROR_0006";
+})(ErrorCodes || (ErrorCodes = {}));
+export var WarningCodes;
+(function (WarningCodes) {
+    WarningCodes["NO_DEFAULT_AUDIO_DEVICE_FOUND"] = "FLUEXGL@AUDIO_WARNING_0001";
+})(WarningCodes || (WarningCodes = {}));
+export var SuccessCodes;
+(function (SuccessCodes) {
+})(SuccessCodes || (SuccessCodes = {}));

package/lib/dist/core/classes/AudioClip.d.ts

@@ -0,0 +1,67 @@
+import { AudioClipAnalyserProperty, AudioClipAnalyserType, AudioClipEventMap, AudioSourceData } from "../../typings";
+import { Channel } from "./Channel";
+export declare class AudioClip {
+    data: AudioSourceData;
+    id: string;
+    hasAttachedToChannel: boolean;
+    loop: boolean;
+    isPlaying: boolean;
+    startTime: number;
+    offsetAtStart: number;
+    progressUpdateSpeed: number;
+    gainNode: GainNode | null;
+    stereoPannerNode: StereoPannerNode | null;
+    parentialAudioContext: AudioContext | null;
+    parentialChannel: Channel | null;
+    preAnalyser: AnalyserNode | null;
+    postAnalyser: AnalyserNode | null;
+    preAnalyserEnabled: boolean;
+    postAnalyserEnabled: boolean;
+    preAnalyserOptions: AnalyserOptions;
+    postAnalyserOptions: AnalyserOptions;
+    preAnalyserFloatArrayBuffer: Float32Array;
+    postAnalyserFloatArrayBuffer: Float32Array;
+    preAnalyserByteArrayBuffer: Uint8Array;
+    postAnalyserByteArrayBuffer: Uint8Array;
+    private audioBufferSourceNodes;
+    private maxAudioBufferSourceNodes;
+    private progressInterval;
+    private events;
+    constructor(data: AudioSourceData);
+    private createBufferSource;
+    private connectSourcesTo;
+    private safeDisconnect;
+    private rebuildNodeChain;
+    InitializeAudioClipOnAttaching(channel: Channel): AudioClip | null;
+    Play(timestamp?: number, offset?: number): AudioClip | null;
+    Seek(seconds: number): AudioClip | null;
+    Stop(): AudioClip | null;
+    SetVolume(volume: number): AudioClip | void;
+    SetPanLevel(panLevel: number): AudioClip | void;
+    Loop(loop?: boolean): AudioClip;
+    SetMaxAudioBufferSourceNodes(value: number): AudioClip;
+    DisconnectAllAudioBufferSourceNodes(): boolean;
+    AddEventListener<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): () => void;
+    Once<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): () => void;
+    RemoveEventListener<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): AudioClip;
+    ClearEventListeners(event?: keyof AudioClipEventMap): AudioClip;
+    GetChannelData(channel?: number): Float32Array;
+    EnablePreAnalyser(): boolean;
+    DisablePreAnalyser(): boolean;
+    EnablePostAnalyser(): boolean;
+    DisablePostAnalyser(): boolean;
+    SetPreAnalyserOptions(options: AnalyserOptions): void;
+    SetPostAnalyserOptions(options: AnalyserOptions): void;
+    SetAnalyserOption(analyserType: AudioClipAnalyserType, property: AudioClipAnalyserProperty, value: number): boolean;
+    GetWaveformFloatData(analyserType: AudioClipAnalyserType): Float32Array | null;
+    GetWaveformByteData(analyserType: AudioClipAnalyserType): Uint8Array | null;
+    get currentPlaybackTime(): number;
+    get duration(): number;
+    get volume(): number;
+    get stereoPanning(): number;
+    get formattedDuration(): string;
+    get sampleRate(): number;
+    get numberOfChannels(): number;
+    get byteLength(): number;
+}
+//# sourceMappingURL=AudioClip.d.ts.map

package/lib/dist/core/classes/AudioClip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioClip.d.ts","sourceRoot":"","sources":["../../../src/core/classes/AudioClip.ts"],"names":[],"mappings":"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"}

package/lib/dist/core/classes/AudioClip.js

@@ -0,0 +1,410 @@
+import { v4 } from "uuid";
+import { format } from "date-fns";
+import { Debug } from "../../utilities/debugger";
+export class AudioClip {
+    data;
+    id = v4();
+    hasAttachedToChannel = false;
+    loop = false;
+    isPlaying = false;
+    startTime = 0;
+    offsetAtStart = 0;
+    progressUpdateSpeed = 20;
+    gainNode = null;
+    stereoPannerNode = null;
+    parentialAudioContext = null;
+    parentialChannel = null;
+    preAnalyser = null;
+    postAnalyser = null;
+    preAnalyserEnabled = false;
+    postAnalyserEnabled = false;
+    preAnalyserOptions = {};
+    postAnalyserOptions = {};
+    preAnalyserFloatArrayBuffer = new Float32Array();
+    postAnalyserFloatArrayBuffer = new Float32Array();
+    preAnalyserByteArrayBuffer = new Uint8Array();
+    postAnalyserByteArrayBuffer = new Uint8Array();
+    audioBufferSourceNodes = [];
+    maxAudioBufferSourceNodes = 1;
+    progressInterval = 0;
+    events = {
+        "progress": []
+    };
+    constructor(data) {
+        this.data = data;
+    }
+    // Private methods.
+    createBufferSource() {
+        if (!this.parentialAudioContext)
+            return null;
+        const context = this.parentialAudioContext;
+        const bufferSource = context.createBufferSource();
+        bufferSource.buffer = this.data.audioBuffer;
+        bufferSource.loop = this.loop;
+        return bufferSource;
+    }
+    connectSourcesTo(target) {
+        for (const src of this.audioBufferSourceNodes) {
+            src.disconnect();
+            src.connect(target);
+        }
+    }
+    safeDisconnect(node) {
+        node?.disconnect();
+    }
+    rebuildNodeChain() {
+        if (!this.parentialAudioContext || !this.gainNode || !this.stereoPannerNode || !this.parentialChannel || !this.parentialChannel.audioClipsInputGainNode) {
+            Debug.Error("rebuildNodeChain: missing context or core nodes (gain/panner).");
+            return false;
+        }
+        const destination = this.parentialChannel.audioClipsInputGainNode;
+        this.safeDisconnect(this.gainNode);
+        this.safeDisconnect(this.stereoPannerNode);
+        this.safeDisconnect(this.preAnalyser);
+        this.safeDisconnect(this.postAnalyser);
+        let entry = this.gainNode;
+        if (this.preAnalyserEnabled && this.preAnalyser) {
+            entry = this.preAnalyser;
+            this.preAnalyser.connect(this.gainNode);
+        }
+        this.gainNode.connect(this.stereoPannerNode);
+        if (this.postAnalyserEnabled && this.postAnalyser) {
+            this.stereoPannerNode.connect(this.postAnalyser);
+            this.postAnalyser.connect(destination);
+        }
+        else {
+            this.stereoPannerNode.connect(destination);
+        }
+        this.connectSourcesTo(entry);
+        return true;
+    }
+    // Public methods
+    InitializeAudioClipOnAttaching(channel) {
+        if (!channel.parentialContext || !channel.audioClipsInputGainNode) {
+            Debug.Error("Could not initialize audio clip on channel attachment, because channel it's master channel has not been defined.", [
+                `Call .AttachChannel([channel<"${channel.id}"> Channel]) on the master channel.`
+            ]);
+            return null;
+        }
+        this.gainNode = new GainNode(channel.parentialContext);
+        this.stereoPannerNode = new StereoPannerNode(channel.parentialContext);
+        this.parentialAudioContext = channel.parentialContext;
+        this.parentialChannel = channel;
+        this.hasAttachedToChannel = true;
+        return this;
+    }
+    Play(timestamp, offset) {
+        if (!this.hasAttachedToChannel || !this.parentialAudioContext || !this.parentialChannel) {
+            Debug.Error("Could not play the audio node because it is not attached to a channel", [
+                "Call 'AttachAudioClip([clip AudioClip])' on a channel, before playing this audio node."
+            ]);
+            return this;
+        }
+        const context = this.parentialAudioContext;
+        const self = this;
+        if (this.audioBufferSourceNodes.length > this.maxAudioBufferSourceNodes - 1)
+            return null;
+        const bufferSource = this.createBufferSource();
+        if (!bufferSource) {
+            Debug.Error("Something went wrong.");
+            return null;
+        }
+        const actualOffset = offset ?? this.offsetAtStart ?? 0;
+        this.startTime = context.currentTime;
+        this.offsetAtStart = actualOffset;
+        this.isPlaying = true;
+        if (this.progressInterval)
+            clearInterval(this.progressInterval);
+        if (this.isPlaying)
+            this.progressInterval = setInterval(function () {
+                if (!self.isPlaying)
+                    return;
+                const current = self.offsetAtStart + (context.currentTime - self.startTime);
+                const date = new Date(current * 1000);
+                const formattedTime = format(date, "mm:ss");
+                const progressPayload = {
+                    current: parseFloat(current.toFixed(2)),
+                    startTime: self.startTime,
+                    offset: self.offsetAtStart,
+                    contextTimestamp: context.currentTime,
+                    formatted: formattedTime
+                };
+                self.events.progress.forEach(function (cb) {
+                    cb(progressPayload);
+                });
+            }, this.progressUpdateSpeed);
+        bufferSource.addEventListener("ended", function () {
+            const i = self.audioBufferSourceNodes.indexOf(bufferSource);
+            bufferSource.disconnect();
+            if (i === 0)
+                self.isPlaying = false;
+            if (i >= 0)
+                return self.audioBufferSourceNodes.splice(i, 1);
+        });
+        this.audioBufferSourceNodes.push(bufferSource);
+        this.rebuildNodeChain();
+        bufferSource.start(timestamp ?? this.startTime, actualOffset);
+        return this;
+    }
+    Seek(seconds) {
+        if (!this.parentialAudioContext || !this.hasAttachedToChannel) {
+            Debug.Error("Could not seek because the clip is not attached to a channel.", [
+                `Clip ID: ${this.id}`
+            ]);
+            return null;
+        }
+        const clamped = Math.max(0, Math.min(seconds, this.duration));
+        if (!this.isPlaying) {
+            this.offsetAtStart = clamped;
+            return this;
+        }
+        this.Stop();
+        this.Play(undefined, clamped);
+        return this;
+    }
+    Stop() {
+        if (!this.hasAttachedToChannel || !this.parentialAudioContext) {
+            Debug.Error("Could not stop the audio node because it is not attached to a channel", [
+                "Call 'AttachAudioClip([node AudioNode])' on a channel, before stopping this audio node."
+            ]);
+            return null;
+        }
+        this.audioBufferSourceNodes.forEach(function (node) {
+            node.stop();
+            node.disconnect();
+        });
+        this.audioBufferSourceNodes.length = 0;
+        this.isPlaying = false;
+        if (this.progressInterval) {
+            clearInterval(this.progressInterval);
+            this.progressInterval = null;
+        }
+        return this;
+    }
+    SetVolume(volume) {
+        if (!this.gainNode || !this.parentialAudioContext)
+            return Debug.Error("Something went wrong while setting the volume.", [
+                `Gain node on audio clip '${this.id}' is undefined.`
+            ]);
+        this.gainNode.gain.setValueAtTime(volume, this.parentialAudioContext.currentTime);
+        return this;
+    }
+    SetPanLevel(panLevel) {
+        if (!this.stereoPannerNode || !this.parentialAudioContext)
+            return Debug.Error("Something went wrong while setting the pan level", [
+                `Stereo panner node on audio clip '${this.id}' is undefined`
+            ]);
+        if (panLevel < -1 || panLevel > 1)
+            return Debug.Error("Could not set the pan level because it is not between -1 and 1.", [
+                "Provide this method with a value between -1 and 1"
+            ]);
+        this.stereoPannerNode.pan.setValueAtTime(panLevel, this.parentialAudioContext.currentTime);
+        return this;
+    }
+    Loop(loop) {
+        this.audioBufferSourceNodes.forEach(function (node) {
+            node.loop = loop ?? true;
+        });
+        this.loop = loop ?? true;
+        return this;
+    }
+    SetMaxAudioBufferSourceNodes(value) {
+        Debug.Warn("Changing the amount of buffer source nodes may cause some properties of this class instance to work inproperly.", [
+            "The default value is 1."
+        ]);
+        this.maxAudioBufferSourceNodes = value;
+        return this;
+    }
+    DisconnectAllAudioBufferSourceNodes() {
+        if (!this.parentialAudioContext) {
+            Debug.Error("Could not disconnect audio buffer source nodes, because the parential audio contex has not been found", [
+                `Clip ID: ${this.id}`,
+                `Parential channel id: ${this.parentialChannel ? this.parentialChannel.id : "none"}`
+            ]);
+            return false;
+        }
+        const contextCurrentTime = this.parentialAudioContext?.currentTime;
+        this.audioBufferSourceNodes.forEach(function (node) {
+            node.stop(contextCurrentTime);
+            node.disconnect();
+        });
+        return true;
+    }
+    AddEventListener(event, cb) {
+        this.events[event].push(cb);
+        return () => this.RemoveEventListener(event, cb);
+    }
+    Once(event, cb) {
+        const wrapper = ((...args) => {
+            // @ts-ignore
+            cb(...args);
+            this.RemoveEventListener(event, wrapper);
+        });
+        return this.AddEventListener(event, wrapper);
+    }
+    RemoveEventListener(event, cb) {
+        const arr = this.events[event];
+        for (let i = 0; i < arr.length; i++) {
+            if (arr[i] === cb) {
+                arr.splice(i, 1);
+                break;
+            }
+        }
+        return this;
+    }
+    ClearEventListeners(event) {
+        if (event) {
+            this.events[event].length = 0;
+        }
+        else {
+            Object.keys(this.events).forEach((k) => (this.events[k].length = 0));
+        }
+        return this;
+    }
+    GetChannelData(channel = 0) {
+        return this.data.audioBuffer.getChannelData(channel);
+    }
+    EnablePreAnalyser() {
+        if (!this.parentialAudioContext || !this.parentialChannel || !this.hasAttachedToChannel) {
+            Debug.Error("EnablePreAnalyser: clip niet aan channel gekoppeld.");
+            return false;
+        }
+        if (!this.preAnalyser)
+            this.preAnalyser = new AnalyserNode(this.parentialAudioContext, this.preAnalyserOptions);
+        this.preAnalyserFloatArrayBuffer = new Float32Array(this.preAnalyser.fftSize);
+        this.preAnalyserByteArrayBuffer = new Uint8Array(this.preAnalyser.fftSize);
+        this.preAnalyserEnabled = true;
+        return this.rebuildNodeChain();
+    }
+    DisablePreAnalyser() {
+        this.preAnalyserEnabled = false;
+        return this.rebuildNodeChain();
+    }
+    EnablePostAnalyser() {
+        if (!this.parentialAudioContext || !this.parentialChannel || !this.hasAttachedToChannel) {
+            Debug.Error("EnablePostAnalyser: clip niet aan channel gekoppeld.");
+            return false;
+        }
+        if (!this.postAnalyser)
+            this.postAnalyser = new AnalyserNode(this.parentialAudioContext, this.postAnalyserOptions);
+        this.postAnalyserFloatArrayBuffer = new Float32Array(this.postAnalyser.fftSize);
+        this.postAnalyserByteArrayBuffer = new Uint8Array(this.postAnalyser.fftSize);
+        this.postAnalyserEnabled = true;
+        return this.rebuildNodeChain();
+    }
+    DisablePostAnalyser() {
+        this.postAnalyserEnabled = false;
+        return this.rebuildNodeChain();
+    }
+    SetPreAnalyserOptions(options) {
+        this.preAnalyserOptions = { ...options };
+        if (!this.preAnalyser)
+            return;
+        this.preAnalyser.fftSize = options.fftSize ?? this.preAnalyser.fftSize;
+        this.preAnalyser.minDecibels = options.minDecibels ?? this.preAnalyser.minDecibels;
+        this.preAnalyser.maxDecibels = options.maxDecibels ?? this.preAnalyser.maxDecibels;
+        this.preAnalyser.smoothingTimeConstant = options.smoothingTimeConstant ?? this.preAnalyser.smoothingTimeConstant;
+    }
+    SetPostAnalyserOptions(options) {
+        this.postAnalyserOptions = { ...options };
+        if (!this.postAnalyser)
+            return;
+        this.postAnalyser.fftSize = options.fftSize ?? this.postAnalyser.fftSize;
+        this.postAnalyser.minDecibels = options.minDecibels ?? this.postAnalyser.minDecibels;
+        this.postAnalyser.maxDecibels = options.maxDecibels ?? this.postAnalyser.maxDecibels;
+        this.postAnalyser.smoothingTimeConstant = options.smoothingTimeConstant ?? this.postAnalyser.smoothingTimeConstant;
+    }
+    SetAnalyserOption(analyserType, property, value) {
+        const node = analyserType === "pre" ? this.preAnalyser : this.postAnalyser;
+        if (node)
+            switch (property) {
+                case "fftSize":
+                    node.fftSize = value;
+                    break;
+                case "minDecibels":
+                    node.minDecibels = value;
+                    break;
+                case "maxDecibels":
+                    node.maxDecibels = value;
+                    break;
+                case "smoothingTimeConstant":
+                    node.smoothingTimeConstant = value;
+                    break;
+                default: return false;
+            }
+        const opts = analyserType === "pre" ? this.preAnalyserOptions : this.postAnalyserOptions;
+        switch (property) {
+            case "fftSize":
+                opts.fftSize = value;
+                break;
+            case "minDecibels":
+                opts.minDecibels = value;
+                break;
+            case "maxDecibels":
+                opts.maxDecibels = value;
+                break;
+            case "smoothingTimeConstant":
+                opts.smoothingTimeConstant = value;
+                break;
+            default: return false;
+        }
+        return true;
+    }
+    GetWaveformFloatData(analyserType) {
+        if (analyserType === "pre" && this.preAnalyser) {
+            this.preAnalyser.getFloatTimeDomainData(this.preAnalyserFloatArrayBuffer);
+            return this.preAnalyserFloatArrayBuffer;
+        }
+        else if (analyserType === "post" && this.postAnalyser) {
+            this.postAnalyser.getFloatTimeDomainData(this.postAnalyserFloatArrayBuffer);
+            return this.postAnalyserFloatArrayBuffer;
+        }
+        return null;
+    }
+    GetWaveformByteData(analyserType) {
+        if (!this.preAnalyser || !this.postAnalyser) {
+            Debug.Error("Could not get byte waveform data because the pre analyser or post analyser has not been enabled.", [
+                "Call .EnablePreAnalyser() or .EnablePostAnalyser() before getting waveform data."
+            ]);
+            return null;
+        }
+        switch (analyserType) {
+            case "pre":
+                this.preAnalyser.getByteTimeDomainData(this.preAnalyserByteArrayBuffer);
+                return this.preAnalyserByteArrayBuffer;
+            case "post":
+                this.postAnalyser.getByteTimeDomainData(this.postAnalyserByteArrayBuffer);
+                return this.postAnalyserByteArrayBuffer;
+            default:
+                return null;
+        }
+    }
+    // Public getters and setters
+    get currentPlaybackTime() {
+        return (!this.isPlaying || !this.parentialAudioContext)
+            ? 0
+            : this.offsetAtStart + (this.parentialAudioContext.currentTime - this.startTime);
+    }
+    get duration() {
+        return this.data.audioBuffer.duration;
+    }
+    get volume() {
+        return this.gainNode?.gain.value ?? 0;
+    }
+    get stereoPanning() {
+        return this.stereoPannerNode?.pan.value ?? 1;
+    }
+    get formattedDuration() {
+        const date = new Date(this.duration * 1000);
+        return format(date, "mm:ss");
+    }
+    get sampleRate() {
+        return this.data.audioBuffer.sampleRate;
+    }
+    get numberOfChannels() {
+        return this.data.audioBuffer.numberOfChannels;
+    }
+    get byteLength() {
+        return this.data.arrayBuffer.byteLength;
+    }
+}

package/lib/dist/core/classes/AudioDevice.d.ts

@@ -0,0 +1,13 @@
+import { Master } from "./Master";
+export declare class AudioDevice {
+    deviceInfo: MediaDeviceInfo;
+    id: string;
+    timestamp: number;
+    masterChannel: Master;
+    masterChannels: Master[];
+    constructor(deviceInfo: MediaDeviceInfo);
+    GetMasterChannel(): Master;
+    SetMasterChannel(channel: Master): void;
+    CreateMasterChannel(): Master;
+}
+//# sourceMappingURL=AudioDevice.d.ts.map

package/lib/dist/core/classes/AudioDevice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioDevice.d.ts","sourceRoot":"","sources":["../../../src/core/classes/AudioDevice.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAKlC,qBAAa,WAAW;IAQD,UAAU,EAAE,eAAe;IANvC,EAAE,EAAE,MAAM,CAAQ;IAClB,SAAS,EAAE,MAAM,CAAc;IAE/B,aAAa,EAAE,MAAM,CAAgB;IACrC,cAAc,EAAE,MAAM,EAAE,CAAM;gBAElB,UAAU,EAAE,eAAe;IAEvC,gBAAgB,IAAI,MAAM;IAI1B,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAUvC,mBAAmB,IAAI,MAAM;CAOvC"}

package/lib/dist/core/classes/AudioDevice.js

@@ -0,0 +1,30 @@
+import { v4 } from "uuid";
+import { Master } from "./Master";
+import { ErrorCodes } from "../../console-codes";
+import { Debug } from "../../utilities/debugger";
+export class AudioDevice {
+    deviceInfo;
+    id = v4();
+    timestamp = Date.now();
+    masterChannel = new Master();
+    masterChannels = [];
+    constructor(deviceInfo) {
+        this.deviceInfo = deviceInfo;
+    }
+    GetMasterChannel() {
+        return this.masterChannel;
+    }
+    SetMasterChannel(channel) {
+        if (channel.id === this.masterChannel.id)
+            return Debug.Error("The provided master channel is the same as the current channel.", [
+                "Provide this method with a different master channel.",
+                `Received master channel ID ${channel.id}.`
+            ], ErrorCodes.SAME_MASTER_CHANNEL);
+        this.masterChannel = channel;
+    }
+    CreateMasterChannel() {
+        const master = new Master();
+        this.masterChannels.push(master);
+        return master;
+    }
+}