@camera.ui/common 0.0.37 → 0.0.39

package/dist/camera/codec-hardware.d.ts

@@ -1,59 +1,178 @@
+/**
+ * Represents a hardware-accelerated video codec
+ */
 export interface HWVideoCodec {
+    /** User-friendly name of the codec */
     name: string;
+    /** FFmpeg codec name */
     codecName: string;
+    /** Type of codec (software or hardware) */
+    type: 'software' | 'hardware';
 }
+/** Array of string arguments for FFmpeg */
 export type HWArgs = string[];
-export interface HWVideoFile {
-    width: number;
-    height: number;
-    path?: string;
-}
+/** FFmpeg version information */
 export interface HWFFmpegVersion {
     major: number;
     minor: number;
     patch: number;
 }
-export type HwAccellMethod = 'auto' | 'cuda' | 'vaapi' | 'videotoolbox' | 'qsv' | 'rkmpp' | 'v4l2m2m';
+/** Hardware acceleration methods supported by FFmpeg */
+export type HwAccelMethod = 'auto' | 'cuda' | 'vaapi' | 'videotoolbox' | 'qsv' | 'rkmpp' | 'v4l2m2m' | 'opencl' | 'vulkan' | 'amf' | 'jetson';
+/**
+ * Class to intelligently select the best VAAPI device
+ */
+export declare class VaapiDeviceSelector {
+    private _selectedGpu;
+    /**
+     * Get the best available VAAPI device
+     * @returns Path to the VAAPI device
+     */
+    getSelectedGpu(): Promise<string>;
+}
+/**
+ * Class to handle hardware-accelerated video encoding with FFmpeg
+ */
 export declare class FFMpegHardware {
-    static VideoCodecN264: HWVideoCodec;
-    static VideoCodecN264H: HWVideoCodec;
-    static VideoCodecI264: HWVideoCodec;
-    static VideoCodecI264C: HWVideoCodec;
-    static VideoCodecM264: HWVideoCodec;
-    static VideoCodecV264: HWVideoCodec;
-    static VideoCodecO264: HWVideoCodec;
-    static VideoCodecRK264: HWVideoCodec;
-    static VideoCodecJetson264: HWVideoCodec;
-    static VideoCodecV4L2M2M264: HWVideoCodec;
-    static VideoCodecVulkan264: HWVideoCodec;
-    static VideoCodecN265: HWVideoCodec;
-    static VideoCodecI265: HWVideoCodec;
-    static VideoCodecM265: HWVideoCodec;
-    static VideoCodecV265: HWVideoCodec;
-    static VideoCodecRK265: HWVideoCodec;
-    static VideoCodecJetson265: HWVideoCodec;
-    static VideoCodecV4L2M2M265: HWVideoCodec;
-    static VideoCodecVulkan265: HWVideoCodec;
-    hwCodecSupport: HWVideoCodec[];
-    private minHeight;
+    static readonly VideoCodecLibx264: HWVideoCodec;
+    static readonly VideoCodecNvenc264: HWVideoCodec;
+    static readonly VideoCodecQsv264: HWVideoCodec;
+    static readonly VideoCodecVaapi264: HWVideoCodec;
+    static readonly VideoCodecAmf264: HWVideoCodec;
+    static readonly VideoCodecToolbox264: HWVideoCodec;
+    static readonly VideoCodecOmx264: HWVideoCodec;
+    static readonly VideoCodecRkmpp264: HWVideoCodec;
+    static readonly VideoCodecJetson264: HWVideoCodec;
+    static readonly VideoCodecV4L2M2M264: HWVideoCodec;
+    static readonly VideoCodecVulkan264: HWVideoCodec;
+    static readonly VideoCodecOpenCL264: HWVideoCodec;
+    static readonly VideoCodecLibx265: HWVideoCodec;
+    static readonly VideoCodecNvenc265: HWVideoCodec;
+    static readonly VideoCodecQsv265: HWVideoCodec;
+    static readonly VideoCodecVaapi265: HWVideoCodec;
+    static readonly VideoCodecAmf265: HWVideoCodec;
+    static readonly VideoCodecToolbox265: HWVideoCodec;
+    static readonly VideoCodecOmx265: HWVideoCodec;
+    static readonly VideoCodecRkmpp265: HWVideoCodec;
+    static readonly VideoCodecJetson265: HWVideoCodec;
+    static readonly VideoCodecV4L2M2M265: HWVideoCodec;
+    static readonly VideoCodecVulkan265: HWVideoCodec;
+    static readonly VideoCodecOpenCL265: HWVideoCodec;
+    /** List of supported hardware codecs on the current system */
+    supportedCodecs: HWVideoCodec[];
     private scalerRegex;
     private _ffmpegPath;
-    private ffmpegPathChanged;
-    get ffmpegPath(): string;
+    private _userAgent;
+    private _vaapiDeviceSelector;
+    private _ffmpegVersion;
+    /** Get all supported H.264 codecs */
     static get H264Codecs(): HWVideoCodec[];
+    /** Get all supported H.265 codecs */
     static get H265Codecs(): HWVideoCodec[];
-    constructor(_ffmpegPath?: string);
-    setFfmpegPath(_ffmpegPath: string): void;
-    initHWSupport(): Promise<void>;
-    hwDeviceInit(args: HWArgs, toCodec: HWVideoCodec): HWArgs;
-    codecInit(codec: HWVideoCodec): HWArgs;
-    hwDeviceArgs(toCodec: HWVideoCodec): HWArgs;
-    hwFilterInit(toCodec: HWVideoCodec, fullhw?: boolean): string;
-    hwApplyScaleTemplate(sargs: string, toCodec: HWVideoCodec, targetWidth: number, targetHeight: number): string;
-    hwApplyFullHWFilter(args: string, toCodec: HWVideoCodec, fullhw: boolean): string;
-    hwMaxResFilter(toCodec: HWVideoCodec, vf: HWVideoFile, reqHeight: number, fullhw: boolean): string | null;
-    getHwaccelMethod(codec: HWVideoCodec): HwAccellMethod;
-    private executeFFmpeg;
-    private calculateTargetDimensions;
-    hwCodecMaxRes(codec: HWVideoCodec): [number, number];
+    /**
+     * Create a new FFMpegHardware instance
+     * @param _ffmpegPath Path to the FFmpeg executable
+     * @param userAgent Custom user agent for FFmpeg requests
+     */
+    constructor(_ffmpegPath?: string, userAgent?: string);
+    /**
+     * Get FFmpeg version information
+     * @returns Version object with major, minor, and patch numbers
+     */
+    getFFmpegVersion(): Promise<HWFFmpegVersion>;
+    /**
+     * Filter codecs based on current system architecture and OS
+     * @returns Filtered array of codecs that are likely to work on this system
+     */
+    getSystemCompatibleCodecs(): HWVideoCodec[];
+    /**
+     * Initialize hardware acceleration support by testing specific codecs
+     * @param codecs List of codecs to test
+     */
+    detectSupportedCodecsFromList(codecs: HWVideoCodec[]): Promise<void>;
+    /**
+     * Initialize hardware acceleration support by testing available codecs
+     */
+    detectSupportedCodecs(): Promise<void>;
+    /**
+     * Create platform-specific probe arguments for testing codec support
+     * @param codec Codec to test
+     * @returns FFmpeg arguments for testing
+     */
+    private createPlatformSpecificProbeArgs;
+    /**
+     * Set up hardware device initialization arguments
+     * @param args Existing FFmpeg arguments
+     * @param codec Target codec to set up
+     * @returns Updated arguments array
+     */
+    setupHardwareDevice(args: HWArgs, codec: HWVideoCodec): Promise<HWArgs>;
+    /**
+     * Add codec-specific encoding parameters
+     * @param codec Target codec
+     * @returns Array of FFmpeg arguments for the codec
+     */
+    getCodecSpecificArgs(codec: HWVideoCodec): HWArgs;
+    /**
+     * Create complete hardware filter chain for scaling and processing
+     * @param codec Target codec
+     * @param requestedWidth Desired output width
+     * @param requestedHeight Desired output height
+     * @param keepOnHardware Whether to keep processing on hardware
+     * @param pixelFormat Optional specific pixel format for output
+     * @returns Complete filter string or null
+     */
+    createHardwareFilter(codec: HWVideoCodec, requestedWidth?: number, requestedHeight?: number, keepOnHardware?: boolean, pixelFormat?: string): string | null;
+    /**
+     * Create filter chain for software encoders
+     * @param requestedWidth Desired output width
+     * @param requestedHeight Desired output height
+     * @param pixelFormat Optional specific pixel format for output
+     * @returns Filter string for software encoding
+     */
+    createSoftwareFilter(requestedWidth?: number, requestedHeight?: number, pixelFormat?: string): string;
+    /**
+     * Get initial filter setup for hardware pipeline
+     * @param codec Target codec
+     * @param keepOnHardware Whether to keep processing on hardware (true) or use hybrid pipeline (false)
+     * @returns Initial filter string
+     */
+    createInitialFilter(codec: HWVideoCodec, keepOnHardware?: boolean): string;
+    /**
+     * Apply hardware-specific scaling template
+     * @param currentFilter Current filter string
+     * @param codec Target codec
+     * @param width Target width
+     * @param height Target height
+     * @returns Updated filter string with hardware-specific scaling
+     */
+    applyScalingFilter(currentFilter: string, codec: HWVideoCodec, width: number, height: number): string;
+    /**
+     * Add final filters to bring data back to CPU if needed and handle format conversion
+     * @param currentFilter Current filter string
+     * @param codec Target codec
+     * @param keepOnHardware Whether to keep processing on hardware
+     * @param pixelFormat Optional specific pixel format for output
+     * @returns Final filter chain
+     */
+    finalizePipeline(currentFilter: string, codec: HWVideoCodec, keepOnHardware: boolean, pixelFormat?: string): string;
+    /**
+     * Determine the hardware acceleration method used by a codec
+     * @param codec Target codec
+     * @returns Hardware acceleration method
+     */
+    getHardwareMethod(codec: HWVideoCodec): HwAccelMethod;
+    /**
+     * Execute FFmpeg with given arguments
+     * @param args FFmpeg arguments
+     * @returns Promise that resolves when FFmpeg completes successfully
+     */
+    private runFFmpeg;
+    /**
+     * Calculate output dimensions
+     * @param targetWidth Desired output width
+     * @param targetHeight Desired output height
+     * @returns [width, height] tuple with even dimensions
+     */
+    private calculateOutputDimensions;
 }