streamify-audio 2.0.0

package/src/discord/Queue.js

@@ -0,0 +1,129 @@
+class Queue {
+    constructor(options = {}) {
+        this.tracks = [];
+        this.previous = [];
+        this.current = null;
+        this.maxPreviousTracks = options.maxPreviousTracks || 25;
+        this.repeatMode = 'off';
+    }
+
+    add(track, position) {
+        if (position !== undefined && position >= 0 && position < this.tracks.length) {
+            this.tracks.splice(position, 0, track);
+        } else {
+            this.tracks.push(track);
+        }
+        return this.tracks.length;
+    }
+
+    addMany(tracks, position) {
+        if (position !== undefined && position >= 0 && position < this.tracks.length) {
+            this.tracks.splice(position, 0, ...tracks);
+        } else {
+            this.tracks.push(...tracks);
+        }
+        return this.tracks.length;
+    }
+
+    remove(index) {
+        if (index < 0 || index >= this.tracks.length) {
+            return null;
+        }
+        return this.tracks.splice(index, 1)[0];
+    }
+
+    clear() {
+        const cleared = this.tracks.length;
+        this.tracks = [];
+        return cleared;
+    }
+
+    shuffle() {
+        for (let i = this.tracks.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [this.tracks[i], this.tracks[j]] = [this.tracks[j], this.tracks[i]];
+        }
+        return this.tracks.length;
+    }
+
+    move(from, to) {
+        if (from < 0 || from >= this.tracks.length) return false;
+        if (to < 0 || to >= this.tracks.length) return false;
+
+        const track = this.tracks.splice(from, 1)[0];
+        this.tracks.splice(to, 0, track);
+        return true;
+    }
+
+    shift() {
+        if (this.current) {
+            this.previous.unshift(this.current);
+            if (this.previous.length > this.maxPreviousTracks) {
+                this.previous.pop();
+            }
+        }
+
+        if (this.repeatMode === 'track' && this.current) {
+            return this.current;
+        }
+
+        if (this.repeatMode === 'queue' && this.tracks.length === 0 && this.previous.length > 0) {
+            this.tracks = [...this.previous].reverse();
+            this.previous = [];
+        }
+
+        this.current = this.tracks.shift() || null;
+        return this.current;
+    }
+
+    unshift() {
+        if (this.previous.length === 0) {
+            return null;
+        }
+
+        if (this.current) {
+            this.tracks.unshift(this.current);
+        }
+
+        this.current = this.previous.shift();
+        return this.current;
+    }
+
+    setCurrent(track) {
+        this.current = track;
+    }
+
+    setRepeatMode(mode) {
+        if (['off', 'track', 'queue'].includes(mode)) {
+            this.repeatMode = mode;
+            return true;
+        }
+        return false;
+    }
+
+    get size() {
+        return this.tracks.length;
+    }
+
+    get isEmpty() {
+        return this.tracks.length === 0;
+    }
+
+    get totalDuration() {
+        let duration = this.current?.duration || 0;
+        duration += this.tracks.reduce((sum, track) => sum + (track.duration || 0), 0);
+        return duration;
+    }
+
+    toJSON() {
+        return {
+            current: this.current,
+            tracks: this.tracks,
+            previous: this.previous,
+            repeatMode: this.repeatMode,
+            size: this.size
+        };
+    }
+}
+
+module.exports = Queue;

package/src/discord/Stream.js

@@ -0,0 +1,252 @@
+const { spawn } = require('child_process');
+const { createAudioResource, StreamType } = require('@discordjs/voice');
+const { buildFfmpegArgs } = require('../filters/ffmpeg');
+const log = require('../utils/logger');
+
+class StreamController {
+    constructor(track, filters, config) {
+        this.track = track;
+        this.filters = filters || {};
+        this.config = config;
+        this.ytdlp = null;
+        this.ffmpeg = null;
+        this.resource = null;
+        this.destroyed = false;
+        this.startTime = null;
+        this.bytesReceived = 0;
+    }
+
+    async create(seekPosition = 0) {
+        if (this.destroyed) {
+            throw new Error('Stream already destroyed');
+        }
+
+        if (this.resource) {
+            return this.resource;
+        }
+
+        this.startTime = Date.now();
+        const videoId = this.track._resolvedId || this.track.id;
+        const source = this.track.source || 'youtube';
+
+        log.info('STREAM', `Creating stream for ${videoId} (${source})`);
+
+        let url;
+        if (source === 'soundcloud') {
+            url = this.track.uri || `https://api.soundcloud.com/tracks/${videoId}/stream`;
+        } else {
+            url = `https://www.youtube.com/watch?v=${videoId}`;
+        }
+
+        const isYouTube = source === 'youtube' || source === 'spotify';
+        const ytdlpArgs = [
+            '-f', isYouTube ? '18/22/bestaudio[ext=webm]/bestaudio/best' : 'bestaudio/best',
+            '--no-playlist',
+            '--no-check-certificates',
+            '--no-warnings',
+            '--retries', '3',
+            '--fragment-retries', '3',
+            '-o', '-',
+            url
+        ];
+
+        if (isYouTube) {
+            ytdlpArgs.push('--extractor-args', 'youtube:player_client=web_creator');
+        }
+
+        if (seekPosition > 0) {
+            const seekSeconds = Math.floor(seekPosition / 1000);
+            ytdlpArgs.push('--download-sections', `*${seekSeconds}-`);
+            log.info('STREAM', `Seeking to ${seekSeconds}s`);
+        }
+
+        if (this.config.cookiesPath) {
+            ytdlpArgs.unshift('--cookies', this.config.cookiesPath);
+        }
+
+        if (this.config.sponsorblock?.enabled !== false && isYouTube) {
+            const categories = this.config.sponsorblock?.categories || ['sponsor', 'selfpromo'];
+            ytdlpArgs.push('--sponsorblock-remove', categories.join(','));
+        }
+
+        this.ytdlp = spawn(this.config.ytdlpPath, ytdlpArgs, {
+            env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
+        });
+
+        this._spawnTime = Date.now() - this.startTime;
+
+        const ffmpegFilters = { ...this.filters };
+        if (seekPosition > 0) {
+            ffmpegFilters.start = seekPosition / 1000;
+        }
+
+        const ffmpegArgs = buildFfmpegArgs(ffmpegFilters, this.config);
+        this.ffmpeg = spawn(this.config.ffmpegPath, ffmpegArgs);
+
+        this._firstDataTime = null;
+        this.ytdlp.stdout.on('data', (chunk) => {
+            if (!this._firstDataTime) {
+                this._firstDataTime = Date.now() - this.startTime;
+            }
+            this.bytesReceived += chunk.length;
+        });
+
+        this.ytdlp.stdout.pipe(this.ffmpeg.stdin);
+
+        let ytdlpError = '';
+        this.ytdlp.stderr.on('data', (data) => {
+            if (this.destroyed) return;
+            const msg = data.toString();
+            ytdlpError += msg;
+            if (msg.includes('ERROR:') && !msg.includes('Retrying') && !msg.includes('Broken pipe')) {
+                log.error('YTDLP', msg.trim());
+            } else if (!msg.includes('[download]') && !msg.includes('ETA') && !msg.includes('[youtube]') && !msg.includes('Retrying fragment') && !msg.includes('Got error')) {
+                log.debug('YTDLP', msg.trim());
+            }
+        });
+
+        this.ffmpeg.stderr.on('data', (data) => {
+            if (this.destroyed) return;
+            const msg = data.toString();
+            if ((msg.includes('Error') || msg.includes('error')) && !msg.includes('Connection reset') && !msg.includes('Broken pipe')) {
+                log.error('FFMPEG', msg.trim());
+            }
+        });
+
+        this.ytdlp.on('close', (code) => {
+            if (code !== 0 && code !== null && !this.destroyed) {
+                log.error('STREAM', `yt-dlp failed (code: ${code}) for ${videoId}`);
+                if (ytdlpError) {
+                    log.error('STREAM', `yt-dlp stderr: ${ytdlpError.slice(-500)}`);
+                }
+            }
+            if (this.ffmpeg && !this.ffmpeg.killed) {
+                this.ffmpeg.stdin.end();
+            }
+        });
+
+        this.ytdlp.on('error', (error) => {
+            if (error.code !== 'EPIPE' && !this.destroyed) {
+                log.error('STREAM', `yt-dlp spawn error: ${error.message}`);
+            }
+        });
+
+        this.ffmpeg.on('error', (error) => {
+            if (error.code !== 'EPIPE' && !this.destroyed) {
+                log.error('STREAM', `ffmpeg spawn error: ${error.message}`);
+            }
+        });
+
+        this.ytdlp.stdout.on('error', (error) => {
+            if (error.code !== 'EPIPE' && !this.destroyed) {
+                log.debug('STREAM', `yt-dlp stdout error: ${error.message}`);
+            }
+        });
+
+        this.ffmpeg.stdin.on('error', (error) => {
+            if (error.code !== 'EPIPE' && !this.destroyed) {
+                log.debug('STREAM', `ffmpeg stdin error: ${error.message}`);
+            }
+        });
+
+        this.ffmpeg.stdout.on('error', (error) => {
+            if (error.code !== 'EPIPE' && !this.destroyed) {
+                log.debug('STREAM', `ffmpeg stdout error: ${error.message}`);
+            }
+        });
+
+        await this._waitForData();
+
+        this.resource = createAudioResource(this.ffmpeg.stdout, {
+            inputType: StreamType.OggOpus,
+            inlineVolume: false
+        });
+
+        const elapsed = Date.now() - this.startTime;
+        const firstData = this._firstDataTime || elapsed;
+        log.info('STREAM', `Ready ${elapsed}ms | First byte: ${firstData}ms | Buffered: ${this.bytesReceived}`);
+
+        return this.resource;
+    }
+
+    _waitForData() {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                log.warn('STREAM', `Timeout waiting for data, proceeding anyway (received: ${this.bytesReceived})`);
+                resolve();
+            }, 15000);
+
+            let resolved = false;
+
+            const checkInterval = setInterval(() => {
+                if (resolved) {
+                    clearInterval(checkInterval);
+                    return;
+                }
+                if (this.bytesReceived > 0) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    clearInterval(checkInterval);
+                    resolve();
+                }
+            }, 50);
+
+            this.ffmpeg.on('close', () => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    clearInterval(checkInterval);
+                    reject(new Error('ffmpeg closed before producing data'));
+                }
+            });
+
+            this.ytdlp.on('close', (code) => {
+                if (!resolved && code !== 0) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    clearInterval(checkInterval);
+                    reject(new Error(`yt-dlp failed with code ${code}`));
+                }
+            });
+        });
+    }
+
+    destroy() {
+        if (this.destroyed) return;
+        this.destroyed = true;
+
+        const elapsed = this.startTime ? Date.now() - this.startTime : 0;
+        log.info('STREAM', `Destroying stream | Duration: ${elapsed}ms | Received: ${this.bytesReceived}`);
+
+        try {
+            if (this.ytdlp && this.ffmpeg) {
+                this.ytdlp.stdout.unpipe(this.ffmpeg.stdin);
+            }
+        } catch (e) {}
+
+        if (this.ytdlp && !this.ytdlp.killed) {
+            try {
+                this.ytdlp.stdout.destroy();
+                this.ytdlp.kill('SIGKILL');
+            } catch (e) {}
+        }
+
+        if (this.ffmpeg && !this.ffmpeg.killed) {
+            try {
+                this.ffmpeg.stdin.destroy();
+                this.ffmpeg.stdout.destroy();
+                this.ffmpeg.kill('SIGKILL');
+            } catch (e) {}
+        }
+
+        this.ytdlp = null;
+        this.ffmpeg = null;
+        this.resource = null;
+    }
+}
+
+function createStream(track, filters, config) {
+    return new StreamController(track, filters, config);
+}
+
+module.exports = { createStream, StreamController };

package/src/filters/ffmpeg.js

@@ -0,0 +1,270 @@
+const EQ_BANDS = [25, 40, 63, 100, 160, 250, 400, 630, 1000, 1600, 2500, 4000, 6300, 10000, 16000];
+
+const PRESETS = {
+    flat: Array(15).fill(0),
+    rock: [0.3, 0.25, 0.2, 0.1, -0.05, -0.1, 0.1, 0.25, 0.35, 0.4, 0.4, 0.35, 0.3, 0.25, 0.2],
+    pop: [0.2, 0.35, 0.4, 0.35, 0.2, 0, -0.1, -0.1, 0, 0.15, 0.2, 0.25, 0.3, 0.35, 0.35],
+    jazz: [0.2, 0.15, 0.1, 0, -0.1, -0.1, 0, 0.1, 0.2, 0.25, 0.25, 0.2, 0.15, 0.1, 0.1],
+    classical: [0.3, 0.25, 0.2, 0.15, 0.1, 0, -0.1, -0.1, 0, 0.1, 0.2, 0.25, 0.3, 0.35, 0.35],
+    electronic: [0.4, 0.35, 0.25, 0, -0.1, -0.15, 0, 0.1, 0.2, 0.3, 0.35, 0.4, 0.35, 0.3, 0.25],
+    hiphop: [0.4, 0.35, 0.3, 0.2, 0.1, 0, -0.1, -0.1, 0, 0.15, 0.2, 0.15, 0.1, 0.1, 0.15],
+    acoustic: [0.3, 0.25, 0.2, 0.15, 0.1, 0.1, 0.15, 0.2, 0.2, 0.15, 0.1, 0.1, 0.15, 0.2, 0.25],
+    rnb: [0.35, 0.4, 0.35, 0.2, 0.05, -0.05, 0, 0.1, 0.15, 0.15, 0.1, 0.05, 0.1, 0.15, 0.2],
+    latin: [0.25, 0.2, 0.1, 0, 0, 0, 0, 0.1, 0.2, 0.3, 0.35, 0.35, 0.3, 0.25, 0.2],
+    loudness: [0.4, 0.35, 0.25, 0.1, 0, -0.1, -0.1, 0, 0.1, 0.2, 0.3, 0.35, 0.4, 0.45, 0.45],
+    piano: [0.2, 0.15, 0.1, 0.05, 0, 0.05, 0.1, 0.15, 0.2, 0.2, 0.15, 0.1, 0.1, 0.15, 0.2],
+    vocal: [-0.2, -0.15, -0.1, 0, 0.2, 0.35, 0.4, 0.4, 0.35, 0.2, 0, -0.1, -0.15, -0.15, -0.1],
+    bass_heavy: [0.5, 0.45, 0.4, 0.3, 0.2, 0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    treble_heavy: [0, 0, 0, 0, 0, 0, 0, 0, 0.1, 0.2, 0.3, 0.4, 0.45, 0.5, 0.5]
+};
+
+function buildEqualizer(bands) {
+    if (!bands || !Array.isArray(bands)) return null;
+
+    const eqParts = [];
+    for (let i = 0; i < Math.min(bands.length, 15); i++) {
+        const gain = bands[i];
+        if (typeof gain === 'number' && gain !== 0) {
+            const clampedGain = Math.max(-0.25, Math.min(1.0, gain));
+            const freq = EQ_BANDS[i];
+            const width = freq < 1000 ? freq * 0.5 : freq * 0.3;
+            eqParts.push(`equalizer=f=${freq}:width_type=h:width=${width}:g=${clampedGain * 12}`);
+        }
+    }
+
+    return eqParts.length > 0 ? eqParts.join(',') : null;
+}
+
+function buildFfmpegArgs(filters = {}, config = {}) {
+    const args = ['-i', 'pipe:0', '-vn'];
+    const audioFilters = [];
+
+    if (filters.equalizer && Array.isArray(filters.equalizer)) {
+        const eq = buildEqualizer(filters.equalizer);
+        if (eq) audioFilters.push(eq);
+    }
+
+    if (filters.preset && PRESETS[filters.preset]) {
+        const eq = buildEqualizer(PRESETS[filters.preset]);
+        if (eq) audioFilters.push(eq);
+    }
+
+    const bass = parseFloat(filters.bass);
+    if (!isNaN(bass) && bass !== 0) {
+        const clampedBass = Math.max(-20, Math.min(20, bass));
+        audioFilters.push(`bass=g=${clampedBass}`);
+    }
+
+    const treble = parseFloat(filters.treble);
+    if (!isNaN(treble) && treble !== 0) {
+        const clampedTreble = Math.max(-20, Math.min(20, treble));
+        audioFilters.push(`treble=g=${clampedTreble}`);
+    }
+
+    const speed = parseFloat(filters.speed);
+    if (!isNaN(speed) && speed !== 1) {
+        const clampedSpeed = Math.max(0.5, Math.min(2.0, speed));
+        if (clampedSpeed < 1) {
+            audioFilters.push(`atempo=${clampedSpeed}`);
+        } else if (clampedSpeed <= 2) {
+            audioFilters.push(`atempo=${clampedSpeed}`);
+        }
+    }
+
+    const pitch = parseFloat(filters.pitch);
+    if (!isNaN(pitch) && pitch !== 1) {
+        const clampedPitch = Math.max(0.5, Math.min(2.0, pitch));
+        audioFilters.push(`asetrate=48000*${clampedPitch},aresample=48000`);
+    }
+
+    const volume = parseFloat(filters.volume);
+    if (!isNaN(volume) && volume !== 100) {
+        const clampedVolume = Math.max(0, Math.min(200, volume));
+        audioFilters.push(`volume=${clampedVolume / 100}`);
+    }
+
+    if (filters.tremolo) {
+        const freq = parseFloat(filters.tremolo.frequency) || 4;
+        const depth = parseFloat(filters.tremolo.depth) || 0.5;
+        const clampedFreq = Math.max(0.1, Math.min(20, freq));
+        const clampedDepth = Math.max(0, Math.min(1, depth));
+        audioFilters.push(`tremolo=f=${clampedFreq}:d=${clampedDepth}`);
+    }
+
+    if (filters.vibrato) {
+        const freq = parseFloat(filters.vibrato.frequency) || 4;
+        const depth = parseFloat(filters.vibrato.depth) || 0.5;
+        const clampedFreq = Math.max(0.1, Math.min(14, freq));
+        const clampedDepth = Math.max(0, Math.min(1, depth));
+        audioFilters.push(`vibrato=f=${clampedFreq}:d=${clampedDepth}`);
+    }
+
+    if (filters.rotation) {
+        const rotSpeed = parseFloat(filters.rotation.speed) || 0.125;
+        const clampedSpeed = Math.max(0.01, Math.min(5, rotSpeed));
+        audioFilters.push(`apulsator=mode=sine:hz=${clampedSpeed}:width=1`);
+    }
+
+    if (filters.lowpass) {
+        const freq = parseFloat(filters.lowpass);
+        if (!isNaN(freq)) {
+            const clampedFreq = Math.max(100, Math.min(20000, freq));
+            audioFilters.push(`lowpass=f=${clampedFreq}`);
+        }
+    }
+
+    if (filters.highpass) {
+        const freq = parseFloat(filters.highpass);
+        if (!isNaN(freq)) {
+            const clampedFreq = Math.max(20, Math.min(10000, freq));
+            audioFilters.push(`highpass=f=${clampedFreq}`);
+        }
+    }
+
+    if (filters.bandpass) {
+        const freq = parseFloat(filters.bandpass.frequency) || 1000;
+        const width = parseFloat(filters.bandpass.width) || 200;
+        audioFilters.push(`bandpass=f=${freq}:width_type=h:width=${width}`);
+    }
+
+    if (filters.bandreject || filters.notch) {
+        const opt = filters.bandreject || filters.notch;
+        const freq = parseFloat(opt.frequency) || 1000;
+        const width = parseFloat(opt.width) || 200;
+        audioFilters.push(`bandreject=f=${freq}:width_type=h:width=${width}`);
+    }
+
+    if (filters.lowshelf) {
+        const freq = parseFloat(filters.lowshelf.frequency) || 200;
+        const gain = parseFloat(filters.lowshelf.gain) || 0;
+        audioFilters.push(`lowshelf=f=${freq}:g=${gain}`);
+    }
+
+    if (filters.highshelf) {
+        const freq = parseFloat(filters.highshelf.frequency) || 3000;
+        const gain = parseFloat(filters.highshelf.gain) || 0;
+        audioFilters.push(`highshelf=f=${freq}:g=${gain}`);
+    }
+
+    if (filters.peaking) {
+        const freq = parseFloat(filters.peaking.frequency) || 1000;
+        const gain = parseFloat(filters.peaking.gain) || 0;
+        const q = parseFloat(filters.peaking.q) || 1;
+        audioFilters.push(`equalizer=f=${freq}:width_type=q:width=${q}:g=${gain}`);
+    }
+
+    if (filters.karaoke === 'true' || filters.karaoke === true) {
+        audioFilters.push('pan=stereo|c0=c0-c1|c1=c1-c0');
+    }
+
+    if (filters.mono === 'true' || filters.mono === true) {
+        audioFilters.push('pan=mono|c0=0.5*c0+0.5*c1');
+    }
+
+    if (filters.surround === 'true' || filters.surround === true) {
+        audioFilters.push('surround');
+    }
+
+    if (filters.flanger === 'true' || filters.flanger === true) {
+        audioFilters.push('flanger');
+    }
+
+    if (filters.phaser === 'true' || filters.phaser === true) {
+        audioFilters.push('aphaser');
+    }
+
+    if (filters.chorus === 'true' || filters.chorus === true) {
+        audioFilters.push('chorus=0.5:0.9:50|60|40:0.4|0.32|0.3:0.25|0.4|0.3:2|2.3|1.3');
+    }
+
+    if (filters.compressor === 'true' || filters.compressor === true) {
+        audioFilters.push('acompressor=threshold=-20dB:ratio=4:attack=5:release=50');
+    }
+
+    if (filters.normalizer === 'true' || filters.normalizer === true) {
+        audioFilters.push('loudnorm');
+    }
+
+    if (filters.nightcore === 'true' || filters.nightcore === true) {
+        audioFilters.push('atempo=1.25');
+        audioFilters.push('asetrate=48000*1.25,aresample=48000');
+    }
+
+    if (filters.vaporwave === 'true' || filters.vaporwave === true) {
+        audioFilters.push('atempo=0.8');
+        audioFilters.push('asetrate=48000*0.8,aresample=48000');
+    }
+
+    if (filters.bassboost === 'true' || filters.bassboost === true) {
+        audioFilters.push('bass=g=10');
+    }
+
+    if (filters['8d'] === 'true' || filters['8d'] === true) {
+        audioFilters.push('apulsator=mode=sine:hz=0.125');
+    }
+
+    if (audioFilters.length > 0) {
+        args.push('-af', audioFilters.join(','));
+    }
+
+    const bitrate = config.audio?.bitrate || '128k';
+    const format = config.audio?.format || 'opus';
+
+    if (format === 'opus') {
+        args.push('-acodec', 'libopus', '-b:a', bitrate, '-f', 'ogg');
+    } else if (format === 'mp3') {
+        args.push('-acodec', 'libmp3lame', '-b:a', bitrate, '-f', 'mp3');
+    } else if (format === 'aac') {
+        args.push('-acodec', 'aac', '-b:a', bitrate, '-f', 'adts');
+    } else {
+        args.push('-acodec', 'libopus', '-b:a', bitrate, '-f', 'ogg');
+    }
+
+    args.push('-');
+
+    return args;
+}
+
+function getAvailableFilters() {
+    return {
+        bass: { type: 'number', min: -20, max: 20, description: 'Bass boost/cut in dB' },
+        treble: { type: 'number', min: -20, max: 20, description: 'Treble boost/cut in dB' },
+        speed: { type: 'number', min: 0.5, max: 2.0, description: 'Playback speed multiplier' },
+        pitch: { type: 'number', min: 0.5, max: 2.0, description: 'Pitch shift multiplier' },
+        volume: { type: 'number', min: 0, max: 200, description: 'Volume percentage' },
+        equalizer: { type: 'array', length: 15, itemType: 'number', min: -0.25, max: 1.0, description: '15-band equalizer (bands 0-14)' },
+        preset: { type: 'string', values: Object.keys(PRESETS), description: 'EQ preset name' },
+        tremolo: { type: 'object', properties: { frequency: { min: 0.1, max: 20 }, depth: { min: 0, max: 1 } }, description: 'Tremolo effect' },
+        vibrato: { type: 'object', properties: { frequency: { min: 0.1, max: 14 }, depth: { min: 0, max: 1 } }, description: 'Vibrato effect' },
+        rotation: { type: 'object', properties: { speed: { min: 0.01, max: 5 } }, description: 'Audio rotation (8D)' },
+        lowpass: { type: 'number', min: 100, max: 20000, description: 'Low-pass filter (Hz)' },
+        highpass: { type: 'number', min: 20, max: 10000, description: 'High-pass filter (Hz)' },
+        bandpass: { type: 'object', properties: { frequency: {}, width: {} }, description: 'Band-pass filter' },
+        bandreject: { type: 'object', properties: { frequency: {}, width: {} }, description: 'Band-reject/notch filter' },
+        lowshelf: { type: 'object', properties: { frequency: {}, gain: {} }, description: 'Low-shelf filter' },
+        highshelf: { type: 'object', properties: { frequency: {}, gain: {} }, description: 'High-shelf filter' },
+        peaking: { type: 'object', properties: { frequency: {}, gain: {}, q: {} }, description: 'Peaking EQ filter' },
+        karaoke: { type: 'boolean', description: 'Reduce vocals' },
+        mono: { type: 'boolean', description: 'Convert to mono' },
+        surround: { type: 'boolean', description: 'Surround sound effect' },
+        flanger: { type: 'boolean', description: 'Flanger effect' },
+        phaser: { type: 'boolean', description: 'Phaser effect' },
+        chorus: { type: 'boolean', description: 'Chorus effect' },
+        compressor: { type: 'boolean', description: 'Dynamic range compression' },
+        normalizer: { type: 'boolean', description: 'Loudness normalization' },
+        nightcore: { type: 'boolean', description: 'Nightcore preset' },
+        vaporwave: { type: 'boolean', description: 'Vaporwave preset' },
+        bassboost: { type: 'boolean', description: 'Bass boost preset' },
+        '8d': { type: 'boolean', description: '8D audio effect' }
+    };
+}
+
+function getPresets() {
+    return PRESETS;
+}
+
+function getEQBands() {
+    return EQ_BANDS;
+}
+
+module.exports = { buildFfmpegArgs, getAvailableFilters, getPresets, getEQBands, PRESETS, EQ_BANDS };