@fluex/fluexgl-dsp 0.4.6 → 0.4.8

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

@@ -0,0 +1,81 @@
+import { Effector } from "../../core/exports";
+import { AudioWorkletProcessorNames, StrictMode } from "../../typings";
+import { coerceFiniteNumber, createAudioWorkletNode, sendMessageToWorklet } from "../../utilities/helpers";
+
+export interface ReverbOptions {
+    roomSize: number;
+    damping: number;
+    mix: number;
+    stereoSpreadMs: number;
+    strictMode: StrictMode;
+}
+
+export enum ReverbMessageCommandId {
+    SetRoomSize,
+    SetDamping,
+    SetMix,
+    SetStereoSpreadMs
+}
+
+export class Reverb extends Effector {
+
+    public label: string | null = "Reverb";
+    public name: string = "Reverb";
+
+    public roomSize: number = 0.3;
+    public damping: number = 0.5;
+    public mix: number = 0.3;
+    public stereoSpreadMs: number = 0;
+    public strictMode: StrictMode = StrictMode.Disabled;
+
+    constructor(options?: Partial<ReverbOptions>) {
+        super();
+
+        this.roomSize = Math.max(0, coerceFiniteNumber(options?.roomSize ?? this.roomSize, this.roomSize));
+        this.damping = Math.max(0, coerceFiniteNumber(options?.damping ?? this.damping, this.damping));
+        this.mix = Math.max(0, coerceFiniteNumber(options?.mix ?? this.mix, this.mix));
+        this.stereoSpreadMs = Math.max(0, coerceFiniteNumber(options?.stereoSpreadMs ?? this.stereoSpreadMs, this.stereoSpreadMs));
+
+        const mode = coerceFiniteNumber(options?.strictMode ?? this.strictMode, this.strictMode);
+        this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
+    }
+
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
+        this.context = context;
+        this.audioWorkletNode = createAudioWorkletNode<ReverbOptions>(context, AudioWorkletProcessorNames.Reverb, this.returnOptionsAsObject());
+    }
+
+    public returnOptionsAsObject(): ReverbOptions {
+        return {
+            roomSize: this.roomSize,
+            damping: this.damping,
+            mix: this.mix,
+            stereoSpreadMs: this.stereoSpreadMs,
+            strictMode: this.strictMode
+        }
+    }
+
+    public setRoomSize(roomSize: number): boolean {
+        roomSize = Math.max(0, coerceFiniteNumber(roomSize ?? this.roomSize, this.roomSize));
+        this.roomSize = roomSize;
+        return sendMessageToWorklet<ReverbMessageCommandId, number>(this.audioWorkletNode, ReverbMessageCommandId.SetRoomSize, roomSize);
+    }
+
+    public setDamping(damping: number): boolean {
+        damping = Math.max(0, coerceFiniteNumber(damping ?? this.damping, this.damping));
+        this.damping = damping;
+        return sendMessageToWorklet<ReverbMessageCommandId, number>(this.audioWorkletNode, ReverbMessageCommandId.SetDamping, damping);
+    }
+
+    public setMix(mix: number): boolean {
+        mix = Math.max(0, coerceFiniteNumber(mix ?? this.mix, this.mix));
+        this.mix = mix;
+        return sendMessageToWorklet<ReverbMessageCommandId, number>(this.audioWorkletNode, ReverbMessageCommandId.SetMix, mix);
+    }
+
+    public setStereoSpreadMs(stereoSpreadMs: number) {
+        stereoSpreadMs = Math.max(0, coerceFiniteNumber(stereoSpreadMs ?? this.stereoSpreadMs, this.stereoSpreadMs));
+        this.stereoSpreadMs = stereoSpreadMs;
+        return sendMessageToWorklet<ReverbMessageCommandId, number>(this.audioWorkletNode, ReverbMessageCommandId.SetStereoSpreadMs, stereoSpreadMs);
+    }
+}

package/lib/src/effects/classes/clips/HardClip.ts

@@ -1,5 +1,5 @@
 import { Effector } from "../../../core/classes/Effector";
-import { CoerceFiniteNumber, CreateAudioWorkletNode, SendMessageToWorklet } from "../../../utilities/helpers";
+import { coerceFiniteNumber, createAudioWorkletNode, sendMessageToWorklet } from "../../../utilities/helpers";
 import { HardClipMessageCommandId, AudioWorkletProcessorNames, HardClipOptions, StrictMode } from "../../../typings";
 
 export class HardClip extends Effector {
@@ -11,22 +11,22 @@ export class HardClip extends Effector {
     public gain: number = 1;
     public strictMode: StrictMode = StrictMode.Disabled;
 
-    constructor({ drive, gain, strictMode }: Partial<HardClipOptions>) {
+    constructor(options?: HardClipOptions) {
         super();
 
-        this.drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
-        this.gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
+        this.drive = Math.max(0, coerceFiniteNumber(options?.drive ?? this.drive, this.drive));
+        this.gain = Math.max(0, coerceFiniteNumber(options?.gain ?? this.gain, this.gain));
 
-        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        const mode = coerceFiniteNumber(options?.strictMode ?? this.strictMode, this.strictMode);
         this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
     }
 
-    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
         this.context = context;
-        this.audioWorkletNode = CreateAudioWorkletNode<HardClipOptions>(context, AudioWorkletProcessorNames.HardClip, this.ReturnOptionsAsObject());
+        this.audioWorkletNode = createAudioWorkletNode<HardClipOptions>(context, AudioWorkletProcessorNames.HardClip, this.returnOptionsAsObject());
     }
 
-    public ReturnOptionsAsObject(): HardClipOptions {
+    public returnOptionsAsObject(): HardClipOptions {
         return {
             drive: this.drive,
             gain: this.gain,
@@ -34,15 +34,15 @@ export class HardClip extends Effector {
         }
     }
 
-     public SetDrive(drive: number): boolean {
-        drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
+     public setDrive(drive: number): boolean {
+        drive = Math.max(0, coerceFiniteNumber(drive, this.drive));
         this.drive = drive;
-        return SendMessageToWorklet<HardClipMessageCommandId, number>(this.audioWorkletNode, HardClipMessageCommandId.SetDrive, drive);
+        return sendMessageToWorklet<HardClipMessageCommandId, number>(this.audioWorkletNode, HardClipMessageCommandId.SetDrive, drive);
     }
 
-    public SetGain(gain: number): boolean{
-        gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
+    public setGain(gain: number): boolean{
+        gain = Math.max(0, coerceFiniteNumber(gain, this.gain));
         this.gain = gain;
-        return SendMessageToWorklet<HardClipMessageCommandId, number>(this.audioWorkletNode, HardClipMessageCommandId.SetGain, gain);
+        return sendMessageToWorklet<HardClipMessageCommandId, number>(this.audioWorkletNode, HardClipMessageCommandId.SetGain, gain);
     }
 }

package/lib/src/effects/classes/clips/SoftClip.ts

@@ -1,4 +1,4 @@
-import { CoerceFiniteNumber, CreateAudioWorkletNode, SendMessageToWorklet } from "../../../utilities/helpers";
+import { coerceFiniteNumber, createAudioWorkletNode, sendMessageToWorklet } from "../../../utilities/helpers";
 import { Effector } from "../../../core/classes/Effector";
 import { SoftClipOptions, AudioWorkletProcessorNames, SoftClipMessageCommandId, StrictMode } from "../../../typings";
 
@@ -14,23 +14,23 @@ export class SoftClip extends Effector {
     constructor({ drive, gain, strictMode }: Partial<SoftClipOptions> = {}) {
         super();
 
-        this.drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
-        this.gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
+        this.drive = Math.max(0, coerceFiniteNumber(drive, this.drive));
+        this.gain = Math.max(0, coerceFiniteNumber(gain, this.gain));
 
-        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        const mode = coerceFiniteNumber(strictMode, this.strictMode);
         this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
     }
 
-    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
     
         if(this.context === null) 
             this.context = context;
         
         if(this.audioWorkletNode === null) 
-            this.audioWorkletNode = CreateAudioWorkletNode<SoftClipOptions>(context, AudioWorkletProcessorNames.SoftClip, this.ReturnOptionsAsObject());
+            this.audioWorkletNode = createAudioWorkletNode<SoftClipOptions>(context, AudioWorkletProcessorNames.SoftClip, this.returnOptionsAsObject());
     }
 
-    public ReturnOptionsAsObject(): SoftClipOptions {
+    public returnOptionsAsObject(): SoftClipOptions {
         return {
             drive: this.drive,
             gain: this.gain,
@@ -38,15 +38,15 @@ export class SoftClip extends Effector {
         }
     }
 
-    public SetDrive(drive: number): boolean {
-        drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
+    public setDrive(drive: number): boolean {
+        drive = Math.max(0, coerceFiniteNumber(drive, this.drive));
         this.drive = drive;
-        return SendMessageToWorklet<SoftClipMessageCommandId, number>(this.audioWorkletNode, SoftClipMessageCommandId.SetDrive, drive);
+        return sendMessageToWorklet<SoftClipMessageCommandId, number>(this.audioWorkletNode, SoftClipMessageCommandId.SetDrive, drive);
     }
 
-    public SetGain(gain: number): boolean{
-        gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
+    public setGain(gain: number): boolean{
+        gain = Math.max(0, coerceFiniteNumber(gain, this.gain));
         this.gain = gain;
-        return SendMessageToWorklet<SoftClipMessageCommandId, number>(this.audioWorkletNode, SoftClipMessageCommandId.SetGain, gain);
+        return sendMessageToWorklet<SoftClipMessageCommandId, number>(this.audioWorkletNode, SoftClipMessageCommandId.SetGain, gain);
     }
 }

package/lib/src/effects/classes/filters/HighPassFilter.ts

@@ -0,0 +1,81 @@
+import { coerceFiniteNumber, createAudioWorkletNode, sendMessageToWorklet } from "../../../utilities/helpers";
+import { Effector } from "../../../core/classes/Effector";
+import { AudioWorkletProcessorNames, HighPassFilterMessageCommandId, HighPassFilterOptions, StrictMode } from "../../../typings";
+import { DEFAULT_SAMPLE_RATE } from "../../../utilities/constants";
+
+export class HighPassFilter extends Effector {
+
+    public name: string = "HighPassFilter";
+    public label: string | null = "HighPassFilter";
+
+    public cutoff: number = 1000;
+    public q: number = 0.7;
+    public strictMode: StrictMode = StrictMode.Disabled;
+    public maxFrequency: number = DEFAULT_SAMPLE_RATE * 0.5;
+
+    private contextSampleRate: number = DEFAULT_SAMPLE_RATE;
+
+    constructor({ cutoff, q, strictMode }: Partial<HighPassFilterOptions> = {}) {
+        super();
+
+        this.cutoff = coerceFiniteNumber(cutoff, this.cutoff);
+        this.q = coerceFiniteNumber(q, this.q);
+
+        const mode = coerceFiniteNumber(strictMode, this.strictMode);
+        this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
+        this.audioWorkletNode && this.registerMessageEventListener(this.audioWorkletNode);
+    }
+
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
+
+        this.context = context;
+        this.contextSampleRate = context.sampleRate;
+        this.audioWorkletNode = createAudioWorkletNode(context, AudioWorkletProcessorNames.HighPassFilter, this.returnOptionsAsObject());
+    }
+
+    public returnOptionsAsObject(): HighPassFilterOptions {
+        return {
+            cutoff: this.cutoff,
+            q: this.q,
+            strictMode: this.strictMode,
+            maxFrequency: this.maxFrequency
+        }
+    }
+
+    public setCutoff(cutoff: number = 1000): boolean {
+
+        if (!this.context) return false;
+
+        cutoff = coerceFiniteNumber(cutoff, this.cutoff);
+        cutoff = Math.min(this.maxFrequency, cutoff);
+
+        if (cutoff >= this.context.sampleRate)
+            cutoff = this.context.sampleRate;
+
+        this.cutoff = cutoff;
+        return sendMessageToWorklet<HighPassFilterMessageCommandId, number>(this.audioWorkletNode, HighPassFilterMessageCommandId.SetCutoff, cutoff);
+    }
+    
+    public setMaxFrequency(maxFrequency: number = this.maxFrequency) {
+
+        maxFrequency = coerceFiniteNumber(maxFrequency, this.maxFrequency);
+
+        if(maxFrequency > (this.contextSampleRate * 0.5))
+            throw new Error("Could not set the max frequency, because the value is over the sample rate.");
+
+        this.maxFrequency = maxFrequency;
+        return sendMessageToWorklet<HighPassFilterMessageCommandId.SetMaxFrequency, number>(this.audioWorkletNode, HighPassFilterMessageCommandId.SetMaxFrequency, maxFrequency);
+    }
+
+    public setQ(q: number = 0.7): boolean {
+
+        q = coerceFiniteNumber(q, this.q);
+        q = Math.max(0.0001, q);
+
+        if (q > 4)
+            q = 4;
+
+        this.q = q;
+        return sendMessageToWorklet<HighPassFilterMessageCommandId, number>(this.audioWorkletNode, HighPassFilterMessageCommandId.SetQ, q);
+    }
+}

package/lib/src/effects/classes/filters/LowPassFilter.ts

@@ -1,6 +1,6 @@
 import { Effector } from "../../../core/classes/Effector";
 
-import { CoerceFiniteNumber, SendMessageToWorklet, CreateAudioWorkletNode } from "../../../utilities/helpers";
+import { coerceFiniteNumber, sendMessageToWorklet, createAudioWorkletNode } from "../../../utilities/helpers";
 
 import { LowPassFilterOptions, LowPassFilterMessageCommandId, AudioWorkletProcessorNames, StrictMode } from "../../../typings";
 
@@ -17,22 +17,22 @@ export class LowPassFilter extends Effector {
     constructor({ cutoff, minFrequency, q, strictMode }: Partial<LowPassFilterOptions>) {
         super();
 
-        this.cutoff = CoerceFiniteNumber(cutoff, this.cutoff);
-        this.minFrequency = CoerceFiniteNumber(minFrequency, this.minFrequency);
-        this.q = CoerceFiniteNumber(q, this.q);
+        this.cutoff = coerceFiniteNumber(cutoff, this.cutoff);
+        this.minFrequency = coerceFiniteNumber(minFrequency, this.minFrequency);
+        this.q = coerceFiniteNumber(q, this.q);
 
-        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        const mode = coerceFiniteNumber(strictMode, this.strictMode);
         this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
     }
 
-    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
 
         this.context = context;
-        this.audioWorkletNode = CreateAudioWorkletNode(context, AudioWorkletProcessorNames.LowPassFilter, this.ReturnOptionsAsObject());
+        this.audioWorkletNode = createAudioWorkletNode(context, AudioWorkletProcessorNames.LowPassFilter, this.returnOptionsAsObject());
         this.audioWorkletNode && this.registerMessageEventListener(this.audioWorkletNode);
     }
 
-    public ReturnOptionsAsObject(): LowPassFilterOptions {
+    public returnOptionsAsObject(): LowPassFilterOptions {
         return {
             cutoff: this.cutoff,
             minFrequency: this.minFrequency,
@@ -41,40 +41,40 @@ export class LowPassFilter extends Effector {
         }
     }
 
-    public SetCutoff(cutoff: number = 1000): boolean {
+    public setCutoff(cutoff: number = 1000): boolean {
 
         if (!this.context) return false;
 
-        cutoff = CoerceFiniteNumber(cutoff, this.cutoff);
+        cutoff = coerceFiniteNumber(cutoff, this.cutoff);
         cutoff = Math.max(this.minFrequency, cutoff);
 
         if (cutoff >= this.context.sampleRate)
             cutoff = this.context.sampleRate;
 
         this.cutoff = cutoff;
-        return SendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetCutoff, cutoff);
+        return sendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetCutoff, cutoff);
     }
 
-    public SetMinFrequency(minFrequency: number = 10): boolean {
+    public setMinFrequency(minFrequency: number = 10): boolean {
 
-        minFrequency = CoerceFiniteNumber(minFrequency, this.minFrequency);
+        minFrequency = coerceFiniteNumber(minFrequency, this.minFrequency);
 
         if (minFrequency < 10)
             minFrequency = 10;
 
         this.minFrequency = minFrequency;
-        return SendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetMinFrequency, minFrequency);
+        return sendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetMinFrequency, minFrequency);
     }
 
-    public SetQ(q: number = 0.7): boolean {
+    public setQ(q: number = 0.7): boolean {
 
-        q = CoerceFiniteNumber(q, this.q);
+        q = coerceFiniteNumber(q, this.q);
         q = Math.max(0.0001, q);
 
         if(q > 4) 
             q = 4;
 
         this.q = q;
-        return SendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetQ, q);
+        return sendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetQ, q);
     }
 }

package/lib/src/effects/classes/filters/NotchFilter.ts

@@ -0,0 +1,81 @@
+import { AudioWorkletProcessorNames, NotchFilterMessageCommandId, NotchFilterOptions, StrictMode } from "../../../typings";
+import { Effector } from "../../../core/classes/Effector";
+import { DEFAULT_SAMPLE_RATE } from "../../../utilities/constants";
+import { coerceFiniteNumber, createAudioWorkletNode, sendMessageToWorklet } from "../../../utilities/helpers";
+
+export default class NotchFilter extends Effector {
+
+    public name: string = "NotchFilter";
+    public label: string | null = "NotchFilter";
+
+    public cutoff: number = 1000;
+    public minFrequency: number = 10;
+    public q: number = 0.7;
+
+    private contextSampleRate: number = DEFAULT_SAMPLE_RATE;
+    private strictMode: StrictMode = StrictMode.Disabled;
+
+    constructor({ cutoff, q, minFrequency, strictMode }: Partial<NotchFilterOptions> = {}) {
+        super();
+
+        this.cutoff = coerceFiniteNumber(cutoff, this.cutoff);
+        this.q = coerceFiniteNumber(q, this.q);
+
+        const mode = coerceFiniteNumber(strictMode, this.strictMode);
+        this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
+        this.audioWorkletNode && this.registerMessageEventListener(this.audioWorkletNode);
+    }
+
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
+
+        this.context = context;
+        this.contextSampleRate = context.sampleRate;
+        this.audioWorkletNode = createAudioWorkletNode(context, AudioWorkletProcessorNames.NotchFilter, this.returnOptionsAsObject());
+    }
+
+    public returnOptionsAsObject(): NotchFilterOptions {
+        return {
+            cutoff: this.cutoff,
+            q: this.q,
+            strictMode: this.strictMode,
+            minFrequency: this.minFrequency
+        }
+    }
+
+    public setCutoff(cutoff: number = 1000): boolean {
+
+        if (!this.context) return false;
+
+        cutoff = coerceFiniteNumber(cutoff, this.cutoff);
+        cutoff = Math.min(this.minFrequency, cutoff);
+
+        if (cutoff >= this.context.sampleRate)
+            cutoff = this.context.sampleRate;
+
+        this.cutoff = cutoff;
+        return sendMessageToWorklet<NotchFilterMessageCommandId, number>(this.audioWorkletNode, NotchFilterMessageCommandId.SetCutoff, cutoff);
+    }
+
+    public setMinFrequency(minFrequency: number = this.minFrequency) {
+
+        minFrequency = coerceFiniteNumber(minFrequency, this.minFrequency);
+
+        if(minFrequency < 10) 
+            minFrequency = 10;
+
+        this.minFrequency = minFrequency;
+        return sendMessageToWorklet<NotchFilterMessageCommandId.SetMinFrequency, number>(this.audioWorkletNode, NotchFilterMessageCommandId.SetMinFrequency, minFrequency);
+    }
+
+    public setQ(q: number = 0.7): boolean {
+
+        q = coerceFiniteNumber(q, this.q);
+        q = Math.max(0.0001, q);
+
+        if (q > 4)
+            q = 4;
+
+        this.q = q;
+        return sendMessageToWorklet<NotchFilterMessageCommandId, number>(this.audioWorkletNode, NotchFilterMessageCommandId.SetQ, q);
+    }
+}

package/lib/src/effects/exports.ts

@@ -7,6 +7,7 @@ export { Saturation } from "./classes/Saturation";
 export { StereoPanner } from "./classes/StereoPanner";
 export { SoftClip } from "./classes/clips/SoftClip";
 export { HardClip } from "./classes/clips/HardClip";
+export { Reverb, type ReverbOptions } from "./classes/Reverb";
 
 export { Compressor } from "./classes/compressors/Compressor";
 export { MultibandCompressor } from "./classes/compressors/MultibandCompressor";
@@ -16,10 +17,5 @@ export { MonoDelay } from "./classes/delays/MonoDelay";
 export { PingPongDelay } from "./classes/delays/PingPongDelay";
 export { StereoDelay } from "./classes/delays/StereoDelay";
 
-export { ChamberReverb } from "./classes/reverbs/ChamberReverb";
-export { ConvolverReverb } from "./classes/reverbs/ConvolverReverb";
-export { GenericReverb } from "./classes/reverbs/GenericReverb";
-export { HallReverb } from "./classes/reverbs/HallReverb";
-export { RoomReverb } from "./classes/reverbs/RoomReverb";
-
 export { LowPassFilter } from "./classes/filters/LowPassFilter";
+export { HighPassFilter } from "./classes/filters/HighPassFilter";

package/lib/src/index.ts

@@ -33,14 +33,11 @@ export {
     MonoDelay,
     PingPongDelay,
     StereoDelay,
-    ChamberReverb,
-    ConvolverReverb,
-    GenericReverb,
-    HallReverb,
-    RoomReverb,
     SoftClip,
     LowPassFilter,
-    HardClip
+    HardClip,
+    HighPassFilter,
+    Reverb, type ReverbOptions
 } from "./effects/exports";
 
 export {
@@ -54,19 +51,20 @@ export {
 } from "./core/exports";
 
 export {
-    InitializeDspPipeline,
-    ResolveAudioOutputDevices,
-    ResolveAudioInputDevices,
-    ResolveDefaultAudioInputDevice,
-    ResolveDefaultAudioOutputDevice,
-    LoadAudioSource,
-    LoadAudioSourceFromBlob,
-    LoadWorkletOnAudioDevice,
-    SendMessageToWorklet
+    initializeDspPipeline,
+    resolveAudioOutputDevices,
+    resolveAudioInputDevices,
+    resolveDefaultAudioInputDevice,
+    resolveDefaultAudioOutputDevice,
+    loadAudioSource,
+    loadAudioSourceFromBlob,
+    loadWorkletOnAudioDevice,
+    sendMessageToWorklet
 } from "./utilities/helpers";
 
 export {
-    SUPPORTED_FILE_TYPES
+    SUPPORTED_FILE_TYPES,
+    DEFAULT_SAMPLE_RATE
 } from "./utilities/constants";
 
 export {
@@ -106,5 +104,5 @@ export type {
     IncomingProcessorMessage,
     ProcessorData,
     EffectorEvents,
-    ArrayPosition
+    ArrayPosition,
 } from "./typings";

package/lib/src/typings.ts

@@ -4,7 +4,6 @@ export type AudioClipAnalyserProperty = "fftSize" | "minDecibels" | "maxDecibels
 export type IncomingMessageType = "message" | "error" | "warning" | "wasm-instantiated";
 export type ArrayPosition = "start" | "middle" | "end" | "one-after-start" | "one-before-end";
 
-
 export type AudioClipEvents = {
     [K in keyof AudioClipEventMap]: AudioClipEventMap[K][];
 }
@@ -19,6 +18,18 @@ export enum LowPassFilterMessageCommandId {
     SetQ
 }
 
+export enum HighPassFilterMessageCommandId {
+    SetCutoff,
+    SetMaxFrequency,
+    SetQ
+}
+
+export enum NotchFilterMessageCommandId {
+    SetCutoff,
+    SetMinFrequency,
+    SetQ
+}
+
 export enum ChorusMessageCommandId {
     SetBaseDelayMs,
     SetDepthMs,
@@ -108,8 +119,21 @@ export interface AudioClipOnProgressEvent {
     formatted: string;
 }
 
+export interface AudioClipOnInitializeEvent {
+    durationOfInitialization: number;
+    context: AudioContext | null;
+}
+
+export interface AudioClipOnPlayEvent {
+    timestamp: number;
+    audioBufferSourceNodes: AudioBufferSourceNode[];
+    context: AudioContext;
+}
+
 export interface AudioClipEventMap {
     "progress": (event: AudioClipOnProgressEvent) => void;
+    "initialize": (event: AudioClipOnInitializeEvent) => void;
+    "play": (event: AudioClipOnPlayEvent) => void;
 }
 
 export interface DspPipelineInitializationOptions {
@@ -139,6 +163,20 @@ export interface LowPassFilterOptions {
     strictMode: StrictMode;
 }
 
+export interface HighPassFilterOptions {
+    cutoff: number;
+    q: number;
+    maxFrequency: number;
+    strictMode: StrictMode;
+}
+
+export interface NotchFilterOptions {
+    cutoff: number;
+    q: number;
+    minFrequency: number;
+    strictMode: StrictMode;
+}
+
 export interface SoftClipOptions {
     drive: number;
     gain: number;

package/lib/src/utilities/constants.ts

@@ -6,4 +6,6 @@ export const SUPPORTED_FILE_TYPES: string[] = [
     "audio/wav",
     "audio/wave",
     "audio/webm"
-];
+];
+
+export const DEFAULT_SAMPLE_RATE: number = 44100;

package/lib/src/utilities/debugger.ts

@@ -4,7 +4,7 @@ import { DSP } from "../index";
 
 export namespace Debug {
 
-    export function Log(message: string, additionalDetails?: string[]) {
+    export function log(message: string, additionalDetails?: string[]) {
 
         if (!DSP.debugger.showInfo) return;
 
@@ -17,7 +17,7 @@ export namespace Debug {
         return console.log(outputString, "color: white;", "color: gray", "color: gray");
     }
 
-    export function Success(message: string, additionalDetails?: string[]) {
+    export function success(message: string, additionalDetails?: string[]) {
 
         if (!DSP.debugger.showInfo) return;
 
@@ -30,7 +30,7 @@ export namespace Debug {
         return console.log(outputString, "color: lime;", "color: white", "color: gray");
     }
 
-    export function Warn(message: string, additionalDetails?: string[], warningCode?: WarningCodes) {
+    export function warn(message: string, additionalDetails?: string[], warningCode?: WarningCodes) {
 
         if (!DSP.debugger.showWarnings) return;
 
@@ -43,7 +43,7 @@ export namespace Debug {
         return console.log(outputString, "color: gray", "color: yellow;", "color: white", "color: white; font-style: italic;");
     }
 
-    export function Error(message: string, additionalDetails?: string[], errorCode?: ErrorCodes) {
+    export function error(message: string, additionalDetails?: string[], errorCode?: ErrorCodes) {
 
         if (!DSP.debugger.showErrors) return;