node-av 1.0.2 → 1.1.0

package/dist/api/filter-presets.js

@@ -0,0 +1,823 @@
+/**
+ * FilterPresets - Pre-defined filter configurations
+ *
+ * Provides convenient filter string builders for common operations.
+ * Includes both software and hardware-accelerated filter presets.
+ *
+ * Simplifies filter creation with type-safe parameter handling.
+ * Supports platform-specific hardware acceleration capabilities.
+ *
+ * @module api/filter-presets
+ */
+import { AV_HWDEVICE_TYPE_CUDA, AV_HWDEVICE_TYPE_D3D11VA, AV_HWDEVICE_TYPE_D3D12VA, AV_HWDEVICE_TYPE_DRM, AV_HWDEVICE_TYPE_DXVA2, AV_HWDEVICE_TYPE_MEDIACODEC, AV_HWDEVICE_TYPE_OPENCL, AV_HWDEVICE_TYPE_QSV, AV_HWDEVICE_TYPE_RKMPP, AV_HWDEVICE_TYPE_VAAPI, AV_HWDEVICE_TYPE_VDPAU, AV_HWDEVICE_TYPE_VIDEOTOOLBOX, AV_HWDEVICE_TYPE_VULKAN, AVFILTER_FLAG_HWDEVICE, } from '../constants/constants.js';
+import { Filter } from '../lib/filter.js';
+import { avGetPixFmtName, avGetSampleFmtName } from '../lib/utilities.js';
+/**
+ * Base class for filter preset implementations.
+ * Provides common filter building methods that can be overridden.
+ */
+export class FilterPresetBase {
+    /**
+     * Scale video to specified dimensions.
+     * @returns Filter string or null if not supported
+     */
+    scale(width, height, options) {
+        const flags = options?.flags;
+        const base = `scale=${width}:${height}`;
+        return flags ? `${base}:flags=${flags}` : base;
+    }
+    /**
+     * Crop video to specified dimensions.
+     */
+    crop(width, height, x = 0, y = 0) {
+        return `crop=${width}:${height}:${x}:${y}`;
+    }
+    /**
+     * Change frame rate.
+     */
+    fps(fps) {
+        return `fps=${fps}`;
+    }
+    /**
+     * Convert pixel format.
+     * Can accept a single format or an array of formats for fallback.
+     * Multiple formats will create a chain: format=fmt1,format=fmt2,...
+     */
+    format(pixelFormat) {
+        if (Array.isArray(pixelFormat)) {
+            // Create a chain of format filters
+            const formats = pixelFormat.map((fmt) => {
+                const formatName = typeof fmt === 'string' ? fmt : (avGetPixFmtName(fmt) ?? 'yuv420p');
+                return `format=${formatName}`;
+            });
+            return formats.join(',');
+        }
+        const formatName = typeof pixelFormat === 'string' ? pixelFormat : (avGetPixFmtName(pixelFormat) ?? 'yuv420p');
+        return `format=${formatName}`;
+    }
+    /**
+     * Rotate video by angle.
+     */
+    rotate(angle) {
+        return `rotate=${angle}*PI/180`;
+    }
+    /**
+     * Flip video horizontally.
+     */
+    hflip() {
+        return 'hflip';
+    }
+    /**
+     * Flip video vertically.
+     */
+    vflip() {
+        return 'vflip';
+    }
+    /**
+     * Apply fade effect.
+     */
+    fade(type, start, duration) {
+        return `fade=t=${type}:st=${start}:d=${duration}`;
+    }
+    /**
+     * Overlay one video on another.
+     */
+    overlay(x = 0, y = 0, options) {
+        let filter = `overlay=${x}:${y}`;
+        if (options) {
+            for (const [key, value] of Object.entries(options)) {
+                filter += `:${key}=${value}`;
+            }
+        }
+        return filter;
+    }
+    /**
+     * Adjust audio volume.
+     */
+    volume(factor) {
+        return `volume=${factor}`;
+    }
+    /**
+     * Convert audio sample format.
+     */
+    aformat(sampleFormat, sampleRate, channelLayout) {
+        const formatName = typeof sampleFormat === 'string' ? sampleFormat : (avGetSampleFmtName(sampleFormat) ?? 's16');
+        let filter = `aformat=sample_fmts=${formatName}`;
+        if (sampleRate)
+            filter += `:sample_rates=${sampleRate}`;
+        if (channelLayout)
+            filter += `:channel_layouts=${channelLayout}`;
+        return filter;
+    }
+    /**
+     * Change audio tempo without changing pitch.
+     */
+    atempo(factor) {
+        return `atempo=${factor}`;
+    }
+    /**
+     * Apply audio fade.
+     */
+    afade(type, start, duration) {
+        return `afade=t=${type}:st=${start}:d=${duration}`;
+    }
+    /**
+     * Mix multiple audio streams.
+     */
+    amix(inputs = 2, duration = 'longest') {
+        return `amix=inputs=${inputs}:duration=${duration}`;
+    }
+}
+/**
+ * Filter chain builder for composing multiple filters.
+ * Allows fluent API for building complex filter graphs.
+ */
+export class FilterChain {
+    filters = [];
+    /**
+     * Add a filter to the chain.
+     * @param filter - Filter string or null/undefined (will be skipped)
+     */
+    add(filter) {
+        if (filter) {
+            this.filters.push(filter);
+        }
+        return this;
+    }
+    /**
+     * Add a custom filter string.
+     */
+    custom(filter) {
+        return this.add(filter);
+    }
+    /**
+     * Build the filter chain string.
+     * @param separator - Separator between filters (default: ',')
+     */
+    build(separator = ',') {
+        return this.filters.join(separator);
+    }
+    /**
+     * Get the filter array.
+     */
+    toArray() {
+        return [...this.filters];
+    }
+}
+/**
+ * Base chain builder with common filter methods.
+ * @template T The preset type this builder uses
+ */
+export class ChainBuilderBase extends FilterChain {
+    presets;
+    constructor(presets) {
+        super();
+        this.presets = presets;
+    }
+    scale(width, height, options) {
+        return this.add(this.presets.scale(width, height, options));
+    }
+    crop(width, height, x = 0, y = 0) {
+        return this.add(this.presets.crop(width, height, x, y));
+    }
+    fps(fps) {
+        return this.add(this.presets.fps(fps));
+    }
+    format(pixelFormat) {
+        return this.add(this.presets.format(pixelFormat));
+    }
+    rotate(angle) {
+        return this.add(this.presets.rotate(angle));
+    }
+    hflip() {
+        return this.add(this.presets.hflip());
+    }
+    vflip() {
+        return this.add(this.presets.vflip());
+    }
+    fade(type, start, duration) {
+        return this.add(this.presets.fade(type, start, duration));
+    }
+    overlay(x = 0, y = 0, options) {
+        return this.add(this.presets.overlay(x, y, options));
+    }
+    volume(factor) {
+        return this.add(this.presets.volume(factor));
+    }
+    aformat(sampleFormat, sampleRate, channelLayout) {
+        return this.add(this.presets.aformat(sampleFormat, sampleRate, channelLayout));
+    }
+    atempo(factor) {
+        return this.add(this.presets.atempo(factor));
+    }
+    afade(type, start, duration) {
+        return this.add(this.presets.afade(type, start, duration));
+    }
+    amix(inputs = 2, duration = 'longest') {
+        return this.add(this.presets.amix(inputs, duration));
+    }
+    // Hardware-specific methods (only available if presets support them)
+    transpose(dir = 0) {
+        if ('transpose' in this.presets) {
+            return this.add(this.presets.transpose(dir));
+        }
+        return this.add(null);
+    }
+    tonemap(options) {
+        if ('tonemap' in this.presets) {
+            return this.add(this.presets.tonemap(options));
+        }
+        return this.add(null);
+    }
+    deinterlace(mode) {
+        if ('deinterlace' in this.presets) {
+            return this.add(this.presets.deinterlace(mode));
+        }
+        return this.add(null);
+    }
+    flip(direction) {
+        if ('flip' in this.presets) {
+            return this.add(this.presets.flip(direction));
+        }
+        // Fallback to hflip/vflip
+        return direction === 'h' ? this.hflip() : this.vflip();
+    }
+    blur(type = 'avg', radius) {
+        if ('blur' in this.presets) {
+            return this.add(this.presets.blur(type, radius));
+        }
+        return this.add(null);
+    }
+    sharpen(amount) {
+        if ('sharpen' in this.presets) {
+            return this.add(this.presets.sharpen(amount));
+        }
+        return this.add(null);
+    }
+    stack(type, inputs = 2) {
+        if ('stack' in this.presets) {
+            return this.add(this.presets.stack(type, inputs));
+        }
+        return this.add(null);
+    }
+    hwupload() {
+        if ('hwupload' in this.presets) {
+            return this.add(this.presets.hwupload());
+        }
+        return this.add('hwupload');
+    }
+    hwdownload() {
+        if ('hwdownload' in this.presets) {
+            return this.add(this.presets.hwdownload());
+        }
+        return this.add('hwdownload');
+    }
+    hwmap(derive) {
+        if ('hwmap' in this.presets) {
+            return this.add(this.presets.hwmap(derive));
+        }
+        return this.add(derive ? `hwmap=derive_device=${derive}` : 'hwmap');
+    }
+}
+/**
+ * Fluent filter chain builder with preset methods.
+ */
+export class FilterChainBuilder extends ChainBuilderBase {
+}
+/**
+ * Common filter presets for convenience.
+ *
+ * Provides pre-defined filter strings for common operations.
+ * Can be used with Filter.create() for quick setup.
+ *
+ * @example
+ * ```typescript
+ * const filter = await Filter.create(
+ *   FilterPresets.scale(1280, 720),
+ *   config
+ * );
+ *
+ * // Using chain builder
+ * const chain = FilterPresets.chain()
+ *   .scale(1920, 1080)
+ *   .format('yuv420p')
+ *   .custom('unsharp=5:5:1.0')
+ *   .build();
+ * ```
+ */
+export class FilterPresets extends FilterPresetBase {
+    static instance = new FilterPresets();
+    /**
+     * Create a new filter chain builder.
+     */
+    static chain() {
+        return new FilterChainBuilder(FilterPresets.instance);
+    }
+    // Static methods that delegate to instance
+    static scale(width, height, flags) {
+        const result = FilterPresets.instance.scale(width, height, { flags });
+        return result ?? '';
+    }
+    static crop(width, height, x = 0, y = 0) {
+        const result = FilterPresets.instance.crop(width, height, x, y);
+        return result ?? '';
+    }
+    static fps(fps) {
+        const result = FilterPresets.instance.fps(fps);
+        return result ?? '';
+    }
+    static format(pixelFormat) {
+        const result = FilterPresets.instance.format(pixelFormat);
+        return result ?? '';
+    }
+    static rotate(angle) {
+        const result = FilterPresets.instance.rotate(angle);
+        return result ?? '';
+    }
+    static hflip() {
+        const result = FilterPresets.instance.hflip();
+        return result ?? '';
+    }
+    static vflip() {
+        const result = FilterPresets.instance.vflip();
+        return result ?? '';
+    }
+    static fade(type, start, duration) {
+        const result = FilterPresets.instance.fade(type, start, duration);
+        return result ?? '';
+    }
+    static overlay(x = 0, y = 0) {
+        const result = FilterPresets.instance.overlay(x, y);
+        return result ?? '';
+    }
+    static volume(factor) {
+        const result = FilterPresets.instance.volume(factor);
+        return result ?? '';
+    }
+    static aformat(sampleFormat, sampleRate, channelLayout) {
+        const result = FilterPresets.instance.aformat(sampleFormat, sampleRate, channelLayout);
+        return result ?? '';
+    }
+    static atempo(factor) {
+        const result = FilterPresets.instance.atempo(factor);
+        return result ?? '';
+    }
+    static afade(type, start, duration) {
+        const result = FilterPresets.instance.afade(type, start, duration);
+        return result ?? '';
+    }
+    static amix(inputs = 2, duration = 'longest') {
+        const result = FilterPresets.instance.amix(inputs, duration);
+        return result ?? '';
+    }
+}
+/**
+ * Hardware-accelerated filter presets.
+ *
+ * Provides hardware-specific filter strings for accelerated processing.
+ * Created and managed by HardwareContext for type-safe hardware operations.
+ *
+ * @example
+ * ```typescript
+ * const hw = await HardwareContext.auto();
+ * if (hw) {
+ *   // Get hardware-specific scale filter (returns null if unsupported)
+ *   const scaleFilter = hw.filterPresets.scale(1920, 1080);
+ *
+ *   // Build a filter chain (unsupported filters are skipped)
+ *   const chain = hw.filterPresets.chain()
+ *     .hwupload()
+ *     .scale(1920, 1080)
+ *     .tonemap()  // Skipped if not supported
+ *     .custom('unsharp=5:5:1.0')
+ *     .hwdownload()
+ *     .build();
+ * }
+ * ```
+ */
+export class HardwareFilterPresets extends FilterPresetBase {
+    deviceType;
+    deviceName;
+    support;
+    /**
+     * Create hardware filter presets for a specific device type.
+     * @internal Used by HardwareContext
+     */
+    constructor(deviceType, deviceName = null) {
+        super();
+        this.deviceType = deviceType;
+        this.deviceName = deviceName ?? 'unknown';
+        this.support = this.getSupport();
+    }
+    /**
+     * Check if a filter name is a hardware-accelerated filter.
+     * Uses FFmpeg's AVFILTER_FLAG_HWDEVICE flag to determine if a filter is hardware-accelerated.
+     * @param filterName - The filter name to check
+     * @returns True if it's a hardware filter, false otherwise
+     */
+    static isHardwareFilter(filterName) {
+        const filter = Filter.getByName(filterName);
+        if (!filter) {
+            return false;
+        }
+        // Check if filter has hardware device flag
+        return (filter.flags & AVFILTER_FLAG_HWDEVICE) !== 0;
+    }
+    /**
+     * Create a new hardware filter chain builder.
+     */
+    chain() {
+        return new HardwareFilterChainBuilder(this);
+    }
+    /**
+     * Hardware-accelerated scale filter.
+     * @returns Filter string or null if not supported
+     */
+    scale(width, height, options) {
+        if (!this.support.scale) {
+            return null;
+        }
+        // Special handling for different hardware scalers
+        let filterName;
+        if (this.deviceType === AV_HWDEVICE_TYPE_CUDA && options?.npp) {
+            filterName = 'scale_npp';
+        }
+        else if (this.deviceType === AV_HWDEVICE_TYPE_RKMPP) {
+            filterName = 'scale_rkrga'; // RKMPP uses RGA for scaling
+        }
+        else if (this.deviceType === AV_HWDEVICE_TYPE_VIDEOTOOLBOX) {
+            filterName = 'scale_vt'; // VideoToolbox uses scale_vt
+        }
+        else {
+            filterName = `scale_${this.deviceName}`;
+        }
+        let filter = `${filterName}=${width}:${height}`;
+        if (options) {
+            for (const [key, value] of Object.entries(options)) {
+                if (key !== 'npp') {
+                    // Skip our special npp flag
+                    filter += `:${key}=${value}`;
+                }
+            }
+        }
+        return filter;
+    }
+    /**
+     * Hardware-accelerated overlay filter.
+     * @returns Filter string or null if not supported
+     */
+    overlay(x = 0, y = 0, options) {
+        if (!this.support.overlay) {
+            return null;
+        }
+        // Special handling for RKMPP which uses RGA
+        const filterName = this.deviceType === AV_HWDEVICE_TYPE_RKMPP ? 'overlay_rkrga' : `overlay_${this.deviceName}`;
+        let filter = `${filterName}=${x}:${y}`;
+        if (options) {
+            for (const [key, value] of Object.entries(options)) {
+                filter += `:${key}=${value}`;
+            }
+        }
+        return filter;
+    }
+    /**
+     * Hardware-accelerated transpose filter.
+     * @returns Filter string or null if not supported
+     */
+    transpose(dir = 0) {
+        if (!this.support.transpose) {
+            return null;
+        }
+        // Special handling for different hardware transpose implementations
+        let filterName;
+        if (this.deviceType === AV_HWDEVICE_TYPE_CUDA) {
+            filterName = 'transpose_cuda'; // Uses transpose_cuda from patch, not NPP
+        }
+        else if (this.deviceType === AV_HWDEVICE_TYPE_VIDEOTOOLBOX) {
+            filterName = 'transpose_vt'; // CoreImage-based transpose
+        }
+        else {
+            filterName = `transpose_${this.deviceName}`;
+        }
+        return `${filterName}=dir=${dir}`;
+    }
+    /**
+     * Hardware-accelerated tonemap filter.
+     * @returns Filter string or null if not supported
+     */
+    tonemap(options) {
+        if (!this.support.tonemap) {
+            return null;
+        }
+        // VideoToolbox uses different filter name
+        const filterName = this.deviceType === AV_HWDEVICE_TYPE_VIDEOTOOLBOX ? 'tonemap_videotoolbox' : `tonemap_${this.deviceName}`;
+        let filter = filterName;
+        if (options) {
+            const opts = Object.entries(options)
+                .map(([k, v]) => `${k}=${v}`)
+                .join(':');
+            filter += `=${opts}`;
+        }
+        return filter;
+    }
+    /**
+     * Hardware-accelerated deinterlace filter.
+     * @returns Filter string or null if not supported
+     */
+    deinterlace(mode) {
+        if (!this.support.deinterlace) {
+            return null;
+        }
+        switch (this.deviceType) {
+            case AV_HWDEVICE_TYPE_CUDA:
+                return mode ? `yadif_cuda=mode=${mode}` : 'yadif_cuda';
+            case AV_HWDEVICE_TYPE_VAAPI:
+                return mode ? `deinterlace_vaapi=mode=${mode}` : 'deinterlace_vaapi';
+            case AV_HWDEVICE_TYPE_QSV:
+                return mode ? `deinterlace_qsv=mode=${mode}` : 'deinterlace_qsv';
+            case AV_HWDEVICE_TYPE_VULKAN:
+                return mode ? `bwdif_vulkan=mode=${mode}` : 'bwdif_vulkan';
+            case AV_HWDEVICE_TYPE_VIDEOTOOLBOX:
+                return mode ? `yadif_videotoolbox=mode=${mode}` : 'yadif_videotoolbox';
+            default:
+                return null;
+        }
+    }
+    /**
+     * Hardware-accelerated flip filter.
+     * @returns Filter string or null if not supported
+     */
+    flip(direction) {
+        if (!this.support.flip) {
+            return null;
+        }
+        if (this.deviceType === AV_HWDEVICE_TYPE_VULKAN) {
+            return direction === 'h' ? 'hflip_vulkan' : 'vflip_vulkan';
+        }
+        return null;
+    }
+    /**
+     * Hardware-accelerated blur filter.
+     * @returns Filter string or null if not supported
+     */
+    blur(type = 'avg', radius) {
+        if (!this.support.blur) {
+            return null;
+        }
+        switch (this.deviceType) {
+            case AV_HWDEVICE_TYPE_CUDA:
+                return radius ? `bilateral_cuda=sigmaS=${radius}` : 'bilateral_cuda';
+            case AV_HWDEVICE_TYPE_VULKAN:
+                return type === 'gaussian' ? (radius ? `gblur_vulkan=sigma=${radius}` : 'gblur_vulkan') : radius ? `avgblur_vulkan=sizeX=${radius}` : 'avgblur_vulkan';
+            case AV_HWDEVICE_TYPE_OPENCL:
+                return type === 'box' ? (radius ? `boxblur_opencl=luma_radius=${radius}` : 'boxblur_opencl') : radius ? `avgblur_opencl=sizeX=${radius}` : 'avgblur_opencl';
+            default:
+                return null;
+        }
+    }
+    /**
+     * Hardware-accelerated sharpen filter.
+     * @returns Filter string or null if not supported
+     */
+    sharpen(amount) {
+        if (!this.support.sharpen) {
+            return null;
+        }
+        switch (this.deviceType) {
+            case AV_HWDEVICE_TYPE_VAAPI:
+                return amount ? `sharpness_vaapi=sharpness=${amount}` : 'sharpness_vaapi';
+            case AV_HWDEVICE_TYPE_OPENCL:
+                return amount ? `unsharp_opencl=amount=${amount}` : 'unsharp_opencl';
+            case AV_HWDEVICE_TYPE_CUDA:
+                // CUDA uses NPP for sharpening
+                return 'sharpen_npp';
+            default:
+                return null;
+        }
+    }
+    /**
+     * Hardware-accelerated stack filters (hstack, vstack, xstack).
+     * @returns Filter string or null if not supported
+     */
+    stack(type, inputs = 2) {
+        if (!this.support.stack) {
+            return null;
+        }
+        if (this.deviceType === AV_HWDEVICE_TYPE_VAAPI || this.deviceType === AV_HWDEVICE_TYPE_QSV) {
+            return `${type}stack_${this.deviceName}=inputs=${inputs}`;
+        }
+        return null;
+    }
+    /**
+     * Hardware upload filter to transfer frames to GPU.
+     */
+    hwupload() {
+        if (this.deviceType === AV_HWDEVICE_TYPE_CUDA) {
+            return 'hwupload_cuda';
+        }
+        return 'hwupload';
+    }
+    /**
+     * Hardware download filter to transfer frames from GPU.
+     */
+    hwdownload() {
+        return 'hwdownload';
+    }
+    /**
+     * Format conversion for hardware frames.
+     */
+    hwmap(derive) {
+        return derive ? `hwmap=derive_device=${derive}` : 'hwmap';
+    }
+    /**
+     * Get capabilities for this hardware type.
+     */
+    getCapabilities() {
+        return this.support;
+    }
+    /**
+     * Get supported filters for this hardware type.
+     */
+    getSupport() {
+        switch (this.deviceType) {
+            case AV_HWDEVICE_TYPE_CUDA:
+                return {
+                    scale: true, // scale_cuda
+                    overlay: true, // overlay_cuda
+                    transpose: true, // transpose_cuda (patch 0054)
+                    tonemap: true, // tonemap_cuda (patch 0004)
+                    deinterlace: true, // bwdif_cuda, yadif_cuda
+                    denoise: false,
+                    flip: false,
+                    blur: true, // bilateral_cuda
+                    sharpen: false, // Uses NPP
+                    chromakey: true, // chromakey_cuda
+                    colorspace: true, // colorspace_cuda
+                    pad: false,
+                    stack: false,
+                };
+            case AV_HWDEVICE_TYPE_VAAPI:
+                return {
+                    scale: true, // scale_vaapi
+                    overlay: true, // overlay_vaapi
+                    transpose: true, // transpose_vaapi
+                    tonemap: true, // tonemap_vaapi
+                    deinterlace: true, // deinterlace_vaapi
+                    denoise: true, // denoise_vaapi
+                    flip: false,
+                    blur: false,
+                    sharpen: true, // sharpness_vaapi
+                    chromakey: false,
+                    colorspace: false,
+                    pad: true, // pad_vaapi
+                    stack: true, // hstack_vaapi, vstack_vaapi, xstack_vaapi
+                };
+            case AV_HWDEVICE_TYPE_QSV:
+                return {
+                    scale: true, // scale_qsv
+                    overlay: true, // overlay_qsv
+                    transpose: false,
+                    tonemap: false,
+                    deinterlace: true, // deinterlace_qsv
+                    denoise: false,
+                    flip: false,
+                    blur: false,
+                    sharpen: false,
+                    chromakey: false,
+                    colorspace: false,
+                    pad: false,
+                    stack: true, // hstack_qsv, vstack_qsv, xstack_qsv
+                };
+            case AV_HWDEVICE_TYPE_VULKAN:
+                return {
+                    scale: true, // scale_vulkan
+                    overlay: true, // overlay_vulkan
+                    transpose: true, // transpose_vulkan
+                    tonemap: false,
+                    deinterlace: true, // bwdif_vulkan
+                    denoise: false,
+                    flip: true, // flip_vulkan, hflip_vulkan, vflip_vulkan
+                    blur: true, // avgblur_vulkan, gblur_vulkan
+                    sharpen: false,
+                    chromakey: false,
+                    colorspace: false,
+                    pad: false,
+                    stack: false,
+                };
+            case AV_HWDEVICE_TYPE_OPENCL:
+                return {
+                    scale: true, // scale_opencl (patch 0006)
+                    overlay: true, // overlay_opencl (+ PGS support patch 0008)
+                    transpose: true, // transpose_opencl
+                    tonemap: true, // tonemap_opencl (enhanced in patch 0007)
+                    deinterlace: false,
+                    denoise: false,
+                    flip: false,
+                    blur: true, // avgblur_opencl, boxblur_opencl
+                    sharpen: true, // unsharp_opencl
+                    chromakey: true, // colorkey_opencl
+                    colorspace: false,
+                    pad: true, // pad_opencl
+                    stack: false,
+                };
+            case AV_HWDEVICE_TYPE_VIDEOTOOLBOX:
+                return {
+                    scale: true, // scale_vt (patch 0047 adds format option)
+                    overlay: true, // overlay_videotoolbox (patch 0048)
+                    transpose: true, // transpose_vt (patch 0049, CoreImage based)
+                    tonemap: true, // tonemap_videotoolbox (patch 0050)
+                    deinterlace: true, // yadif_videotoolbox
+                    denoise: false,
+                    flip: false,
+                    blur: false,
+                    sharpen: false,
+                    chromakey: false,
+                    colorspace: false,
+                    pad: false,
+                    stack: false,
+                };
+            case AV_HWDEVICE_TYPE_MEDIACODEC:
+                // MediaCodec is Android's hardware acceleration - mainly for decode/encode
+                return {
+                    scale: false,
+                    overlay: false,
+                    transpose: false,
+                    tonemap: false,
+                    deinterlace: false,
+                    denoise: false,
+                    flip: false,
+                    blur: false,
+                    sharpen: false,
+                    chromakey: false,
+                    colorspace: false,
+                    pad: false,
+                    stack: false,
+                };
+            case AV_HWDEVICE_TYPE_RKMPP: // Rockchip - has RGA filters via patch 0046
+                // Note: RKMPP uses separate RKRGA (Rockchip 2D Raster Graphic Acceleration)
+                // for filtering operations, configured with --enable-rkrga
+                return {
+                    scale: true, // scale_rkrga (patch 0046)
+                    overlay: true, // overlay_rkrga (patch 0046)
+                    transpose: false,
+                    tonemap: false,
+                    deinterlace: false,
+                    denoise: false,
+                    flip: false,
+                    blur: false,
+                    sharpen: false,
+                    chromakey: false,
+                    colorspace: false,
+                    pad: false,
+                    stack: false,
+                };
+            // These hardware types don't have dedicated filters - they're mainly for decode/encode
+            case AV_HWDEVICE_TYPE_VDPAU: // Decode-only, deprecated in favor of VAAPI
+            case AV_HWDEVICE_TYPE_DXVA2: // Windows decode-only
+            case AV_HWDEVICE_TYPE_D3D11VA: // Windows decode-only
+            case AV_HWDEVICE_TYPE_D3D12VA: // Has HEVC encoder but no filters
+            case AV_HWDEVICE_TYPE_DRM: // Linux DRM buffer sharing, not processing
+                return {
+                    scale: false,
+                    overlay: false,
+                    transpose: false,
+                    tonemap: false,
+                    deinterlace: false,
+                    denoise: false,
+                    flip: false,
+                    blur: false,
+                    sharpen: false,
+                    chromakey: false,
+                    colorspace: false,
+                    pad: false,
+                    stack: false,
+                };
+            default:
+                // Unknown hardware - no support
+                // NPP is not a separate hardware type, it's CUDA-based
+                // We handle it through CUDA with special filter names
+                return {
+                    scale: false,
+                    overlay: false,
+                    transpose: false,
+                    tonemap: false,
+                    deinterlace: false,
+                    denoise: false,
+                    flip: false,
+                    blur: false,
+                    sharpen: false,
+                    chromakey: false,
+                    colorspace: false,
+                    pad: false,
+                    stack: false,
+                };
+        }
+    }
+}
+/**
+ * Hardware filter chain builder with fluent API.
+ * Automatically skips unsupported filters (returns null).
+ */
+export class HardwareFilterChainBuilder extends ChainBuilderBase {
+}
+//# sourceMappingURL=filter-presets.js.map