streamify-audio 2.1.11 → 2.1.13

package/docs/discord/player.md

@@ -14,7 +14,7 @@ const player = manager.get(guildId);
 
 ## Playback Methods
 
-### play(track)
+### play(track, options?)
 
 Plays a track immediately. If something is playing, adds to queue and skips.
 
@@ -23,6 +23,34 @@ const result = await manager.search('never gonna give you up');
 await player.play(result.tracks[0]);
 ```
 
+**Options:**
+- `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
+await player.play(track, { startPosition: 30000 });
+
+// Start with specific volume
+await player.play(track, { volume: 50 });
+
+// Start with filters applied
+await player.play(track, { filters: { bass: 10, nightcore: true } });
+
+// Replace current track without queueing
+await player.play(track, { replace: true });
+
+// Combine options
+await player.play(track, {
+    startPosition: savedPositionMs,
+    volume: savedVolume,
+    filters: savedFilters,
+    replace: true
+});
+```
+
 ### pause()
 
 Pauses playback and destroys the stream to save resources.
@@ -97,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 }>;
     }
 
     // ========================================================================
@@ -237,6 +239,29 @@ declare module 'streamify-audio' {
         on(event: 'playerDestroy', listener: (player: Player) => void): this;
     }
 
+    export interface PlayOptions {
+        startPosition?: number;
+        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 {
         constructor(manager: Manager, options: any);
 
@@ -261,7 +286,7 @@ declare module 'streamify-audio' {
         disconnect(): boolean;
         destroy(): void;
 
-        play(track: Track): Promise<void>;
+        play(track: Track, options?: PlayOptions): Promise<void>;
         pause(destroyStream?: boolean): boolean;
         resume(): Promise<boolean>;
         skip(): Promise<Track | null>;
@@ -281,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.11",
+  "version": "2.1.13",
   "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;
@@ -261,15 +263,33 @@ class Player extends EventEmitter {
             await this.connect();
         }
 
-        const startPosition = options.startPosition || options.seek || 0;
+        const playOptions = {
+            startPosition: options.startPosition || options.seek || 0,
+            volume: options.volume,
+            filters: options.filters,
+            replace: options.replace || false
+        };
+
+        if (options.volume !== undefined) {
+            this._volume = Math.max(0, Math.min(200, options.volume));
+        }
 
-        if (this.queue.current) {
+        if (options.filters) {
+            this._filters = { ...this._filters, ...options.filters };
+        }
+
+        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, startPosition);
+        return this._playTrack(track, playOptions.startPosition);
     }
 
     async _playTrack(track, startPosition = 0) {
@@ -604,6 +624,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
+};