ziplayer 0.1.5 → 0.2.1

package/src/extensions/index.ts

@@ -1,17 +1,69 @@
+import type { Player } from "../structures/Player";
+import type { PlayerManager } from "../structures/PlayerManager";
+import type {
+	ExtensionSearchRequest,
+	SearchResult,
+	StreamInfo,
+	Track,
+	ExtensionContext,
+	ExtensionPlayRequest,
+	ExtensionPlayResponse,
+	ExtensionAfterPlayPayload,
+	ExtensionStreamRequest,
+} from "../types";
+
 import { BaseExtension } from "./BaseExtension";
 
 export { BaseExtension } from "./BaseExtension";
 
+type DebugFn = (message?: any, ...optionalParams: any[]) => void;
+
 // Extension factory
 export class ExtensionManager {
-	private extensions: Map<string, BaseExtension> = new Map();
+	private debug: DebugFn;
+	private extensions: Map<string, BaseExtension>;
+	private player: Player;
+	private manager: PlayerManager;
+	private extensionContext: ExtensionContext;
+
+	constructor(player: Player, manager: PlayerManager) {
+		this.player = player;
+		this.manager = manager;
+		this.extensions = new Map();
+		this.extensionContext = Object.freeze({ player, manager });
+
+		this.debug = (message?: any, ...optionalParams: any[]) => {
+			if (manager.debugEnabled) {
+				manager.emit("debug", `[ExtensionManager] ${message}`, ...optionalParams);
+			}
+		};
+	}
 
 	register(extension: BaseExtension): void {
+		if (this.extensions.has(extension.name)) {
+			return;
+		}
+		if (!extension.player) {
+			extension.player = this.player;
+		}
 		this.extensions.set(extension.name, extension);
 	}
 
-	unregister(name: string): boolean {
-		return this.extensions.delete(name);
+	unregister(extension: BaseExtension): boolean {
+		const name = extension.name;
+		const result = this.extensions.delete(name);
+		if (result) {
+			this.invokeExtensionLifecycle(extension, "onDestroy");
+		}
+		return result;
+	}
+
+	destroy(): void {
+		this.debug(`[ExtensionManager] destroying all extensions`);
+		for (const extension of this.extensions.values()) {
+			this.unregister(extension);
+		}
+		this.extensions.clear();
 	}
 
 	get(name: string): BaseExtension | undefined {
@@ -29,4 +81,114 @@ export class ExtensionManager {
 	clear(): void {
 		this.extensions.clear();
 	}
+
+	private invokeExtensionLifecycle(extension: BaseExtension | undefined, hook: "onRegister" | "onDestroy"): void {
+		if (!extension) return;
+		const fn = (extension as any)[hook];
+		if (typeof fn !== "function") return;
+		try {
+			const result = fn.call(extension, this.extensionContext);
+			if (result && typeof (result as Promise<unknown>).then === "function") {
+				(result as Promise<unknown>).catch((err) => this.debug(`[Player] Extension ${extension.name} ${hook} error:`, err));
+			}
+		} catch (err) {
+			this.debug(`[Player] Extension ${extension.name} ${hook} error:`, err);
+		}
+	}
+
+	async provideSearch(query: string, requestedBy: string): Promise<SearchResult | null> {
+		const request: ExtensionSearchRequest = { query, requestedBy };
+		for (const extension of this.getAll()) {
+			const hook = (extension as any).provideSearch;
+			if (typeof hook !== "function") continue;
+			try {
+				const result = await Promise.resolve(hook.call(extension, this.extensionContext, request));
+				if (result && Array.isArray(result.tracks) && result.tracks.length > 0) {
+					this.debug(`[Player] Extension ${extension.name} handled search for query: ${query}`);
+					return result as SearchResult;
+				}
+			} catch (err) {
+				this.debug(`[Player] Extension ${extension.name} provideSearch error:`, err);
+			}
+		}
+		return null;
+	}
+
+	async provideStream(track: Track): Promise<StreamInfo | null> {
+		const request: ExtensionStreamRequest = { track };
+		for (const extension of this.getAll()) {
+			const hook = (extension as any).provideStream;
+			if (typeof hook !== "function") continue;
+			try {
+				const result = await Promise.resolve(hook.call(extension, this.extensionContext, request));
+				if (result && (result as StreamInfo).stream) {
+					this.debug(`[Player] Extension ${extension.name} provided stream for track: ${track.title}`);
+					return result as StreamInfo;
+				}
+			} catch (err) {
+				this.debug(`[Player] Extension ${extension.name} provideStream error:`, err);
+			}
+		}
+		return null;
+	}
+
+	async BeforePlayHooks(
+		initial: ExtensionPlayRequest,
+	): Promise<{ request: ExtensionPlayRequest; response: ExtensionPlayResponse }> {
+		const request: ExtensionPlayRequest = { ...initial };
+		const response: ExtensionPlayResponse = {};
+		for (const extension of this.getAll()) {
+			const hook = (extension as any).beforePlay;
+			if (typeof hook !== "function") continue;
+			try {
+				const result = await Promise.resolve(hook.call(extension, this.extensionContext, request));
+				if (!result) continue;
+				if (result.query !== undefined) {
+					request.query = result.query;
+					response.query = result.query;
+				}
+				if (result.requestedBy !== undefined) {
+					request.requestedBy = result.requestedBy;
+					response.requestedBy = result.requestedBy;
+				}
+				if (Array.isArray(result.tracks)) {
+					response.tracks = result.tracks;
+				}
+				if (typeof result.isPlaylist === "boolean") {
+					response.isPlaylist = result.isPlaylist;
+				}
+				if (typeof result.success === "boolean") {
+					response.success = result.success;
+				}
+				if (result.error instanceof Error) {
+					response.error = result.error;
+				}
+				if (typeof result.handled === "boolean") {
+					response.handled = result.handled;
+					if (result.handled) break;
+				}
+			} catch (err) {
+				this.debug(`[Player] Extension ${extension.name} beforePlay error:`, err);
+			}
+		}
+		return { request, response };
+	}
+
+	async AfterPlayHooks(payload: ExtensionAfterPlayPayload): Promise<void> {
+		if (this.getAll().length === 0) return;
+		const safeTracks = payload.tracks ? [...payload.tracks] : undefined;
+		if (safeTracks) {
+			Object.freeze(safeTracks);
+		}
+		const immutablePayload = Object.freeze({ ...payload, tracks: safeTracks });
+		for (const extension of this.getAll()) {
+			const hook = (extension as any).afterPlay;
+			if (typeof hook !== "function") continue;
+			try {
+				await Promise.resolve(hook.call(extension, this.extensionContext, immutablePayload));
+			} catch (err) {
+				this.debug(`[Player] Extension ${extension.name} afterPlay error:`, err);
+			}
+		}
+	}
 }

package/src/plugins/index.ts

@@ -1,11 +1,35 @@
 import { BasePlugin } from "./BasePlugin";
+import { withTimeout } from "../utils/timeout";
+import type { Track, StreamInfo } from "../types";
+import type { PlayerManager } from "../structures/PlayerManager";
+import type { Player } from "../structures/Player";
+type DebugFn = (message?: any, ...optionalParams: any[]) => void;
+
+type PluginManagerOptions = {
+	extractorTimeout: number | undefined;
+};
 
 export { BasePlugin } from "./BasePlugin";
 
 // Plugin factory
 export class PluginManager {
+	private debug: DebugFn;
+	private options: PluginManagerOptions;
+	private player: Player;
+	private manager: PlayerManager;
 	private plugins: Map<string, BasePlugin> = new Map();
 
+	constructor(player: Player, manager: PlayerManager, options: PluginManagerOptions) {
+		this.player = player;
+		this.manager = manager;
+		this.options = options;
+		this.debug = (message?: any, ...optionalParams: any[]) => {
+			if (manager.debugEnabled) {
+				manager.emit("debug", `[ExtensionManager] ${message}`, ...optionalParams);
+			}
+		};
+	}
+
 	register(plugin: BasePlugin): void {
 		this.plugins.set(plugin.name, plugin);
 	}
@@ -29,4 +53,50 @@ export class PluginManager {
 	clear(): void {
 		this.plugins.clear();
 	}
+
+	async getStream(track: Track): Promise<StreamInfo | null> {
+		let streamInfo: StreamInfo | null = null;
+		const plugin = this.get(track.source) || this.findPlugin(track.url);
+
+		if (!plugin) {
+			this.debug(`[Player] No plugin found for track: ${track.title}`);
+			return null;
+		}
+
+		this.debug(`[Player] Getting stream for track: ${track.title}`);
+		this.debug(`[Player] Using plugin: ${plugin.name}`);
+		this.debug(`[Track] Track Info:`, track);
+		const timeoutMs = this.options.extractorTimeout ?? 50000;
+		try {
+			streamInfo = await withTimeout(plugin.getStream(track), timeoutMs, "getStream timed out");
+			if (!(streamInfo as any)?.stream) {
+				throw new Error(`No stream returned from ${plugin.name}`);
+			}
+		} catch (streamError) {
+			this.debug(`[Player] getStream failed, trying getFallback:`, streamError);
+			const allplugs = this.getAll();
+			for (const p of allplugs) {
+				if (typeof (p as any).getFallback !== "function" && typeof (p as any).getStream !== "function") {
+					continue;
+				}
+				try {
+					streamInfo = await withTimeout((p as any).getStream(track), timeoutMs, `getStream timed out for plugin ${p.name}`);
+					if ((streamInfo as any)?.stream) {
+						this.debug(`[Player] getStream succeeded with plugin ${p.name} for track: ${track.title}`);
+						break;
+					}
+					streamInfo = await withTimeout((p as any).getFallback(track), timeoutMs, `getFallback timed out for plugin ${p.name}`);
+					if (!(streamInfo as any)?.stream) continue;
+					break;
+				} catch (fallbackError) {
+					this.debug(`[Player] getFallback failed with plugin ${p.name}:`, fallbackError);
+				}
+			}
+			if (!(streamInfo as any)?.stream) {
+				throw new Error(`All getFallback attempts failed for track: ${track.title}`);
+			}
+		}
+
+		return streamInfo as StreamInfo;
+	}
 }

package/src/structures/FilterManager.ts

@@ -0,0 +1,262 @@
+import type { AudioFilter } from "../types";
+import { PREDEFINED_FILTERS } from "../types";
+import type { Player } from "./Player";
+import type { PlayerManager } from "./PlayerManager";
+import prism, { FFmpeg } from "prism-media";
+import type { Readable } from "stream";
+
+type DebugFn = (message?: any, ...optionalParams: any[]) => void;
+
+export class FilterManager {
+	private activeFilters: AudioFilter[] = [];
+	private debug: DebugFn;
+	private player: Player;
+	private ffmpeg: FFmpeg | null = null;
+	public StreamType: "webm/opus" | "ogg/opus" | "mp3" | "arbitrary" = "mp3";
+
+	constructor(player: Player, manager: PlayerManager) {
+		this.player = player as Player;
+
+		this.debug = (message?: any, ...optionalParams: any[]) => {
+			if (manager.debugEnabled) {
+				manager.emit("debug", `[FilterManager] ${message}`, ...optionalParams);
+			}
+		};
+	}
+
+	/**
+	 * Destroy the filter manager
+	 *
+	 * @returns {void}
+	 * @example
+	 * player.filter.destroy();
+	 */
+	destroy(): void {
+		this.activeFilters = [];
+		if (this.ffmpeg) {
+			try {
+				this.ffmpeg.destroy();
+			} catch {}
+			this.ffmpeg = null;
+		}
+	}
+
+	/**
+	 * Get the combined FFmpeg filter string for all active filters
+	 *
+	 * @returns {string} Combined FFmpeg filter string
+	 * @example
+	 * const filterString = player.getFilterString();
+	 * console.log(`Filter string: ${filterString}`);
+	 */
+	public getFilterString(): string {
+		if (this.activeFilters.length === 0) return "";
+		return this.activeFilters.map((f) => f.ffmpegFilter).join(",");
+	}
+
+	/**
+	 * Get all currently applied filters
+	 *
+	 * @returns {AudioFilter[]} Array of active filters
+	 * @example
+	 * const filters = player.getActiveFilters();
+	 * console.log(`Active filters: ${filters.map(f => f.name).join(', ')}`);
+	 */
+	public getActiveFilters(): AudioFilter[] {
+		return [...this.activeFilters];
+	}
+
+	/**
+	 * Check if a specific filter is currently applied
+	 *
+	 * @param {string} filterName - Name of the filter to check
+	 * @returns {boolean} True if filter is applied
+	 * @example
+	 * const hasBassBoost = player.hasFilter("bassboost");
+	 * console.log(`Has bass boost: ${hasBassBoost}`);
+	 */
+	public hasFilter(filterName: string): boolean {
+		return this.activeFilters.some((f) => f.name === filterName);
+	}
+
+	/**
+	 * Get available predefined filters
+	 *
+	 * @returns {AudioFilter[]} Array of all predefined filters
+	 * @example
+	 * const availableFilters = player.getAvailableFilters();
+	 * console.log(`Available filters: ${availableFilters.length}`);
+	 */
+	public getAvailableFilters(): AudioFilter[] {
+		return Object.values(PREDEFINED_FILTERS);
+	}
+
+	/**
+	 * Get filters by category
+	 *
+	 * @param {string} category - Category to filter by
+	 * @returns {AudioFilter[]} Array of filters in the category
+	 * @example
+	 * const eqFilters = player.getFiltersByCategory("eq");
+	 * console.log(`EQ filters: ${eqFilters.map(f => f.name).join(', ')}`);
+	 */
+	public getFiltersByCategory(category: string): AudioFilter[] {
+		return Object.values(PREDEFINED_FILTERS).filter((f) => f.category === category);
+	}
+
+	/**
+	 * Apply an audio filter to the player
+	 *
+	 * @param {string | AudioFilter} filter - Filter name or AudioFilter object
+	 * @returns {Promise<boolean>} True if filter was applied successfully
+	 * @example
+	 * // Apply predefined filter to current track
+	 * await player.applyFilter("bassboost");
+	 *
+	 * // Apply custom filter to current track
+	 * await player.applyFilter({
+	 *   name: "custom",
+	 *   ffmpegFilter: "volume=1.5,treble=g=5",
+	 *   description: "Tăng âm lượng và âm cao"
+	 * });
+	 *
+	 * // Apply filter without affecting current track
+	 * await player.applyFilter("bassboost", false);
+	 */
+	public async applyFilter(filter?: string | AudioFilter): Promise<boolean> {
+		if (!filter) return false;
+
+		let audioFilter: AudioFilter | undefined;
+		if (typeof filter === "string") {
+			const predefined = PREDEFINED_FILTERS[filter];
+			if (!predefined) {
+				this.debug(`[FilterManager] Predefined filter not found: ${filter}`);
+				return false;
+			}
+			audioFilter = predefined;
+		} else {
+			audioFilter = filter;
+		}
+
+		if (this.activeFilters.some((f) => f.name === audioFilter.name)) {
+			this.debug(`[FilterManager] Filter already applied: ${audioFilter.name}`);
+			return false;
+		}
+
+		this.activeFilters.push(audioFilter);
+		this.debug(`[FilterManager] Applied filter: ${audioFilter.name} - ${audioFilter.description}`);
+		return await this.player.refeshPlayerResource();
+	}
+
+	/**
+	 * Apply multiple filters at once
+	 *
+	 * @param {(string | AudioFilter)[]} filters - Array of filter names or AudioFilter objects
+	 * @returns {Promise<boolean>} True if all filters were applied successfully
+	 * @example
+	 * // Apply multiple filters to current track
+	 * await player.applyFilters(["bassboost", "trebleboost"]);
+	 *
+	 * // Apply filters without affecting current track
+	 * await player.applyFilters(["bassboost", "trebleboost"], false);
+	 */
+	public async applyFilters(filters: (string | AudioFilter)[]): Promise<boolean> {
+		let allApplied = true;
+		for (const f of filters) {
+			const ok = await this.applyFilter(f);
+			if (!ok) allApplied = false;
+		}
+		return allApplied;
+	}
+	/**
+	 * Remove an audio filter from the player
+	 *
+	 * @param {string} filterName - Name of the filter to remove
+	 * @returns {boolean} True if filter was removed successfully
+	 * @example
+	 * player.removeFilter("bassboost");
+	 */
+	public async removeFilter(filterName: string): Promise<boolean> {
+		const index = this.activeFilters.findIndex((f) => f.name === filterName);
+		if (index === -1) {
+			this.debug(`[FilterManager] Filter not found: ${filterName}`);
+			return false;
+		}
+		const removed = this.activeFilters.splice(index, 1)[0];
+		this.debug(`[FilterManager] Removed filter: ${removed.name}`);
+		return await this.player.refeshPlayerResource();
+	}
+
+	/**
+	 * Clear all audio filters from the player
+	 *
+	 * @returns {boolean} True if filters were cleared successfully
+	 * @example
+	 * player.clearFilters();
+	 */
+	public async clearAll(): Promise<boolean> {
+		const count = this.activeFilters.length;
+		this.activeFilters = [];
+		this.debug(`[FilterManager] Cleared ${count} filters`);
+		return await this.player.refeshPlayerResource();
+	}
+
+	/**
+	 * Apply filters and seek to a stream
+	 *
+	 * @param {Readable} stream - The stream to apply filters and seek to
+	 * @param {number} position - The position to seek to in milliseconds (default: 0)
+	 * @returns {Promise<Readable>} The stream with filters and seek applied
+	 */
+	public async applyFiltersAndSeek(stream: Readable, position: number = -1): Promise<Readable> {
+		const filterString = this.getFilterString();
+		this.debug(`[FilterManager] Applying filters and seek to stream: ${filterString || "none"}, seek: ${position}ms`);
+		try {
+			const args = ["-analyzeduration", "0", "-loglevel", "0"];
+
+			if (position > 0) {
+				const seekSeconds = Math.floor(position / 1000);
+				args.push("-ss", seekSeconds.toString());
+			}
+
+			// Add filter if any are active
+			if (filterString) {
+				args.push("-af", filterString);
+			}
+			args.push("-f", this.StreamType === "webm/opus" ? "webm/opus" : this.StreamType === "ogg/opus" ? "ogg/opus" : "mp3");
+			args.push("-ar", "48000", "-ac", "2");
+
+			try {
+				if (this.ffmpeg) {
+					this.ffmpeg.destroy();
+				}
+				this.ffmpeg = null;
+			} catch {}
+
+			this.ffmpeg = stream.pipe(new prism.FFmpeg({ args }));
+
+			this.ffmpeg.on("close", () => {
+				this.debug(`[FilterManager] FFmpeg filter+seek processing completed`);
+				if (this.ffmpeg) {
+					this.ffmpeg.destroy();
+					this.ffmpeg = null;
+				}
+			});
+
+			this.ffmpeg.on("error", (err: Error) => {
+				this.debug(`[FilterManager] FFmpeg filter+seek error:`, err);
+				if (this.ffmpeg) {
+					this.ffmpeg.destroy();
+				}
+				if (this.ffmpeg) {
+					this.ffmpeg = null;
+				}
+			});
+			return this.ffmpeg;
+		} catch (error) {
+			this.debug(`[FilterManager] Error creating FFmpeg instance:`, error);
+			// Fallback to original stream if FFmpeg fails
+			throw error;
+		}
+	}
+}