@ffmpeg-oneclick/core 0.1.2

package/dist/index.d.cts

@@ -0,0 +1,725 @@
+import EventEmitter from 'events';
+import { Readable, Writable, Transform } from 'stream';
+
+interface ProgressInfo {
+    percent: number;
+    eta: number;
+    frames: number;
+    time: number;
+    bitrate: number;
+    fps: number;
+    size: number;
+}
+interface FFmpegResult {
+    output: string;
+    duration: number;
+    size: number;
+    command: string;
+    logs: string;
+}
+interface VideoMetadata {
+    duration: number;
+    width: number;
+    height: number;
+    fps: number;
+    videoCodec: string;
+    audioCodec: string;
+    videoBitrate: number;
+    audioBitrate: number;
+    audioSampleRate: number;
+    audioChannels: number;
+}
+type HardwareAcceleration = 'auto' | 'none' | 'nvenc' | 'qsv' | 'vce' | 'videotoolbox';
+type InputType = string | Buffer | NodeJS.ReadableStream;
+type OutputType = string | NodeJS.WritableStream;
+interface FFmpegEventListeners {
+    start?: (command: string) => void;
+    progress?: (progress: ProgressInfo) => void;
+    end?: (result: FFmpegResult) => void;
+    error?: (error: Error) => void;
+    stdout?: (data: string) => void;
+    stderr?: (data: string) => void;
+}
+interface FFmpegOptions {
+    ffmpegPath?: string;
+    ffprobePath?: string;
+    hardwareAcceleration?: HardwareAcceleration;
+    threads?: number;
+    timeout?: number;
+    logLevel?: 'quiet' | 'error' | 'warning' | 'info' | 'verbose' | 'debug';
+    cache?: CacheOptions$1;
+}
+interface CacheOptions$1 {
+    enabled?: boolean;
+    dir?: string;
+    ttl?: number;
+    maxSize?: number;
+}
+interface VideoFilterOptions {
+    scale?: string | {
+        width: number;
+        height: number;
+    };
+    crop?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    rotate?: number;
+    hflip?: boolean;
+    vflip?: boolean;
+    blur?: number;
+    sharpen?: number;
+    brightness?: number;
+    contrast?: number;
+    saturation?: number;
+}
+interface AudioFilterOptions {
+    volume?: number;
+    denoise?: boolean;
+    normalize?: boolean;
+}
+declare enum ErrorCode {
+    INPUT_NOT_FOUND = 1001,
+    INPUT_INVALID_FORMAT = 1002,
+    INPUT_CORRUPTED = 1003,
+    INPUT_UNSUPPORTED = 1004,
+    OUTPUT_PATH_INVALID = 2001,
+    OUTPUT_WRITE_FAILED = 2002,
+    OUTPUT_ALREADY_EXISTS = 2003,
+    FFMPEG_NOT_FOUND = 3001,
+    FFMPEG_EXECUTION_FAILED = 3002,
+    FFMPEG_TIMEOUT = 3003,
+    FFMPEG_INVALID_COMMAND = 3004,
+    INVALID_PARAMETER = 4001,
+    INCOMPATIBLE_OPTIONS = 4002,
+    MISSING_REQUIRED_OPTION = 4003,
+    OUT_OF_MEMORY = 5001,
+    INSUFFICIENT_DISK_SPACE = 5002,
+    PERMISSION_DENIED = 5003
+}
+interface FFmpegError extends Error {
+    code: ErrorCode;
+    details?: Record<string, unknown>;
+    suggestion?: string;
+    retryable: boolean;
+}
+
+interface CacheOptions {
+    enabled: boolean;
+    dir?: string;
+    ttl?: number;
+    maxSize?: number;
+}
+declare class CacheManager {
+    private options;
+    private cacheDir;
+    private manifestPath;
+    private manifest;
+    private hits;
+    private misses;
+    private manifestDirty;
+    private saveTimer;
+    private lockOptions;
+    constructor(options?: CacheOptions);
+    private initCacheDir;
+    private loadManifest;
+    private markDirty;
+    private saveManifest;
+    generateParamsHash(inputPath: string, options: Record<string, any>): string;
+    getCacheKey(inputPath: string, options: Record<string, any>): string;
+    has(key: string): boolean;
+    get(key: string): string | null;
+    set(key: string, inputPath: string, outputPath: string, options: Record<string, any>): void;
+    delete(key: string): void;
+    clear(): void;
+    getStats(): {
+        count: number;
+        totalSize: number;
+        oldestEntry: number;
+        newestEntry: number;
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+    cleanupExpired(): void;
+    private evictIfNeeded;
+    getHitRate(): number;
+    flush(): Promise<void>;
+}
+
+declare class ChainableFFmpeg {
+    private wrapper;
+    private commandBuilder;
+    private inputValue;
+    private outputValue;
+    private listeners;
+    private cacheManager?;
+    private cacheEnabled;
+    constructor(options?: FFmpegOptions);
+    input(input: InputType): this;
+    output(output: OutputType): this;
+    videoCodec(codec: string): this;
+    audioCodec(codec: string): this;
+    videoBitrate(bitrate: string | number): this;
+    audioBitrate(bitrate: string | number): this;
+    audioFrequency(frequency: number): this;
+    audioChannels(channels: number): this;
+    volume(volume: number): this;
+    fps(fps: number): this;
+    size(size: string | {
+        width: number;
+        height: number;
+    }): this;
+    hardwareAccelerate(type: HardwareAcceleration): this;
+    threads(count: number): this;
+    duration(seconds: number): this;
+    startTime(seconds: number): this;
+    trim(start: number, end: number): this;
+    concat(inputs: string[]): this;
+    concatWithoutAudio(inputs: string[]): this;
+    rotate(angle: number): this;
+    flip(): this;
+    flop(): this;
+    crop(x: number, y: number, width: number, height: number): this;
+    screenshot(timestamp: number, output: string): this;
+    screenshots(options: {
+        timestamps: number[];
+        filenameTemplate?: string;
+        outputDir?: string;
+        format?: 'jpg' | 'png' | 'bmp';
+        quality?: number;
+    }): this;
+    thumbnails(options: {
+        count: number;
+        filenameTemplate?: string;
+        outputDir?: string;
+        format?: 'jpg' | 'png';
+        width?: number;
+    }): this;
+    format(format: string): this;
+    hls(options?: {
+        segmentDuration?: number;
+        playlistName?: string;
+        segmentName?: string;
+        listSize?: number;
+        fmp4?: boolean;
+    }): this;
+    dash(options?: {
+        segmentDuration?: number;
+        manifestName?: string;
+        segmentName?: string;
+        live?: boolean;
+    }): this;
+    toHLS(output: string, options?: {
+        segmentDuration?: number;
+        playlistName?: string;
+        segmentName?: string;
+        listSize?: number;
+        fmp4?: boolean;
+    }): Promise<FFmpegResult>;
+    toDASH(output: string, options?: {
+        segmentDuration?: number;
+        manifestName?: string;
+        segmentName?: string;
+        live?: boolean;
+    }): Promise<FFmpegResult>;
+    videoFilters(options: VideoFilterOptions): this;
+    audioFilters(options: AudioFilterOptions): this;
+    mix(audioInputs: Array<{
+        input: string | number;
+        volume?: number;
+        startTime?: number;
+        duration?: number;
+    }>, options?: {
+        codec?: string;
+        bitrate?: string | number;
+    }): this;
+    watermark(watermarkPath: string, options?: {
+        position?: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'center' | {
+            x: number;
+            y: number;
+        };
+        opacity?: number;
+        scale?: number;
+    }): this;
+    textWatermark(text: string, options?: {
+        fontFile?: string;
+        fontSize?: number;
+        fontColor?: string;
+        position?: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'center' | {
+            x: number;
+            y: number;
+        };
+        opacity?: number;
+        borderColor?: string;
+        borderWidth?: number;
+        shadowColor?: string;
+        shadowOffset?: number;
+    }): this;
+    metadata(key: string, value: string): this;
+    noMetadata(): this;
+    autoRotate(): Promise<this>;
+    outputOption(option: string, value?: string): this;
+    inputOption(option: string, value?: string): this;
+    cache(options?: Partial<CacheOptions>): this;
+    on<K extends keyof FFmpegEventListeners>(event: K, listener: NonNullable<FFmpegEventListeners[K]>): this;
+    run(): Promise<FFmpegResult>;
+    getCommand(): string;
+    kill(): void;
+}
+
+declare function createFFmpegError(code: ErrorCode, message: string, options?: {
+    details?: Record<string, unknown>;
+    suggestion?: string;
+    retryable?: boolean;
+    cause?: Error;
+}): FFmpegError;
+declare function getErrorSuggestion(code: ErrorCode): string;
+
+declare class CommandBuilder {
+    private inputArgs;
+    private outputArgs;
+    private inputFiles;
+    private outputFiles;
+    private complexFilters;
+    private mappings;
+    private metadata;
+    addInput(input: string): this;
+    addInputOption(option: string, value?: string): this;
+    setOutput(output: string): this;
+    addOutputOption(option: string, value?: string): this;
+    setVideoCodec(codec: string): this;
+    setAudioCodec(codec: string): this;
+    setVideoBitrate(bitrate: string | number): this;
+    setAudioBitrate(bitrate: string | number): this;
+    setAudioFrequency(frequency: number): this;
+    setAudioChannels(channels: number): this;
+    setVolume(volume: number): this;
+    setFPS(fps: number): this;
+    setSize(size: string | {
+        width: number;
+        height: number;
+    }): this;
+    setHardwareAcceleration(type: HardwareAcceleration): this;
+    setThreads(threads: number): this;
+    setDuration(seconds: number): this;
+    setStartTime(seconds: number): this;
+    concat(inputs: string[]): this;
+    concatWithoutAudio(inputs: string[]): this;
+    rotate(angle: number): this;
+    flip(): this;
+    flop(): this;
+    addVideoFilter(filter: string): this;
+    addAudioFilter(filter: string): this;
+    addWatermark(watermarkPath: string, options?: {
+        position?: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'center' | {
+            x: number;
+            y: number;
+        };
+        opacity?: number;
+        scale?: number;
+    }): this;
+    private calculateTextPosition;
+    addTextWatermark(text: string, options?: {
+        fontFile?: string;
+        fontSize?: number;
+        fontColor?: string;
+        position?: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'center' | {
+            x: number;
+            y: number;
+        };
+        opacity?: number;
+        borderColor?: string;
+        borderWidth?: number;
+        shadowColor?: string;
+        shadowOffset?: number;
+    }): this;
+    private buildScaleFilter;
+    private buildCropFilter;
+    private buildColorFilters;
+    private buildGeometryFilters;
+    private buildBlurSharpenFilters;
+    applyVideoFilters(options: VideoFilterOptions): this;
+    applyAudioFilters(options: AudioFilterOptions): this;
+    addMetadata(key: string, value: string): this;
+    removeAllMetadata(): this;
+    setHLS(options?: {
+        segmentDuration?: number;
+        playlistName?: string;
+        segmentName?: string;
+        listSize?: number;
+        fmp4?: boolean;
+    }): this;
+    setDASH(options?: {
+        segmentDuration?: number;
+        manifestName?: string;
+        segmentName?: string;
+        live?: boolean;
+    }): this;
+    setFormat(format: string): this;
+    overwrite(): this;
+    noOverwrite(): this;
+    build(): string[];
+    buildString(): string;
+    getOptions(): Record<string, any>;
+    reset(): void;
+    mixAudio(audioInputs: Array<{
+        input: string | number;
+        volume?: number;
+        startTime?: number;
+        duration?: number;
+    }>, options?: {
+        codec?: string;
+        bitrate?: string | number;
+    }): this;
+    screenshot(timestamp: number, output: string): this;
+    screenshots(options: {
+        timestamps: number[];
+        filenameTemplate?: string;
+        outputDir?: string;
+        format?: 'jpg' | 'png' | 'bmp';
+        quality?: number;
+    }): this;
+    thumbnails(options: {
+        count: number;
+        filenameTemplate?: string;
+        outputDir?: string;
+        format?: 'jpg' | 'png';
+        width?: number;
+    }): this;
+}
+
+declare class FFmpegWrapper extends EventEmitter {
+    private options;
+    private commandBuilder;
+    private progressParser;
+    private process;
+    private killed;
+    private startTime;
+    private inputDuration;
+    constructor(options?: FFmpegOptions);
+    private getFFmpegPath;
+    private getFFprobePath;
+    private getInputDuration;
+    private validateInputOutput;
+    private setupInputOutput;
+    private setupOptions;
+    private handleStderr;
+    private handleInputStreams;
+    private handleOutputStreams;
+    private buildResult;
+    private handleExecutionError;
+    run(input: InputType, output: OutputType): Promise<FFmpegResult>;
+    kill(): void;
+    cleanup(): void;
+    destroy(): void;
+    getMetadata(input: string): Promise<VideoMetadata>;
+    getCommandBuilder(): CommandBuilder;
+}
+
+declare class ProgressParser {
+    private lastProgress;
+    private parseFrames;
+    private parseFps;
+    private parseTime;
+    private parseBitrate;
+    private parseSize;
+    parseLine(line: string): Partial<ProgressInfo> | null;
+    calculatePercent(currentTime: number, totalTime: number): number;
+    calculateETA(currentTime: number, totalTime: number, speed: number): number;
+    getLastProgress(): Partial<ProgressInfo>;
+    reset(): void;
+}
+
+type HardwareAccelType = 'nvenc' | 'qsv' | 'vce' | 'videotoolbox' | 'none';
+interface HardwareAccelInfo {
+    type: HardwareAccelType;
+    available: boolean;
+    encoder?: string;
+    decoder?: string;
+    info?: string;
+}
+declare class HardwareAccelDetector {
+    private ffmpegPath;
+    private cache;
+    constructor(ffmpegPath?: string);
+    detectAll(): Promise<HardwareAccelInfo[]>;
+    detect(type: HardwareAccelType): Promise<HardwareAccelInfo>;
+    private detectHardwareAccel;
+    private detectNVENC;
+    private detectQSV;
+    private detectVCE;
+    private detectVideoToolbox;
+    getBest(): Promise<HardwareAccelInfo>;
+    clearCache(): void;
+}
+declare function getHardwareAccelDetector(ffmpegPath?: string): HardwareAccelDetector;
+declare function detectBestHardwareAccel(ffmpegPath?: string): Promise<HardwareAccelInfo>;
+
+type TaskPriority = 'high' | 'normal' | 'low';
+type TaskStatus = 'pending' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+interface Task<T = any> {
+    id: string;
+    priority: TaskPriority;
+    status: TaskStatus;
+    run: (signal?: AbortSignal) => Promise<T>;
+    result?: T;
+    error?: Error;
+    createdAt: number;
+    startedAt?: number;
+    completedAt?: number;
+    progress?: number;
+    abortController?: AbortController;
+}
+interface QueueOptions {
+    maxConcurrent?: number;
+    autoStart?: boolean;
+    timeout?: number;
+}
+declare class ConcurrentQueue extends EventEmitter {
+    private maxConcurrent;
+    private autoStart;
+    private timeout;
+    private queue;
+    private running;
+    private completedTasks;
+    private maxHistorySize;
+    private paused;
+    private taskIdCounter;
+    constructor(options?: QueueOptions);
+    add<T>(run: (signal?: AbortSignal) => Promise<T>, priority?: TaskPriority): string;
+    private insertTask;
+    private process;
+    private addToHistory;
+    private generateTaskId;
+    pause(): void;
+    resume(): void;
+    cancel(taskId: string): boolean;
+    clear(): void;
+    getTask(taskId: string): Task | undefined;
+    getStats(): {
+        pending: number;
+        running: number;
+        completed: number;
+        failed: number;
+        total: number;
+    };
+    waitAll(): Promise<void>;
+    setMaxConcurrent(max: number): void;
+    isPaused(): boolean;
+    isEmpty(): boolean;
+}
+
+interface PresetConfig {
+    name: string;
+    description?: string;
+    videoCodec?: string;
+    audioCodec?: string;
+    videoBitrate?: string | number;
+    audioBitrate?: string | number;
+    fps?: number;
+    size?: string | {
+        width: number;
+        height: number;
+    };
+    format?: string;
+    options?: Record<string, any>;
+    processor?: (instance: ChainableFFmpeg, options?: any) => ChainableFFmpeg;
+}
+declare class PresetManager {
+    private presets;
+    constructor();
+    private registerCompressionPresets;
+    private registerPlatformPresets;
+    private registerFormatPresets;
+    private registerStreamingPresets;
+    private registerScreenshotPresets;
+    private registerBuiltInPresets;
+    register(name: string, config: PresetConfig): void;
+    private isValidBitrate;
+    get(name: string): PresetConfig | undefined;
+    list(): Array<{
+        name: string;
+        config: PresetConfig;
+    }>;
+    private applyConfig;
+    private validateAndGetPreset;
+    apply(input: string, output: string, presetName: string, options?: any): ChainableFFmpeg;
+    applyAsync(input: string, output: string, presetName: string, options?: any): Promise<ChainableFFmpeg>;
+    compressVideo(input: string, output: string, quality?: 'high' | 'medium' | 'low'): Promise<any>;
+    toGif(input: string, output: string, options?: {
+        startTime?: number;
+        duration?: number;
+        fps?: number;
+        size?: string;
+    }): Promise<any>;
+    extractAudio(input: string, output: string, bitrate?: string): Promise<any>;
+    webOptimized(input: string, output: string): Promise<any>;
+    mobileFriendly(input: string, output: string): Promise<any>;
+    createThumbnail(input: string, output: string, time?: number): Promise<any>;
+}
+declare const presets: PresetManager;
+
+type StreamType = 'readable' | 'writable' | 'duplex' | 'transform';
+interface StreamHandlerOptions {
+    highWaterMark?: number;
+    autoEnd?: boolean;
+    autoDestroy?: boolean;
+    encoding?: BufferEncoding;
+    timeout?: number;
+}
+declare class StreamHandler {
+    private options;
+    private inputStreams;
+    private outputStreams;
+    private eventListeners;
+    constructor(options?: StreamHandlerOptions);
+    detectInputType(input: any): 'file' | 'buffer' | 'stream' | 'url' | 'unknown';
+    detectOutputType(output: any): 'file' | 'stream' | 'unknown';
+    createInputStream(input: any): Promise<Readable>;
+    createOutputStream(output: any): Promise<Writable>;
+    pipeStreams(source: Readable, destination: Writable, options?: {
+        end?: boolean;
+    }): Promise<void>;
+    private trackListener;
+    cleanup(): void;
+    createTransformStream(transformer: (chunk: Buffer, encoding: BufferEncoding) => Buffer | string | null): Transform;
+    readStreamToBuffer(stream: Readable): Promise<Buffer>;
+    writeBufferToStream(buffer: Buffer, stream: Writable): Promise<void>;
+    validateStream(stream: any, type: 'readable' | 'writable'): boolean;
+    waitForStreamEnd(stream: Readable | Writable): Promise<void>;
+    destroyStream(stream: Readable | Writable, error?: Error): void;
+    pauseStream(stream: Readable): void;
+    resumeStream(stream: Readable): void;
+    getStreamStats(stream: Readable | Writable): {
+        bytesRead?: number;
+        bytesWritten?: number;
+        isPaused?: boolean;
+        isEnded?: boolean;
+    };
+}
+declare function getStreamHandler(options?: StreamHandlerOptions): StreamHandler;
+
+interface MetadataInfo {
+    format: {
+        filename: string;
+        format_name: string;
+        format_long_name: string;
+        duration: number;
+        bit_rate: number;
+        size: number;
+        tags?: Record<string, string>;
+    };
+    streams: StreamInfo[];
+    chapters?: ChapterInfo[];
+}
+interface StreamInfo {
+    index: number;
+    codec_name: string;
+    codec_long_name?: string;
+    codec_type: 'video' | 'audio' | 'subtitle' | 'data' | 'attachment';
+    stream_index?: number;
+    width?: number;
+    height?: number;
+    fps?: number;
+    aspect_ratio?: string;
+    pix_fmt?: string;
+    level?: number;
+    profile?: string;
+    bit_rate?: number;
+    sample_rate?: number;
+    channels?: number;
+    channel_layout?: string;
+    bits_per_sample?: number;
+    rotation?: number;
+    tags?: Record<string, string>;
+    displaymatrix?: string;
+    [key: string]: any;
+}
+interface ChapterInfo {
+    id: number;
+    start_time: number;
+    end_time: number;
+    tags?: Record<string, string>;
+}
+declare class MetadataProcessor {
+    private ffprobePath;
+    constructor(ffprobePath?: string);
+    getMetadata(input: string): Promise<MetadataInfo>;
+    private detectRotation;
+    getVideoStream(input: string): Promise<StreamInfo | null>;
+    getAudioStream(input: string, index?: number): Promise<StreamInfo | null>;
+    needsAutoRotate(input: string): Promise<boolean>;
+    getAutoRotateFilter(input: string): Promise<string | null>;
+    getClearRotationCommand(): string[];
+    getDuration(input: string): Promise<number>;
+    getResolution(input: string): Promise<{
+        width: number;
+        height: number;
+    }>;
+    getFrameRate(input: string): Promise<number>;
+    getAudioSampleRate(input: string): Promise<number>;
+    getAudioChannels(input: string): Promise<number>;
+    hasAudio(input: string): Promise<boolean>;
+    hasVideo(input: string): Promise<boolean>;
+    getAllAudioStreams(input: string): Promise<StreamInfo[]>;
+    getAllSubtitleStreams(input: string): Promise<StreamInfo[]>;
+}
+declare function getMetadataProcessor(ffprobePath?: string): MetadataProcessor;
+
+interface PluginDependency {
+    name: string;
+    version: string;
+}
+interface Plugin {
+    name: string;
+    version: string;
+    description?: string;
+    author?: string;
+    dependencies?: PluginDependency[];
+    install: (context: PluginContext) => void | Promise<void>;
+    uninstall?: () => void | Promise<void>;
+}
+interface PluginContext {
+    registerPreset: (name: string, config: PresetConfig) => void;
+    registerProcessor: (name: string, handler: ProcessorHandler) => void;
+    registerChainMethod: (name: string, method: (this: ChainableFFmpeg, ...args: any[]) => ChainableFFmpeg) => void;
+    registerBuilderMethod: (name: string, method: (this: any, ...args: any[]) => any) => void;
+    getVersion: () => string;
+    extendTypes?: (types: any) => any;
+}
+type ProcessorHandler = (instance: ChainableFFmpeg, options?: any) => ChainableFFmpeg | Promise<ChainableFFmpeg>;
+declare class PluginManager {
+    private plugins;
+    private processors;
+    private presetConfigs;
+    private pluginResources;
+    install(plugin: Plugin): Promise<void>;
+    uninstall(pluginName: string): Promise<void>;
+    getPlugin(name: string): Plugin | undefined;
+    listPlugins(): Plugin[];
+    getProcessor(name: string): ProcessorHandler | undefined;
+    getPresetConfig(name: string): PresetConfig | undefined;
+    listPresetConfigs(): Array<{
+        name: string;
+        config: PresetConfig;
+    }>;
+    applyProcessor(name: string, instance: ChainableFFmpeg, options?: any): Promise<ChainableFFmpeg>;
+    has(name: string): boolean;
+    clear(): Promise<void>;
+    getStats(): {
+        pluginCount: number;
+        processorCount: number;
+        presetCount: number;
+    };
+    private checkVersionSatisfied;
+}
+declare function getPluginManager(): PluginManager;
+declare function usePlugin(plugin: Plugin): Promise<void>;
+
+declare function ffmpeg(input?: InputType, options?: FFmpegOptions): ChainableFFmpeg;
+declare function getMetadata(input: string, options?: FFmpegOptions): Promise<VideoMetadata>;
+
+export { type AudioFilterOptions, CacheManager, type CacheOptions$1 as CacheOptions, ChainableFFmpeg, type ChapterInfo, CommandBuilder, ConcurrentQueue, ErrorCode, type FFmpegError, type FFmpegEventListeners, type FFmpegOptions, type FFmpegResult, FFmpegWrapper, HardwareAccelDetector, type HardwareAccelInfo, type HardwareAccelType, type HardwareAcceleration, type InputType, type MetadataInfo, MetadataProcessor, type OutputType, type Plugin, type PluginContext, PluginManager, type PresetConfig, PresetManager, type ProcessorHandler, type ProgressInfo, ProgressParser, type QueueOptions, StreamHandler, type StreamHandlerOptions, type StreamInfo, type StreamType, type Task, type TaskPriority, type TaskStatus, type VideoFilterOptions, type VideoMetadata, createFFmpegError, ffmpeg as default, detectBestHardwareAccel, ffmpeg, getErrorSuggestion, getHardwareAccelDetector, getMetadata, getMetadataProcessor, getPluginManager, getStreamHandler, presets, usePlugin };