@fluex/fluexgl-dsp 0.4.7 → 0.4.8

package/lib/dist/utilities/helpers.js

@@ -12,29 +12,29 @@ import { ErrorCodes, WarningCodes } from "../console-codes";
  * FluexGL DSP cannot be used without calling this function first.
  * @returns
  */
-export async function InitializeDspPipeline(options) {
-    Debug.Log("Attempting to initialize DSP pipeline...");
+export async function initializeDspPipeline(options) {
+    Debug.log("Attempting to initialize DSP pipeline...");
     const start = Date.now();
     let initialized = true;
     try {
         const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-        Debug.Log(`Found ${stream.getTracks().length} media stream tracks.`);
+        Debug.log(`Found ${stream.getTracks().length} media stream tracks.`);
         stream.getTracks().forEach(function (track) {
             track.stop();
         });
     }
     catch (err) {
         initialized = false;
-        Debug.Error("Permission to access media devices has not been granted.", [
+        Debug.error("Permission to access media devices has not been granted.", [
             "Make sure the user has granted FluentGL permission to access media devices."
         ], ErrorCodes.NO_CONTEXT_PERMISSION);
     }
     await LoadWebAssemblyModule(options.pathToWasm);
     const workletFileRequest = await fetch(options.pathToWorklet);
     const textContent = await workletFileRequest.text();
-    const blobUrl = ConstructProcessorWorklet(textContent);
+    const blobUrl = constructProcessorWorklet(textContent);
     const end = Date.now(), difference = end - start;
-    Debug.Success(`Succesfully initialized DSP pipeline within ${difference}ms.`);
+    Debug.success(`Succesfully initialized DSP pipeline within ${difference}ms.`);
     return {
         success: true,
         workletBlobUrl: blobUrl
@@ -44,7 +44,7 @@ export async function InitializeDspPipeline(options) {
  * Resolves a list of available audio output devices.
  * @returns
  */
-export async function ResolveAudioOutputDevices() {
+export async function resolveAudioOutputDevices() {
     const devices = await navigator.mediaDevices.enumerateDevices();
     const audioDevices = [];
     for (let device of devices)
@@ -55,7 +55,7 @@ export async function ResolveAudioOutputDevices() {
  * Resolves a list of available audio input devices.
  * @returns
  */
-export async function ResolveAudioInputDevices() {
+export async function resolveAudioInputDevices() {
     const devices = await navigator.mediaDevices.enumerateDevices();
     const audioDevices = [];
     for (let device of devices)
@@ -66,36 +66,36 @@ export async function ResolveAudioInputDevices() {
  * Resolves the default audio output device.
  * @returns
  */
-export async function ResolveDefaultAudioOutputDevice(init) {
-    Debug.Log("Attempting to resolve default audio output device...");
+export async function resolveDefaultAudioOutputDevice(init) {
+    Debug.log("Attempting to resolve default audio output device...");
     const audioDeviceInfos = [];
     const devices = await navigator.mediaDevices.enumerateDevices();
     for (let device of devices)
         (device.kind === "audiooutput" && device.deviceId == "default")
             && audioDeviceInfos.push(device);
-    devices.length === 0 && Debug.Warn("No default audio device found.", [], WarningCodes.NO_DEFAULT_AUDIO_DEVICE_FOUND);
+    devices.length === 0 && Debug.warn("No default audio device found.", [], WarningCodes.NO_DEFAULT_AUDIO_DEVICE_FOUND);
     const defaultAudioDevice = devices.length === 0 ? null : new AudioDevice(audioDeviceInfos[0]);
     if (!defaultAudioDevice)
         return null;
-    await LoadWorkletOnAudioDevice(defaultAudioDevice, init.workletBlobUrl);
+    await loadWorkletOnAudioDevice(defaultAudioDevice, init.workletBlobUrl);
     return defaultAudioDevice;
 }
 /**
  * Resolves the default audio input device.
  * @returns
  */
-export async function ResolveDefaultAudioInputDevice(init) {
-    Debug.Log("Attempting to resolve default audio output device...");
+export async function resolveDefaultAudioInputDevice(init) {
+    Debug.log("Attempting to resolve default audio output device...");
     const audioDeviceInfos = [];
     const devices = await navigator.mediaDevices.enumerateDevices();
     for (let device of devices)
         (device.kind === "audioinput" && device.deviceId == "default")
             && audioDeviceInfos.push(device);
-    devices.length === 0 && Debug.Warn("No default audio device found.", [], WarningCodes.NO_DEFAULT_AUDIO_DEVICE_FOUND);
+    devices.length === 0 && Debug.warn("No default audio device found.", [], WarningCodes.NO_DEFAULT_AUDIO_DEVICE_FOUND);
     const defaultAudioDevice = devices.length === 0 ? null : new AudioDevice(audioDeviceInfos[0]);
     if (!defaultAudioDevice)
         return null;
-    await LoadWorkletOnAudioDevice(defaultAudioDevice, init.workletBlobUrl);
+    await loadWorkletOnAudioDevice(defaultAudioDevice, init.workletBlobUrl);
     return defaultAudioDevice;
 }
 /**
@@ -104,19 +104,19 @@ export async function ResolveDefaultAudioInputDevice(init) {
  * @param options
  * @returns
  */
-export async function LoadAudioSource(path, options = { allowForeignFileTypes: false }) {
+export async function loadAudioSource(path, options = { allowForeignFileTypes: false }) {
     const extension = mime.getType(path);
     if (!extension && !options.allowForeignFileTypes) {
-        Debug.Error("The file type of the specified file could not be identified.", [
+        Debug.error("The file type of the specified file could not be identified.", [
             `Set allowForeignFileTypes to true in the properties to allow foreign or unknown file types.`
         ], ErrorCodes.NO_FILE_TYPE_FOUND);
         return null;
     }
     if (!SUPPORTED_FILE_TYPES.includes(extension))
-        Debug.Warn("The file type of the specified file is unknown and possibly unknown, but will be used anyways.");
+        Debug.warn("The file type of the specified file is unknown and possibly unknown, but will be used anyways.");
     const file = await fetch(path, { method: "get" });
     if (file.status !== 200) {
-        Debug.Error("The specified file could not be loaded.", [
+        Debug.error("The specified file could not be loaded.", [
             `Received status code: ${file.status}.`
         ], ErrorCodes.PATH_TO_FILE_NOT_FOUND);
         return null;
@@ -133,7 +133,7 @@ export async function LoadAudioSource(path, options = { allowForeignFileTypes: f
 /**
  * Loads an audio file from a blob.
  */
-export async function LoadAudioSourceFromBlob(blob) {
+export async function loadAudioSourceFromBlob(blob) {
     const tempContext = new AudioContext(), arrayBuffer = await blob.arrayBuffer();
     const audioBuffer = await tempContext.decodeAudioData(arrayBuffer);
     return {
@@ -142,27 +142,27 @@ export async function LoadAudioSourceFromBlob(blob) {
         audioBuffer, arrayBuffer
     };
 }
-export function ConstructProcessorWorklet(code) {
+export function constructProcessorWorklet(code) {
     const blob = new Blob([code], {
         type: "application/javascript"
     });
     return URL.createObjectURL(blob);
 }
-export async function LoadWorkletOnAudioDevice(audioDevice, workletBlobUrl) {
-    Debug.Log("Loading worklet modules on master channel...", [`Channel ID: ${audioDevice.id}`]);
+export async function loadWorkletOnAudioDevice(audioDevice, workletBlobUrl) {
+    Debug.log("Loading worklet modules on master channel...", [`Channel ID: ${audioDevice.id}`]);
     const context = audioDevice.context, start = Date.now();
     await context.audioWorklet.addModule(workletBlobUrl);
     const end = Date.now(), difference = end - start;
-    Debug.Success("Succesfully loaded audio processor worklets into master channel.", [
+    Debug.success("Succesfully loaded audio processor worklets into master channel.", [
         `Executed in ${difference}ms.`,
     ]);
     return true;
 }
-export function SendMessageToWorklet(node, commandId, data) {
+export function sendMessageToWorklet(node, commandId, data) {
     if (!node)
         return false;
     if (typeof data === "number" && !Number.isFinite(data)) {
-        Debug.Warn("Refusing to send non-finite numeric value to AudioWorkletNode.", [
+        Debug.warn("Refusing to send non-finite numeric value to AudioWorkletNode.", [
             `Command: ${String(commandId)}`,
             `Value: ${String(data)}`
         ]);
@@ -171,39 +171,25 @@ export function SendMessageToWorklet(node, commandId, data) {
     node.port.postMessage({ commandId, data });
     return true;
 }
-export function IsFiniteNumber(value) {
+export function isFiniteNumber(value) {
     return typeof value === "number" && Number.isFinite(value);
 }
-export function CoerceFiniteNumber(value, fallback) {
-    return IsFiniteNumber(value) ? value : fallback;
+export function coerceFiniteNumber(value, fallback) {
+    return isFiniteNumber(value) ? value : fallback;
 }
-export function CreateAudioWorkletNode(context, name, data) {
-    if (!compiledWebAssemblyModule) {
-        Debug.Error("Failed to create audio worklet node, because the web assembly module has not been compiled properly.", [
-            `Request audio worklet node: ${name}.`
-        ], ErrorCodes.WORKLET_NO_WASM_MODULE_INSTANTIATED);
-        return null;
-    }
-    try {
-        return new AudioWorkletNode(context, name, {
-            numberOfInputs: 1,
-            numberOfOutputs: 1,
-            outputChannelCount: [2],
-            parameterData: {
-                ...data,
-                sampleRate: context.sampleRate
-            },
-            processorOptions: {
-                module: compiledWebAssemblyModule
-            }
-        });
-    }
-    catch (err) {
-        Debug.Error("Failed to create audio worklet node.", [
-            `Request audio worklet node: ${name}.`,
-            "Make sure you called InitializeDspPipeline/InitializeDpsPipeline and loaded the worklet module on the same AudioContext.",
-            String(err)
-        ]);
-        return null;
-    }
+export function createAudioWorkletNode(context, name, data) {
+    if (!compiledWebAssemblyModule)
+        throw new Error("Coult not create audio worklet node. WebAssembly has not been compiled yet.");
+    return new AudioWorkletNode(context, name, {
+        numberOfInputs: 1,
+        numberOfOutputs: 1,
+        outputChannelCount: [2],
+        parameterData: {
+            ...data,
+            sampleRate: context.sampleRate
+        },
+        processorOptions: {
+            module: compiledWebAssemblyModule
+        }
+    });
 }

package/lib/dist/utilities/web-assembly.js

@@ -8,7 +8,7 @@ export async function LoadWebAssemblyModule(path) {
             compiledWebAssemblyModule = module;
             resolve(module);
         }).catch(function (error) {
-            Debug.Error("Failed to load WebAssembly module from path: " + path, [
+            Debug.error("Failed to load WebAssembly module from path: " + path, [
                 "Make sure the path is correct and the server is serving the .wasm file with the correct MIME type (application/wasm).",
                 "Error details: " + error.message
             ], ErrorCodes.WASM_COMPILATION_ERROR);

package/lib/src/console-codes.ts

@@ -19,7 +19,8 @@ export enum ErrorCodes {
     AUDIO_CLIP_ALREADY_ATTACHED = "ERROR:FLUEXGL-DSP@0018",
     AUDIO_CLIP_NOT_FOUND = "ERROR:FLUEXGL-DSP@0019",
     AUDIO_CLIP_PLAYER_NO_CONTEXT = "ERROR:FLUEXGL-DSP@0020",
-    PANNING_OUT_OF_RANGE = "ERROR:FLUEXGL-DSP@0021"
+    PANNING_OUT_OF_RANGE = "ERROR:FLUEXGL-DSP@0021",
+    PITCH_OUT_OF_RANGE = "ERROR:FLUEXGL-DSP@0022"
 }
 
 export enum WarningCodes {

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

@@ -1,7 +1,7 @@
 import { v4 } from "uuid";
 import { format } from "date-fns";
 
-import { AudioClipEventMap, AudioClipEvents, AudioSourceData } from "../../typings";
+import { AudioClipEventMap, AudioClipEvents, AudioClipOnInitializeEvent, AudioSourceData } from "../../typings";
 import { Debug } from "../../utilities/debugger";
 import { Channel } from "./Channel";
 import { AudioClipPlayer } from "./AudioClipPlayer";
@@ -9,7 +9,9 @@ import { Master } from "./Master";
 import { DSP } from "../../index";
 import { ErrorCodes } from "../../console-codes";
 
-type ProgressPayload = Parameters<AudioClipEventMap["progress"]>[0];
+type OnProgressCallbackFunction = AudioClipEventMap["progress"];
+type OnInitializeCallbackFunction = AudioClipEventMap["initialize"];
+type OnPlayCallbackFunction = AudioClipEventMap["play"];
 
 export class AudioClip {
 
@@ -21,6 +23,10 @@ export class AudioClip {
     public startTime: number = 0;
     public offsetAtStart: number = 0;
     public playbackRate: number = 1;
+    public pitch: number = 0;
+
+    public minPitchSemitones: number = -24;
+    public maxPitchSemitones: number = 24;
 
     public progressUpdateSpeed: number = 20;
 
@@ -32,11 +38,14 @@ export class AudioClip {
 
     private audioBufferSourceNodes: AudioBufferSourceNode[] = [];
     private maxAudioBufferSourceNodes: number = 1;
+    private audioClipPlayers: AudioClipPlayer[] = [];
 
     private progressInterval: number | null = 0;
 
     private events: AudioClipEvents = {
-        "progress": []
+        "progress": [],
+        "initialize": [],
+        "play": []
     }
 
     constructor(public data: AudioSourceData) { }
@@ -66,54 +75,98 @@ export class AudioClip {
         node?.disconnect();
     }
 
+    private getOutputNodes(): AudioNode[] {
+
+        const nodes: AudioNode[] = [];
+
+        for (const player of this.audioClipPlayers) {
+            if (player.outputGainNode && !nodes.includes(player.outputGainNode))
+                nodes.push(player.outputGainNode);
+        }
+
+        return nodes;
+    }
+
     private rebuildNodeChain(): boolean {
 
-        if (!this.context || !this.gainNode || !this.stereoPannerNode || !this.audioClipPlayer || !this.audioClipPlayer.outputGainNode) {
-            Debug.Error("Failed to rebuild node chain, because some of the core AudioNodes are missing.");
+        if (!this.context || !this.gainNode || !this.stereoPannerNode) {
+            Debug.error("Failed to rebuild node chain, because some of the core AudioNodes are missing.");
             return false;
         }
 
-        const destination = this.audioClipPlayer.outputGainNode;
+        const destinations = this.getOutputNodes();
+
+        if (destinations.length === 0) {
+            Debug.error("Failed to rebuild node chain, because no output destinations are available.");
+            return false;
+        }
 
         this.safeDisconnect(this.gainNode);
         this.safeDisconnect(this.stereoPannerNode);
 
         this.gainNode.connect(this.stereoPannerNode);
-        this.stereoPannerNode.connect(destination);
+        for (const destination of destinations) {
+            this.stereoPannerNode.connect(destination);
+        }
 
         this.connectSourcesTo(this.gainNode);
         return true;
     }
 
-    public Initialize(audioClipPlayer: AudioClipPlayer) {
+    public initialize(audioClipPlayer: AudioClipPlayer) {
+
+        const startTimestamp: number = Date.now(),
+            self: AudioClip = this;
 
-        if (!audioClipPlayer.context) return Debug.Error("Could not initialize AudioClip, because the AudioClipPlayer somehow has no audio context.", [
+        if (!audioClipPlayer.context) return Debug.error("Could not initialize AudioClip, because the AudioClipPlayer somehow has no audio context.", [
             `AudioClipPlayer id: ${audioClipPlayer.id}`,
             `AudioClip id: ${this.id}`
         ], ErrorCodes.AUDIO_CLIP_PLAYER_NO_CONTEXT);
 
+        if (this.context && this.context !== audioClipPlayer.context) {
+            return Debug.error("Could not initialize AudioClip, because the AudioClipPlayer does not share the same AudioContext.", [
+                `AudioClipPlayer id: ${audioClipPlayer.id}`,
+                `AudioClip id: ${this.id}`
+            ], ErrorCodes.AUDIO_CLIP_PLAYER_NO_CONTEXT);
+        }
+
         this.audioClipPlayer = audioClipPlayer;
         this.context = audioClipPlayer.context;
 
-        this.gainNode = new GainNode(this.context);
-        this.stereoPannerNode = new StereoPannerNode(this.context);
+        if (!this.gainNode) this.gainNode = new GainNode(this.context);
+        if (!this.stereoPannerNode) this.stereoPannerNode = new StereoPannerNode(this.context);
+
+        if (!this.audioClipPlayers.includes(audioClipPlayer))
+            this.audioClipPlayers.push(audioClipPlayer);
+
+        const endTimestamp: number = Date.now(),
+            difference: number = endTimestamp - startTimestamp;
+
+        this.events.initialize.forEach(function(cb: OnInitializeCallbackFunction) {
+            cb({
+                durationOfInitialization: difference,
+                context: self.context
+            });
+        });
+
+        this.rebuildNodeChain();
     }
 
-    public Play(timestamp?: number, offset?: number) {
+    public play(timestamp?: number, offset?: number) {
 
-        if (!this.context) return Debug.Error("Could not play audio clip, because context (AudioContext) is undefined.", [
-            "Make sure to attach this AudioClip to an AudioClipPlayer instance, before calling .Play on this AudioClip."
+        if (!this.context) return Debug.error("Could not play audio clip, because context (AudioContext) is undefined.", [
+            "Make sure to attach this AudioClip to an AudioClipPlayer instance, before calling .play on this AudioClip."
         ]);
 
-        const context = this.context;
-        const self = this;
+        const context = this.context,
+            self = this;
 
         if (this.audioBufferSourceNodes.length > this.maxAudioBufferSourceNodes - 1) return null;
 
         const bufferSource: AudioBufferSourceNode | null = this.createBufferSource();
 
         if (!bufferSource) {
-            Debug.Error("Something went wrong.");
+            Debug.error("Something went wrong.");
             return null;
         }
 
@@ -134,7 +187,7 @@ export class AudioClip {
 
             const formattedTime = format(date, "mm:ss");
 
-            const progressPayload: ProgressPayload = {
+            const progressPayload: Parameters<AudioClipEventMap["progress"]>[0] = {
                 current: parseFloat(current.toFixed(2)),
                 startTime: self.startTime,
                 offset: self.offsetAtStart,
@@ -142,7 +195,7 @@ export class AudioClip {
                 formatted: formattedTime
             }
 
-            self.events.progress.forEach(function (cb: (event: ProgressPayload) => void) {
+            self.events.progress.forEach(function (cb: OnProgressCallbackFunction) {
                 cb(progressPayload);
             });
         }, this.progressUpdateSpeed);
@@ -165,13 +218,21 @@ export class AudioClip {
 
         bufferSource.start(timestamp ?? this.startTime, actualOffset);
 
+        this.events.play.forEach(function(cb: OnPlayCallbackFunction) {
+            cb({
+                timestamp: Date.now(),
+                audioBufferSourceNodes: self.audioBufferSourceNodes,
+                context: context,
+            })
+        });
+
         return this;
     }
 
-    public Seek(seconds: number) {
+    public seek(seconds: number) {
 
-        if (!this.context) return Debug.Error("Could not seek because the context (AudioContext) of this AudioClip is undefined.", [
-            `Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .Seek on this AudioClip.`,
+        if (!this.context) return Debug.error("Could not seek because the context (AudioContext) of this AudioClip is undefined.", [
+            `Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .seek on this AudioClip.`,
             `AudioClip id: ${this.id}`
         ]);
 
@@ -184,13 +245,13 @@ export class AudioClip {
             return this;
         }
 
-        this.Stop();
-        this.Play(undefined, clamped);
+        this.stop();
+        this.play(undefined, clamped);
 
         return this;
     }
 
-    public Stop(): AudioClip | null {
+    public stop(): AudioClip | null {
 
         this.audioBufferSourceNodes.forEach(function (node: AudioBufferSourceNode) {
             node.stop();
@@ -208,23 +269,23 @@ export class AudioClip {
         return this;
     }
 
-    public SetVolume(volume: number): AudioClip {
+    public setVolume(volume: number): AudioClip {
 
-        if (!this.context) Debug.Error("Could not set volume because the context (AudioContext) of this AudioClip is undefined.", [
-            "Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .SetVolume() on this AudioClip.",
+        if (!this.context) Debug.error("Could not set volume because the context (AudioContext) of this AudioClip is undefined.", [
+            "Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .setVolume() on this AudioClip.",
         ], ErrorCodes.AUDIO_CLIP_PLAYER_NO_CONTEXT);
 
         this.gainNode?.gain.setValueAtTime(volume, this.context?.currentTime ?? 0);
         return this;
     }
 
-    public SetPanLevel(panLevel: number): AudioClip {
+    public setPanLevel(panLevel: number): AudioClip {
 
-        if (!this.context) Debug.Error("Could not set volume because the context (AudioContext) of this AudioClip is undefined.", [
-            "Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .SetPanLevel() on this AudioClip.",
+        if (!this.context) Debug.error("Could not set volume because the context (AudioContext) of this AudioClip is undefined.", [
+            "Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .setPanLevel() on this AudioClip.",
         ], ErrorCodes.AUDIO_CLIP_PLAYER_NO_CONTEXT);
 
-        if (panLevel < -1 || panLevel > 1) Debug.Error("Could not set the pan level because it is not between -1 and 1.", [
+        if (panLevel < -1 || panLevel > 1) Debug.error("Could not set the pan level because it is not between -1 and 1.", [
             `Given value: ${panLevel}.`,
             `Accepts a value between -1 and 1. Can be a floating number.`
         ], ErrorCodes.PANNING_OUT_OF_RANGE);
@@ -233,7 +294,7 @@ export class AudioClip {
         return this;
     }
 
-    public Loop(loop?: boolean): AudioClip {
+    public setLoop(loop?: boolean): AudioClip {
 
         this.audioBufferSourceNodes.forEach(function (node: AudioBufferSourceNode) {
             node.loop = loop ?? true;
@@ -243,10 +304,10 @@ export class AudioClip {
         return this;
     }
 
-    public SetMaxAudioBufferSourceNodes(value: number): AudioClip {
+    public setMaxAudioBufferSourceNodes(value: number): AudioClip {
 
         if (!DSP.overrideMaxAudioBufferNodes) {
-            Debug.Warn("Cannot set maxAudioBufferSourceNodes because the option to override the current maximum value is disabled.", [
+            Debug.warn("Cannot set maxAudioBufferSourceNodes because the option to override the current maximum value is disabled.", [
                 "Set overrideMaxAudioBufferNodes on DSP to true, in order to override the maximum audio buffer source nodes."
             ]);
             return this;
@@ -256,7 +317,7 @@ export class AudioClip {
         return this;
     }
 
-    public DisconnectAllAudioBufferSourceNodes(): boolean {
+    public disconnectAllAudioBufferSourceNodes(): boolean {
 
         if (!this.context) return false;
 
@@ -270,25 +331,25 @@ export class AudioClip {
         return true;
     }
 
-    public AddEventListener<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): () => void {
+    public addEventListener<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): () => void {
 
         this.events[event].push(cb);
-        return () => this.RemoveEventListener(event, cb);
+        return () => this.removeEventListener(event, cb);
     }
 
-    public Once<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): () => void {
+    public once<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): () => void {
 
         const wrapper = ((...args: unknown[]) => {
 
             // @ts-ignore
             cb(...args);
-            this.RemoveEventListener(event, wrapper as unknown as AudioClipEventMap[K]);
+            this.removeEventListener(event, wrapper as unknown as AudioClipEventMap[K]);
         }) as unknown as AudioClipEventMap[K];
 
-        return this.AddEventListener(event, wrapper);
+        return this.addEventListener(event, wrapper);
     }
 
-    public RemoveEventListener<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): AudioClip {
+    public removeEventListener<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): AudioClip {
 
         const arr = this.events[event];
 
@@ -301,7 +362,7 @@ export class AudioClip {
         return this;
     }
 
-    public ClearEventListeners(event?: keyof AudioClipEventMap): AudioClip {
+    public clearEventListeners(event?: keyof AudioClipEventMap): AudioClip {
 
         if (event) {
             this.events[event].length = 0;
@@ -312,47 +373,82 @@ export class AudioClip {
         return this;
     }
 
-    public GetChannelData(channel: number = 0): Float32Array {
+    public getChannelData(channel: number = 0): Float32Array {
         return this.data.audioBuffer.getChannelData(channel);
     }
 
-    public Send(channel: Channel | Master) {
+    public send(channel: Channel | Master) {
 
-        if (!channel.audioClipPlayer) return Debug.Error("Could not send AudioClip signal to channel, because the channel's AudioClipPlayer is undefined.", [
+        if (!channel.audioClipPlayer) return Debug.error("Could not send AudioClip signal to channel, because the channel's AudioClipPlayer is undefined.", [
             "Make sure to initialize the Channel.",
             `Channel id: ${channel.id}.`,
             `AudioClip id: ${this.id}.`
         ]);
 
-        channel.audioClipPlayer.AttachAudioClip(this);
+        channel.audioClipPlayer.attachAudioClip(this);
     }
 
-    public Unsend(channel: Channel | Master) {
+    public unsend(channel: Channel | Master) {
 
-        if (!channel.audioClipPlayer) return Debug.Error("Could not unsend AudioClip signal to channel, because the channel's AudioClipPlayer is undefined.", [
+        if (!channel.audioClipPlayer) return Debug.error("Could not unsend AudioClip signal to channel, because the channel's AudioClipPlayer is undefined.", [
             "Make sure to initialize the Channel.",
             `Channel id: ${channel.id}.`,
             `AudioClip id: ${this.id}.`
         ]);
 
-        channel.audioClipPlayer.DetachAudioClip(this);
+        channel.audioClipPlayer.detachAudioClip(this);
     }
 
-    public SetPlaybackRateInSemitones(semitones: number): AudioClip {
+    public detachFromAudioClipPlayer(audioClipPlayer: AudioClipPlayer): void {
 
-        if(!this.context) 
-            throw new Error("Could not set playback rate because the AudioContext is not defined.");
+        const idx = this.audioClipPlayers.indexOf(audioClipPlayer);
 
-        const calculatedPlaybackRate: number = Math.pow(2, semitones / 12);
-    
-        for(const buffer of this.audioBufferSourceNodes) {
-            buffer.playbackRate.setValueAtTime(calculatedPlaybackRate, this.context?.currentTime);
+        if (idx === -1) return;
+
+        this.audioClipPlayers.splice(idx, 1);
+
+        if (this.audioClipPlayer === audioClipPlayer) {
+            this.audioClipPlayer = this.audioClipPlayers[0] ?? null;
+        }
+
+        if (this.audioClipPlayers.length === 0) {
+            this.stop();
+            return;
         }
 
+        this.rebuildNodeChain();
+    }
+
+    public setPitch(semitones: number): AudioClip {
+
+        if (!this.context) Debug.error("Could not set pitch because the context (AudioContext) of this AudioClip is undefined.", [
+            "Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .setPitch() on this AudioClip.",
+        ], ErrorCodes.AUDIO_CLIP_PLAYER_NO_CONTEXT);
+
+        if (semitones < this.minPitchSemitones || semitones > this.maxPitchSemitones) Debug.error("Could not set the pitch because it is not within the allowed semitone range.", [
+            `Given value: ${semitones}.`,
+            `Accepts a value between ${this.minPitchSemitones} and ${this.maxPitchSemitones} semitones.`
+        ], ErrorCodes.PITCH_OUT_OF_RANGE);
+
+        const calculatedPlaybackRate: number = Math.pow(2, semitones / 12);
+
+        for (const buffer of this.audioBufferSourceNodes) 
+            buffer.playbackRate.setValueAtTime(calculatedPlaybackRate, this.context?.currentTime ?? 0);
+
+        this.pitch = semitones;
         this.playbackRate = calculatedPlaybackRate;
         return this;
     }
 
+    public resetPitch(): AudioClip {
+        return this.setPitch(0);
+    }
+
+    /** @deprecated Use {@link setPitch} instead. */
+    public setPlaybackRateInSemitones(semitones: number): AudioClip {
+        return this.setPitch(semitones);
+    }
+
     public get currentPlaybackTime(): number {
         return (!this.isPlaying || !this.context)
             ? 0
@@ -372,9 +468,7 @@ export class AudioClip {
     }
 
     public get formattedDuration(): string {
-
         const date = new Date(this.duration * 1000);
-
         return format(date, "mm:ss");
     }
 
@@ -389,4 +483,4 @@ export class AudioClip {
     public get byteLength(): number {
         return this.data.arrayBuffer.byteLength;
     }
-}
+}