streamify-audio 2.1.12 → 2.1.14

package/docs/discord/player.md

@@ -27,6 +27,7 @@ await player.play(result.tracks[0]);
 - `startPosition` - Start playback at a specific position in milliseconds
 - `volume` - Set volume before playing (0-200)
 - `filters` - Apply filters before playing
+- `replace` - Replace current track without adding to queue/history
 
 ```javascript
 // Start playing at 30 seconds
@@ -38,11 +39,15 @@ await player.play(track, { volume: 50 });
 // Start with filters applied
 await player.play(track, { filters: { bass: 10, nightcore: true } });
 
-// Combine options (useful for session restoration)
+// Replace current track without queueing
+await player.play(track, { replace: true });
+
+// Combine options
 await player.play(track, {
     startPosition: savedPositionMs,
     volume: savedVolume,
-    filters: savedFilters
+    filters: savedFilters,
+    replace: true
 });
 ```
 
@@ -120,6 +125,57 @@ console.log(player.filters);  // { bass: 10, nightcore: true }
 
 See [Filters](../filters.md) for all available filters.
 
+## Effect Presets
+
+Effect presets are pre-configured filter combinations that stack by default.
+
+```javascript
+// Apply a single preset
+await player.setEffectPresets(['bassboost']);
+
+// Apply multiple presets (they stack)
+await player.setEffectPresets(['nightcore', 'bassboost']);
+
+// Apply with custom intensity (0.1 - 1.0)
+await player.setEffectPresets([
+    { name: 'nightcore', intensity: 0.8 },
+    { name: 'bassboost', intensity: 0.5 }
+]);
+
+// Replace all presets instead of stacking
+await player.setEffectPresets(['8d'], { replace: true });
+
+// Get active presets
+const active = player.getActiveEffectPresets();
+// [{ name: 'nightcore', intensity: 0.8 }, { name: 'bassboost', intensity: 0.5 }]
+
+// Clear all effect presets
+await player.clearEffectPresets();
+
+// List available presets
+const presets = player.getEffectPresets();
+// ['bassboost', 'nightcore', 'vaporwave', '8d', 'karaoke', ...]
+```
+
+**Available Presets:**
+- `bassboost` - Boost bass frequencies
+- `nightcore` - Speed up with higher pitch
+- `vaporwave` - Slow down with lower pitch
+- `8d` - 8D rotating audio effect
+- `karaoke` - Reduce vocals
+- `trebleboost` - Boost treble frequencies
+- `deep` - Deep bass with lower pitch
+- `lofi` - Lo-fi aesthetic
+- `radio` - Radio/telephone effect
+- `telephone` - Old telephone effect
+- `soft` - Softer, quieter sound
+- `loud` - Louder, compressed sound
+- `chipmunk` - High-pitched voice
+- `darth` - Deep Darth Vader voice
+- `echo` - Echo/reverb effect
+- `vibrato` - Vibrato effect
+- `tremolo` - Tremolo effect
+
 ## Loop Modes
 
 ```javascript

package/index.d.ts

@@ -163,6 +163,8 @@ declare module 'streamify-audio' {
         static Manager: typeof Manager;
         static Player: typeof Player;
         static Queue: typeof Queue;
+        static getEffectPresetsInfo(): EffectPresetInfo[];
+        static EFFECT_PRESETS: Record<string, { filters: Filters; description: string }>;
     }
 
     // ========================================================================
@@ -242,6 +244,22 @@ declare module 'streamify-audio' {
         seek?: number;
         volume?: number;
         filters?: Filters;
+        replace?: boolean;
+    }
+
+    export interface EffectPreset {
+        name: string;
+        intensity?: number;
+    }
+
+    export interface EffectPresetInfo {
+        name: string;
+        description: string;
+        filters: string[];
+    }
+
+    export interface SetEffectPresetsOptions {
+        replace?: boolean;
     }
 
     export class Player extends EventEmitter {
@@ -288,6 +306,11 @@ declare module 'streamify-audio' {
         clearEQ(): Promise<boolean>;
         getPresets(): string[];
 
+        setEffectPresets(presets: (string | EffectPreset)[], options?: SetEffectPresetsOptions): Promise<boolean>;
+        getActiveEffectPresets(): EffectPreset[];
+        clearEffectPresets(): Promise<boolean>;
+        getEffectPresets(): string[];
+
         toJSON(): any;
 
         on(event: 'trackStart', listener: (track: Track) => void): this;

package/index.js

@@ -249,4 +249,8 @@ Streamify.Manager = Manager;
 Streamify.Player = Manager ? require('./src/discord/Player') : null;
 Streamify.Queue = Manager ? require('./src/discord/Queue') : null;
 
+const { getEffectPresetsInfo, EFFECT_PRESETS } = require('./src/filters/ffmpeg');
+Streamify.getEffectPresetsInfo = getEffectPresetsInfo;
+Streamify.EFFECT_PRESETS = EFFECT_PRESETS;
+
 module.exports = Streamify;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "streamify-audio",
-  "version": "2.1.12",
+  "version": "2.1.14",
   "description": "Dual-mode audio library: HTTP streaming proxy + Discord player (Lavalink alternative). Supports YouTube, Spotify, SoundCloud with audio filters.",
   "main": "index.js",
   "types": "index.d.ts",
   "bin": {
-    "streamify": "./bin/streamify.js"
+    "streamify": "bin/streamify.js"
   },
   "scripts": {
     "start": "node index.js",
@@ -48,7 +48,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/LucasCzechia/streamify.git"
+    "url": "git+https://github.com/LucasCzechia/streamify.git"
   },
   "homepage": "https://github.com/LucasCzechia/streamify#readme",
   "bugs": {

package/src/discord/Player.js

@@ -1,6 +1,7 @@
 const { EventEmitter } = require('events');
 const Queue = require('./Queue');
 const { createStream } = require('./Stream');
+const { applyEffectPreset, EFFECT_PRESETS } = require('../filters/ffmpeg');
 const log = require('../utils/logger');
 
 let voiceModule;
@@ -35,6 +36,7 @@ class Player extends EventEmitter {
 
         this._volume = options.volume || manager.config.defaultVolume || 80;
         this._filters = {};
+        this._effectPresets = [];
         this._playing = false;
         this._paused = false;
         this._positionTimestamp = 0;
@@ -45,6 +47,7 @@ class Player extends EventEmitter {
         this._prefetchedTrack = null;
         this._prefetching = false;
         this._changingStream = false;
+        this._manualSkip = false;
 
         this.autoLeave = {
             enabled: options.autoLeave?.enabled ?? true,
@@ -195,15 +198,17 @@ class Player extends EventEmitter {
 
             this.emit('trackEnd', track, 'finished');
 
-            const next = this.queue.shift();
-            if (next) {
-                this._playTrack(next);
-            } else {
-                if (this.autoplay.enabled && track) {
-                    await this._handleAutoplay(track);
+            if (!this._manualSkip) {
+                const next = this.queue.shift();
+                if (next) {
+                    this._playTrack(next);
                 } else {
-                    this.emit('queueEnd');
-                    this._resetInactivityTimeout();
+                    if (this.autoplay.enabled && track) {
+                        await this._handleAutoplay(track);
+                    } else {
+                        this.emit('queueEnd');
+                        this._resetInactivityTimeout();
+                    }
                 }
             }
         });
@@ -264,7 +269,8 @@ class Player extends EventEmitter {
         const playOptions = {
             startPosition: options.startPosition || options.seek || 0,
             volume: options.volume,
-            filters: options.filters
+            filters: options.filters,
+            replace: options.replace || false
         };
 
         if (options.volume !== undefined) {
@@ -275,11 +281,16 @@ class Player extends EventEmitter {
             this._filters = { ...this._filters, ...options.filters };
         }
 
-        if (this.queue.current) {
+        if (this.queue.current && !playOptions.replace) {
             this.queue.add(track, 0);
             return this.skip();
         }
 
+        if (playOptions.replace && this.stream) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+
         this.queue.setCurrent(track);
         return this._playTrack(track, playOptions.startPosition);
     }
@@ -473,8 +484,16 @@ class Player extends EventEmitter {
             this.stream = null;
         }
 
+        this._manualSkip = true;
+        const next = this.queue.shift();
         this.audioPlayer.stop();
-        return this.queue.current;
+
+        if (next) {
+            await this._playTrack(next);
+        }
+
+        this._manualSkip = false;
+        return next;
     }
 
     async previous() {
@@ -487,8 +506,11 @@ class Player extends EventEmitter {
             this.stream = null;
         }
 
+        this._manualSkip = true;
         this.audioPlayer.stop();
-        return this._playTrack(prev);
+        const result = await this._playTrack(prev);
+        this._manualSkip = false;
+        return result;
     }
 
     stop() {
@@ -616,6 +638,70 @@ class Player extends EventEmitter {
         return Object.keys(PRESETS);
     }
 
+    async setEffectPresets(presets, options = {}) {
+        if (!Array.isArray(presets)) {
+            presets = [presets];
+        }
+
+        const replace = options.replace ?? false;
+        const appliedFilters = {};
+        const newPresets = [];
+
+        for (const preset of presets) {
+            const name = typeof preset === 'string' ? preset : preset.name;
+            const intensity = typeof preset === 'object' ? (preset.intensity ?? 1.0) : 1.0;
+
+            if (!EFFECT_PRESETS[name]) {
+                log.warn('PLAYER', `Unknown effect preset: ${name}`);
+                continue;
+            }
+
+            const filters = applyEffectPreset(name, intensity);
+            if (filters) {
+                Object.assign(appliedFilters, filters);
+                newPresets.push({ name, intensity });
+            }
+        }
+
+        if (replace) {
+            this._effectPresets = newPresets;
+            this._filters = appliedFilters;
+        } else {
+            const existingNames = this._effectPresets.map(p => p.name);
+            for (const preset of newPresets) {
+                const idx = existingNames.indexOf(preset.name);
+                if (idx >= 0) {
+                    this._effectPresets[idx] = preset;
+                } else {
+                    this._effectPresets.push(preset);
+                }
+            }
+            this._filters = { ...this._filters, ...appliedFilters };
+        }
+
+        if (this._playing && this.queue.current) {
+            return this.setFilter('_trigger', null);
+        }
+        return true;
+    }
+
+    getActiveEffectPresets() {
+        return [...this._effectPresets];
+    }
+
+    async clearEffectPresets() {
+        this._effectPresets = [];
+        this._filters = {};
+        if (this._playing && this.queue.current) {
+            return this.setFilter('_trigger', null);
+        }
+        return true;
+    }
+
+    getEffectPresets() {
+        return Object.keys(EFFECT_PRESETS);
+    }
+
     disconnect() {
         if (this.connection) {
             this.connection.destroy();

package/src/filters/ffmpeg.js

@@ -18,6 +18,26 @@ const PRESETS = {
     treble_heavy: [0, 0, 0, 0, 0, 0, 0, 0, 0.1, 0.2, 0.3, 0.4, 0.45, 0.5, 0.5]
 };
 
+const EFFECT_PRESETS = {
+    bassboost: { filters: { bass: 10 }, description: 'Boost bass frequencies' },
+    nightcore: { filters: { speed: 1.25, pitch: 1.25 }, description: 'Speed up with higher pitch' },
+    vaporwave: { filters: { speed: 0.8, pitch: 0.8 }, description: 'Slow down with lower pitch' },
+    '8d': { filters: { rotation: { speed: 0.2 } }, description: '8D rotating audio effect' },
+    karaoke: { filters: { karaoke: true }, description: 'Reduce vocals' },
+    trebleboost: { filters: { treble: 10 }, description: 'Boost treble frequencies' },
+    deep: { filters: { bass: 15, pitch: 0.9 }, description: 'Deep bass with lower pitch' },
+    lofi: { filters: { lowpass: 3000, bass: 5 }, description: 'Lo-fi aesthetic' },
+    radio: { filters: { highpass: 300, lowpass: 5000 }, description: 'Radio/telephone effect' },
+    telephone: { filters: { highpass: 500, lowpass: 3500 }, description: 'Old telephone effect' },
+    soft: { filters: { bass: -5, treble: -3, volume: 70 }, description: 'Softer, quieter sound' },
+    loud: { filters: { bass: 5, treble: 3, compressor: true }, description: 'Louder, compressed sound' },
+    chipmunk: { filters: { pitch: 1.5 }, description: 'High-pitched chipmunk voice' },
+    darth: { filters: { pitch: 0.7 }, description: 'Deep Darth Vader voice' },
+    echo: { filters: { echo: true }, description: 'Echo/reverb effect' },
+    vibrato: { filters: { vibrato: { frequency: 5, depth: 0.5 } }, description: 'Vibrato effect' },
+    tremolo: { filters: { tremolo: { frequency: 5, depth: 0.5 } }, description: 'Tremolo effect' }
+};
+
 function buildEqualizer(bands) {
     if (!bands || !Array.isArray(bands)) return null;
 
@@ -267,4 +287,49 @@ function getEQBands() {
     return EQ_BANDS;
 }
 
-module.exports = { buildFfmpegArgs, getAvailableFilters, getPresets, getEQBands, PRESETS, EQ_BANDS };
+function getEffectPresets() {
+    return EFFECT_PRESETS;
+}
+
+function getEffectPresetsInfo() {
+    return Object.entries(EFFECT_PRESETS).map(([name, data]) => ({
+        name,
+        description: data.description,
+        filters: Object.keys(data.filters)
+    }));
+}
+
+function applyEffectPreset(name, intensity = 1.0) {
+    const preset = EFFECT_PRESETS[name];
+    if (!preset) return null;
+
+    const filters = {};
+    for (const [key, value] of Object.entries(preset.filters)) {
+        if (typeof value === 'number') {
+            filters[key] = value * intensity;
+        } else if (typeof value === 'boolean') {
+            filters[key] = value;
+        } else if (typeof value === 'object') {
+            filters[key] = { ...value };
+            for (const [k, v] of Object.entries(filters[key])) {
+                if (typeof v === 'number') {
+                    filters[key][k] = v * intensity;
+                }
+            }
+        }
+    }
+    return filters;
+}
+
+module.exports = {
+    buildFfmpegArgs,
+    getAvailableFilters,
+    getPresets,
+    getEQBands,
+    getEffectPresets,
+    getEffectPresetsInfo,
+    applyEffectPreset,
+    PRESETS,
+    EQ_BANDS,
+    EFFECT_PRESETS
+};