node-av 0.0.1

package/dist/lib/error.js

@@ -0,0 +1,254 @@
+import { bindings } from './binding.js';
+/**
+ * FFmpeg error handling.
+ *
+ * Represents FFmpeg errors with error codes and human-readable messages.
+ * Provides utilities for error checking and throwing.
+ * Essential for proper error handling in FFmpeg operations.
+ *
+ * Direct mapping to FFmpeg's error system.
+ *
+ * @example
+ * ```typescript
+ * import { FFmpegError } from 'node-av';
+ *
+ * // Check return codes
+ * const ret = await codecContext.sendPacket(packet);
+ * FFmpegError.throwIfError(ret, 'sendPacket');
+ *
+ * // Handle specific errors
+ * try {
+ *   const openRet = await formatContext.openInput('file.mp4', null, null);
+ *   FFmpegError.throwIfError(openRet, 'openInput');
+ * } catch (error) {
+ *   if (error instanceof FFmpegError) {
+ *     console.error(`Error code: ${error.code}`);
+ *     console.error(`Message: ${error.message}`);
+ *   }
+ * }
+ * ```
+ */
+export class FFmpegError extends Error {
+    native;
+    /**
+     * Create a new FFmpegError instance.
+     *
+     * Wraps an FFmpeg error code with a JavaScript Error.
+     * Automatically retrieves the error message from FFmpeg.
+     *
+     * Direct wrapper around FFmpeg error codes.
+     *
+     * @param code - FFmpeg error code (negative number)
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AVERROR_EOF } from 'node-av/constants';
+     *
+     * const error = new FFmpegError(AVERROR_EOF);
+     * console.log(error.message); // "End of file"
+     * console.log(error.code);    // -541478725
+     * ```
+     */
+    constructor(code) {
+        const native = new bindings.FFmpegError(code);
+        const message = code !== undefined ? native.message : 'FFmpeg Error';
+        super(message);
+        this.native = native;
+        this.name = 'FFmpegError';
+        // Maintain proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, FFmpegError);
+        }
+    }
+    /**
+     * Put a description of the AVERROR code errnum in a string.
+     *
+     * Converts an error code to a human-readable message.
+     *
+     * Direct mapping to av_strerror()
+     *
+     * @param errnum - Error code to describe
+     *
+     * @returns Error description string
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AVERROR_EAGAIN, AVERROR_EOF } from 'node-av/constants';
+     *
+     * const message = FFmpegError.strerror(AVERROR_EAGAIN);
+     * console.log(message); // "Resource temporarily unavailable"
+     *
+     * const message2 = FFmpegError.strerror(AVERROR_EOF);
+     * console.log(message2); // "End of file"
+     * ```
+     */
+    static strerror(errnum) {
+        return bindings.FFmpegError.strerror(errnum);
+    }
+    /**
+     * Convert a POSIX error code to FFmpeg error code.
+     *
+     * Converts standard POSIX error codes to FFmpeg's error format.
+     *
+     * Direct mapping to AVERROR() macro
+     *
+     * @param posixError - POSIX error code (positive)
+     *
+     * @returns FFmpeg error code (negative)
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { EAGAIN } from 'errno';
+     *
+     * const ffmpegError = FFmpegError.makeError(EAGAIN);
+     * // ffmpegError is now AVERROR(EAGAIN)
+     *
+     * if (ret === ffmpegError) {
+     *   console.log('Resource temporarily unavailable');
+     * }
+     * ```
+     */
+    static makeError(posixError) {
+        return bindings.FFmpegError.makeError(posixError);
+    }
+    /**
+     * Check if a value is an error code.
+     *
+     * @param code - Value to check
+     *
+     * @returns true if code is negative (error), false otherwise
+     *
+     * @example
+     * ```typescript
+     * const ret = await formatContext.readFrame(packet);
+     * if (FFmpegError.isFFmpegError(ret)) {
+     *   console.error('Read frame failed');
+     * }
+     * ```
+     */
+    static isFFmpegError(code) {
+        return bindings.FFmpegError.isError(code);
+    }
+    /**
+     * Create FFmpegError from error code if it's an error.
+     *
+     * Helper method to conditionally create error objects.
+     *
+     * @param code - FFmpeg return code
+     *
+     * @returns FFmpegError if code < 0, null otherwise
+     *
+     * @example
+     * ```typescript
+     * const ret = await formatContext.openInput('video.mp4', null, null);
+     * const error = FFmpegError.fromCode(ret);
+     * if (error) {
+     *   console.error(`Failed: ${error.message}`);
+     *   console.error(`Code: ${error.code}`);
+     * }
+     * ```
+     */
+    static fromCode(code) {
+        if (code >= 0) {
+            return null;
+        }
+        return new FFmpegError(code);
+    }
+    /**
+     * Throw FFmpegError if code indicates error.
+     *
+     * Checks return code and throws an error if negative.
+     * Essential for FFmpeg error handling pattern.
+     *
+     * @param code - FFmpeg return code
+     * @param operation - Optional operation name for better error messages
+     *
+     * @throws {FFmpegError} If code < 0
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * const ret = await codecContext.sendPacket(packet);
+     * FFmpegError.throwIfError(ret, 'sendPacket');
+     * // Continues if successful, throws if error
+     *
+     * // With operation name for better error messages
+     * const ret2 = formatContext.allocOutputContext2(null, 'mp4', 'out.mp4');
+     * FFmpegError.throwIfError(ret2, 'allocOutputContext2');
+     * // Error message: "allocOutputContext2 failed: ..."
+     * ```
+     *
+     * @see {@link fromCode} To create error without throwing
+     * @see {@link isFFmpegError} To check if value is error
+     */
+    static throwIfError(code, operation) {
+        if (code < 0) {
+            const error = new FFmpegError(code);
+            if (operation) {
+                error.message = `${operation} failed: ${error.message}`;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Check if error code matches specific error.
+     *
+     * Compares return code with specific error constant.
+     * Useful for handling different error conditions.
+     *
+     * @param code - FFmpeg return code
+     * @param errorCode - Error code to check against
+     *
+     * @returns true if codes match, false otherwise
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AVERROR_EOF, AVERROR_EAGAIN } from 'node-av/constants';
+     *
+     * const ret = await codecContext.receiveFrame(frame);
+     * if (FFmpegError.is(ret, AVERROR_EOF)) {
+     *   console.log('End of stream reached');
+     * } else if (FFmpegError.is(ret, AVERROR_EAGAIN)) {
+     *   console.log('Need more input');
+     * }
+     * ```
+     */
+    static is(code, errorCode) {
+        return code === errorCode;
+    }
+    /**
+     * Get error code.
+     *
+     * Direct mapping to AVERROR code
+     *
+     * FFmpeg error code (negative number).
+     */
+    get code() {
+        return this.native.code;
+    }
+    /**
+     * Get human-readable error message.
+     *
+     * Direct mapping to av_strerror() output
+     *
+     * Error description string.
+     */
+    get message() {
+        return this.native.message;
+    }
+    /**
+     * Get the native FFmpeg error object.
+     *
+     * @internal For use by other wrapper classes
+     * @returns The underlying native error object
+     */
+    getNative() {
+        return this.native;
+    }
+}
+//# sourceMappingURL=error.js.map

package/dist/lib/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../src/lib/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAGxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,OAAO,WAAY,SAAQ,KAAK;IAC5B,MAAM,CAAoB;IAElC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,YAAY,IAAa;QACvB,MAAM,MAAM,GAAG,IAAI,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAC9C,MAAM,OAAO,GAAG,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,cAAc,CAAC;QACrE,KAAK,CAAC,OAAO,CAAC,CAAC;QAEf,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;QAE1B,oFAAoF;QACpF,IAAI,KAAK,CAAC,iBAAiB,EAAE,CAAC;YAC5B,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAc;QAC5B,OAAO,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,SAAS,CAAC,UAAkB;QACjC,OAAO,QAAQ,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,aAAa,CAAC,IAAY;QAC/B,OAAO,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAY;QAC1B,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC;YACd,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,MAAM,CAAC,YAAY,CAAC,IAAY,EAAE,SAAkB;QAClD,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;YACb,MAAM,KAAK,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC;YACpC,IAAI,SAAS,EAAE,CAAC;gBACb,KAAa,CAAC,OAAO,GAAG,GAAG,SAAS,YAAY,KAAK,CAAC,OAAO,EAAE,CAAC;YACnE,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,EAAE,CAAC,IAAY,EAAE,SAAiB;QACvC,OAAO,IAAI,KAAK,SAAS,CAAC;IAC5B,CAAC;IAED;;;;;;OAMG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED;;;;;;OAMG;IACH,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;CACF"}

package/dist/lib/filter-context.d.ts

@@ -0,0 +1,445 @@
+import { Filter } from './filter.js';
+import { HardwareDeviceContext } from './hardware-device-context.js';
+import { OptionMember } from './option.js';
+import { Rational } from './rational.js';
+import type { Frame } from './frame.js';
+import type { HardwareFramesContext } from './hardware-frames-context.js';
+import type { NativeDictionary, NativeFilterContext, NativeFilterGraph, NativeWrapper } from './native-types.js';
+import type { IRational } from './types.js';
+/**
+ * Filter context for media processing.
+ *
+ * Represents an instance of a filter in a filter graph.
+ * Manages filter configuration, parameters, and connections.
+ * Must be created through FilterGraph.createFilter() and properly initialized before use.
+ *
+ * Direct mapping to FFmpeg's AVFilterContext.
+ *
+ * @example
+ * ```typescript
+ * import { FilterGraph, Filter, FFmpegError } from 'node-av';
+ *
+ * // Create filter context through FilterGraph
+ * const filterGraph = new FilterGraph();
+ * filterGraph.alloc();
+ *
+ * const bufferFilter = Filter.getByName('buffer');
+ * const bufferCtx = filterGraph.createFilter(bufferFilter, 'in');
+ * const initRet = bufferCtx.initStr('video_size=1920x1080:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1');
+ * FFmpegError.throwIfError(initRet, 'initStr buffer');
+ *
+ * // Link filters
+ * const scaleFilter = Filter.getByName('scale');
+ * const scaleCtx = filterGraph.createFilter(scaleFilter, 'scale');
+ * const scaleRet = scaleCtx.initStr('1280:720');
+ * FFmpegError.throwIfError(scaleRet, 'initStr scale');
+ *
+ * const linkRet = bufferCtx.link(0, scaleCtx, 0);
+ * FFmpegError.throwIfError(linkRet, 'link');
+ *
+ * // Configure and use the graph
+ * const configRet = filterGraph.config();
+ * FFmpegError.throwIfError(configRet, 'config');
+ * ```
+ */
+export declare class FilterContext extends OptionMember<NativeFilterContext> implements Disposable, NativeWrapper<NativeFilterContext> {
+    private _hwDeviceCtx?;
+    /**
+     * Constructor is internal - use FilterGraph.createFilter().
+     *
+     * FilterContexts are created and managed by FilterGraph.
+     * Do not instantiate directly.
+     *
+     * @internal
+     *
+     * @param native - Native AVFilterContext to wrap
+     */
+    constructor(native: NativeFilterContext);
+    /**
+     * Filter instance name.
+     *
+     * The unique name of this filter instance in the graph.
+     *
+     * Direct mapping to AVFilterContext->name
+     */
+    get name(): string | null;
+    set name(value: string | null);
+    /**
+     * The filter definition.
+     *
+     * The AVFilter that this context is an instance of.
+     *
+     * Direct mapping to AVFilterContext->filter
+     *
+     * @readonly
+     */
+    get filter(): Filter | null;
+    /**
+     * The parent filter graph.
+     *
+     * The filter graph that contains this filter context.
+     *
+     * Direct mapping to AVFilterContext->graph
+     *
+     * @readonly
+     */
+    get graph(): NativeFilterGraph | null;
+    /**
+     * Number of input pads.
+     *
+     * The number of input connections this filter can accept.
+     *
+     * Direct mapping to AVFilterContext->nb_inputs
+     *
+     * @readonly
+     */
+    get nbInputs(): number;
+    /**
+     * Number of output pads.
+     *
+     * Direct mapping to AVFilterContext->nb_outputs
+     *
+     * The number of output connections this filter can provide.
+     */
+    get nbOutputs(): number;
+    /**
+     * Filter readiness status.
+     *
+     * Direct mapping to AVFilterContext->ready
+     *
+     * Non-zero when the filter has been properly initialized.
+     */
+    get ready(): number;
+    /**
+     * Get or set the hardware device context.
+     *
+     * Direct mapping to AVFilterContext->hw_device_ctx
+     *
+     * Used for hardware-accelerated filters that need device context.
+     * Must be set before filter initialization for hardware filters.
+     */
+    get hwDeviceCtx(): HardwareDeviceContext | null;
+    set hwDeviceCtx(value: HardwareDeviceContext | null);
+    /**
+     * Initialize the filter with options.
+     *
+     * Direct mapping to avfilter_init_dict()
+     *
+     * @param options - Optional dictionary of filter options
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - 0: Success
+     *   - AVERROR(EINVAL): Invalid options
+     *   - AVERROR(ENOMEM): Memory allocation failure
+     *   - <0: Other filter-specific errors
+     *
+     * @example
+     * ```typescript
+     * import { Dictionary, FilterContext, FFmpegError } from 'node-av';
+     *
+     * const options = new Dictionary();
+     * const ret1 = options.set('width', '1280', 0);
+     * FFmpegError.throwIfError(ret1, 'set width');
+     * const ret2 = options.set('height', '720', 0);
+     * FFmpegError.throwIfError(ret2, 'set height');
+     *
+     * const initRet = filterCtx.init(options.getNative());
+     * FFmpegError.throwIfError(initRet, 'init');
+     * options.free();
+     * ```
+     *
+     * @see initStr() - Alternative initialization with string arguments
+     */
+    init(options?: NativeDictionary | null): number;
+    /**
+     * Initialize the filter with a string argument.
+     *
+     * Direct mapping to avfilter_init_str()
+     *
+     * @param args - Filter arguments string (format is filter-specific)
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - 0: Success
+     *   - AVERROR(EINVAL): Invalid arguments
+     *   - AVERROR(ENOMEM): Memory allocation failure
+     *   - <0: Other filter-specific errors
+     *
+     * @example
+     * ```typescript
+     * import { FilterContext, FFmpegError } from 'node-av';
+     *
+     * // Initialize scale filter
+     * const scaleRet = scaleCtx.initStr('1280:720');
+     * FFmpegError.throwIfError(scaleRet, 'initStr scale');
+     *
+     * // Initialize buffer source
+     * const bufferRet = bufferCtx.initStr('video_size=1920x1080:pix_fmt=yuv420p:time_base=1/25');
+     * FFmpegError.throwIfError(bufferRet, 'initStr buffer');
+     * ```
+     *
+     * @see init() - Alternative initialization with dictionary
+     */
+    initStr(args?: string | null): number;
+    /**
+     * Link this filter's output to another filter's input.
+     *
+     * Direct mapping to avfilter_link()
+     *
+     * @param srcPad - Output pad index on this filter
+     * @param dst - Destination filter context
+     * @param dstPad - Input pad index on destination filter
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - 0: Success
+     *   - AVERROR(EINVAL): Invalid pad indices or incompatible formats
+     *   - AVERROR(ENOMEM): Memory allocation failure
+     *   - <0: Other linking errors
+     *
+     * @example
+     * ```typescript
+     * import { FilterContext, FFmpegError } from 'node-av';
+     *
+     * // Link buffer source to scale filter
+     * const linkRet1 = bufferCtx.link(0, scaleCtx, 0);
+     * FFmpegError.throwIfError(linkRet1, 'link buffer to scale');
+     *
+     * // Link scale to sink
+     * const linkRet2 = scaleCtx.link(0, sinkCtx, 0);
+     * FFmpegError.throwIfError(linkRet2, 'link scale to sink');
+     * ```
+     */
+    link(srcPad: number, dst: FilterContext, dstPad: number): number;
+    /**
+     * Unlink a filter pad.
+     *
+     * Removes the connection from the specified input pad.
+     * Note: avfilter_link_free is deprecated, we set pointer to nullptr instead.
+     *
+     * @param pad - Input pad index to unlink
+     *
+     * @example
+     * ```typescript
+     * // Unlink the first input pad
+     * filterCtx.unlink(0);
+     * ```
+     */
+    unlink(pad: number): void;
+    /**
+     * Add a frame to a buffer source filter.
+     *
+     * Direct mapping to av_buffersrc_add_frame()
+     *
+     * This function is specific to buffer source filters and is used
+     * to feed frames into the filter graph.
+     *
+     * @param frame - The frame to add (can be null to signal EOF)
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - 0: Success
+     *   - AVERROR(EAGAIN): The buffer is full, try again later
+     *   - AVERROR(EINVAL): Invalid parameters
+     *   - AVERROR_EOF: The filter has been closed
+     *
+     * @example
+     * ```typescript
+     * import { Frame, FilterContext, FFmpegError } from 'node-av';
+     *
+     * // Feed a frame to the buffer source
+     * const addRet = srcCtx.buffersrcAddFrame(frame);
+     * FFmpegError.throwIfError(addRet, 'buffersrcAddFrame');
+     *
+     * // Signal end of stream
+     * const eofRet = srcCtx.buffersrcAddFrame(null);
+     * FFmpegError.throwIfError(eofRet, 'buffersrcAddFrame EOF');
+     * ```
+     */
+    buffersrcAddFrame(frame: Frame | null): Promise<number>;
+    /**
+     * Set parameters for a buffer source filter.
+     *
+     * Direct mapping to av_buffersrc_parameters_set()
+     *
+     * This function configures a buffer source filter with specific parameters,
+     * including hardware frames context for hardware-accelerated filtering.
+     *
+     * @param params - Parameters for the buffer source
+     * @returns 0 on success, negative error code on failure
+     *
+     * @example
+     * ```typescript
+     * const ret = srcCtx.buffersrcParametersSet({
+     *   width: 1920,
+     *   height: 1080,
+     *   format: AV_PIX_FMT_YUV420P,
+     *   timeBase: { num: 1, den: 30 },
+     *   hwFramesCtx: hardware.framesContext
+     * });
+     * FFmpegError.throwIfError(ret, 'buffersrcParametersSet');
+     * ```
+     */
+    buffersrcParametersSet(params: {
+        width?: number;
+        height?: number;
+        format?: number;
+        timeBase?: IRational;
+        frameRate?: IRational;
+        sampleAspectRatio?: IRational;
+        hwFramesCtx?: HardwareFramesContext | null;
+        sampleRate?: number;
+        channelLayout?: bigint;
+    }): number;
+    /**
+     * Get a frame from a buffer sink filter.
+     *
+     * Direct mapping to av_buffersink_get_frame()
+     *
+     * This function is specific to buffer sink filters and is used
+     * to retrieve filtered frames from the filter graph.
+     *
+     * @param frame - The frame to receive the filtered data
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - 0: Success, frame contains valid data
+     *   - AVERROR(EAGAIN): No frame available, need more input
+     *   - AVERROR_EOF: End of stream reached
+     *   - AVERROR(EINVAL): Invalid parameters
+     *
+     * @example
+     * ```typescript
+     * import { Frame, FilterContext, FFmpegError } from 'node-av';
+     * import { AVERROR_EAGAIN, AVERROR_EOF } from 'node-av/constants';
+     *
+     * // Get filtered frames
+     * const frame = new Frame();
+     * frame.alloc();
+     *
+     * let ret = sinkCtx.buffersinkGetFrame(frame);
+     * while (ret >= 0) {
+     *   // Process the filtered frame
+     *   processFrame(frame);
+     *   frame.unref();
+     *
+     *   // Try to get another frame
+     *   ret = sinkCtx.buffersinkGetFrame(frame);
+     * }
+     *
+     * if (!FFmpegError.is(ret, AVERROR_EAGAIN) && !FFmpegError.is(ret, AVERROR_EOF)) {
+     *   FFmpegError.throwIfError(ret, 'buffersinkGetFrame');
+     * }
+     * ```
+     */
+    buffersinkGetFrame(frame: Frame): Promise<number>;
+    /**
+     * Set the frame size for a buffersink filter.
+     *
+     * Direct mapping to av_buffersink_set_frame_size()
+     *
+     * For audio encoders that require a specific frame size.
+     *
+     * @param frameSize - The frame size to set
+     *
+     * @example
+     * ```typescript
+     * if (encCtx.frameSize > 0) {
+     *   buffersinkCtx.buffersinkSetFrameSize(encCtx.frameSize);
+     * }
+     * ```
+     */
+    /**
+     * Get the time base from a buffersink filter.
+     *
+     * Direct mapping to av_buffersink_get_time_base()
+     *
+     * Returns the time base of the buffersink filter.
+     *
+     * @returns The time base as a Rational
+     *
+     * @example
+     * ```typescript
+     * const timeBase = buffersinkCtx.buffersinkGetTimeBase();
+     * console.log(`Time base: ${timeBase.num}/${timeBase.den}`);
+     * ```
+     */
+    buffersinkGetTimeBase(): Rational;
+    /**
+     * Free the filter context.
+     *
+     * Direct mapping to avfilter_free()
+     *
+     * @example
+     * ```typescript
+     * filterCtx.free();
+     * // filterCtx is now invalid and should not be used
+     * ```
+     */
+    free(): void;
+    /**
+     * Check if this is a source filter context.
+     *
+     * Source filters have no inputs and generate data.
+     *
+     * @returns true if the filter has no input pads, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (filterCtx.isSource()) {
+     *   console.log('This is a source filter');
+     * }
+     * ```
+     */
+    isSource(): boolean;
+    /**
+     * Check if this is a sink filter context.
+     *
+     * Sink filters have no outputs and consume data.
+     *
+     * @returns true if the filter has no output pads, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (filterCtx.isSink()) {
+     *   console.log('This is a sink filter');
+     * }
+     * ```
+     */
+    isSink(): boolean;
+    /**
+     * Check if the filter is ready for processing.
+     *
+     * Filters must be initialized before they can process data.
+     *
+     * @returns true if the filter has been properly initialized, false otherwise
+     *
+     * @example
+     * ```typescript
+     * filterCtx.initStr('1280:720');
+     * if (filterCtx.isReady()) {
+     *   console.log('Filter is ready for processing');
+     * }
+     * ```
+     */
+    isReady(): boolean;
+    /**
+     * Get the native FFmpeg AVFilterContext pointer.
+     *
+     * @internal For use by other wrapper classes
+     * @returns The underlying native filter context object
+     */
+    getNative(): NativeFilterContext;
+    /**
+     * Dispose of the filter context.
+     *
+     * Implements the Disposable interface for automatic cleanup.
+     * Equivalent to calling free().
+     *
+     * @example
+     * ```typescript
+     * {
+     *   using filterCtx = filterGraph.createFilter(filter, 'my_filter');
+     *   filterCtx.initStr('args');
+     *   // ... use filter context
+     * } // Automatically freed when leaving scope
+     * ```
+     */
+    [Symbol.dispose](): void;
+}