node-av 0.0.1

package/dist/lib/binding.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Native bindings loader
+ *
+ * This module loads the native C++ bindings compiled by node-gyp.
+ * All native classes are accessed through this single entry point.
+ */
+import type { AVHWDeviceType, AVLogLevel, AVMediaType, AVOptionSearchFlags, AVPixelFormat, AVSampleFormat } from './constants.js';
+import type { NativeAudioFifo, NativeBitStreamFilter, NativeBitStreamFilterContext, NativeCodec, NativeCodecContext, NativeCodecParameters, NativeCodecParser, NativeDictionary, NativeFFmpegError, NativeFilter, NativeFilterContext, NativeFilterGraph, NativeFilterInOut, NativeFormatContext, NativeFrame, NativeHardwareDeviceContext, NativeHardwareFramesContext, NativeInputFormat, NativeIOContext, NativeLog, NativeOption, NativeOutputFormat, NativePacket, NativeSoftwareResampleContext, NativeSoftwareScaleContext, NativeStream } from './native-types.js';
+import type { ChannelLayout, IRational } from './types.js';
+type NativePacketConstructor = new () => NativePacket;
+type NativeFrameConstructor = new () => NativeFrame;
+interface NativeCodecConstructor {
+    new (): NativeCodec;
+    findDecoder(id: number): NativeCodec | null;
+    findEncoder(id: number): NativeCodec | null;
+    findDecoderByName(name: string): NativeCodec | null;
+    findEncoderByName(name: string): NativeCodec | null;
+    getCodecList(): NativeCodec[];
+    iterateCodecs(opaque?: bigint | null): {
+        codec: NativeCodec;
+        opaque: bigint;
+    } | null;
+}
+type NativeCodecContextConstructor = new () => NativeCodecContext;
+type NativeCodecParametersConstructor = new () => NativeCodecParameters;
+type NativeCodecParserConstructor = new () => NativeCodecParser;
+type NativeFormatContextConstructor = new () => NativeFormatContext;
+type NativeStreamConstructor = new () => NativeStream;
+interface NativeInputFormatConstructor {
+    new (): NativeInputFormat;
+    findInputFormat(shortName: string): NativeInputFormat | null;
+    probe(buffer: Buffer, filename?: string): NativeInputFormat | null;
+    probeBuffer(ioContext: NativeIOContext, maxProbeSize?: number): Promise<NativeInputFormat | null>;
+}
+interface NativeOutputFormatConstructor {
+    new (): NativeOutputFormat;
+    guessFormat(shortName: string | null, filename: string | null, mimeType: string | null): NativeOutputFormat | null;
+}
+type NativeIOContextConstructor = new () => NativeIOContext;
+type NativeDictionaryConstructor = new () => NativeDictionary;
+interface NativeFFmpegErrorConstructor {
+    new (code?: number): NativeFFmpegError;
+    strerror(errnum: number): string;
+    makeError(posixError: number): number;
+    isError(code: number): boolean;
+}
+interface NativeFilterConstructor {
+    new (): NativeFilter;
+    getByName(name: string): NativeFilter | null;
+    getList(): NativeFilter[];
+}
+type NativeFilterContextConstructor = new () => NativeFilterContext;
+type NativeFilterGraphConstructor = new () => NativeFilterGraph;
+type NativeFilterInOutConstructor = new () => NativeFilterInOut;
+interface NativeBitStreamFilterConstructor {
+    new (): NativeBitStreamFilter;
+    getByName(name: string): NativeBitStreamFilter | null;
+    iterate(): NativeBitStreamFilter[];
+}
+type NativeBitStreamFilterContextConstructor = new () => NativeBitStreamFilterContext;
+type NativeAudioFifoConstructor = new () => NativeAudioFifo;
+type NativeSoftwareScaleContextConstructor = new () => NativeSoftwareScaleContext;
+type NativeSoftwareResampleContextConstructor = new () => NativeSoftwareResampleContext;
+interface NativeHardwareDeviceContextConstructor {
+    new (): NativeHardwareDeviceContext;
+    getTypeName(type: AVHWDeviceType): string | null;
+    iterateTypes(): AVHWDeviceType[];
+    findTypeByName(name: string): AVHWDeviceType;
+}
+type NativeHardwareFramesContextConstructor = new () => NativeHardwareFramesContext;
+interface NativeLogConstructor {
+    new (): NativeLog;
+    setLevel(level: AVLogLevel): void;
+    getLevel(): AVLogLevel;
+    log(level: AVLogLevel, message: string): void;
+    setCallback(callback: ((level: AVLogLevel, message: string) => void) | null, options?: any): void;
+    resetCallback(): void;
+}
+interface NativeOptionStatic {
+    next(obj: OptionCapableObject, prev?: NativeOption): NativeOption | null;
+    find(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): NativeOption | null;
+    find2(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): {
+        option: NativeOption;
+        isDifferentTarget: boolean;
+    } | null;
+    get(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): string | null;
+    getInt(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): number | null;
+    getDouble(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): number | null;
+    getRational(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): IRational | null;
+    getPixelFormat(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): AVPixelFormat | null;
+    getSampleFormat(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): AVSampleFormat | null;
+    getImageSize(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): {
+        width: number;
+        height: number;
+    } | null;
+    getChannelLayout(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): ChannelLayout | null;
+    getDict(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): NativeDictionary | null;
+    set(obj: OptionCapableObject, name: string, value: string, searchFlags?: AVOptionSearchFlags): number;
+    setInt(obj: OptionCapableObject, name: string, value: number | bigint, searchFlags?: AVOptionSearchFlags): number;
+    setDouble(obj: OptionCapableObject, name: string, value: number, searchFlags?: AVOptionSearchFlags): number;
+    setRational(obj: OptionCapableObject, name: string, value: {
+        num: number;
+        den: number;
+    }, searchFlags?: AVOptionSearchFlags): number;
+    setPixelFormat(obj: OptionCapableObject, name: string, value: number, searchFlags?: AVOptionSearchFlags): number;
+    setSampleFormat(obj: OptionCapableObject, name: string, value: number, searchFlags?: AVOptionSearchFlags): number;
+    setImageSize(obj: OptionCapableObject, name: string, width: number, height: number, searchFlags?: AVOptionSearchFlags): number;
+    setChannelLayout(obj: OptionCapableObject, name: string, value: number, searchFlags?: AVOptionSearchFlags): number;
+    setDict(obj: OptionCapableObject, name: string, value: NativeDictionary, searchFlags?: AVOptionSearchFlags): number;
+    setBin(obj: OptionCapableObject, name: string, value: Buffer, searchFlags?: AVOptionSearchFlags): number;
+    setDefaults(obj: OptionCapableObject): void;
+    copy(dest: OptionCapableObject, src: OptionCapableObject): number;
+    isSetToDefault(obj: OptionCapableObject, name: string, searchFlags?: AVOptionSearchFlags): boolean | null;
+    serialize(obj: OptionCapableObject, optFlags?: number, flags?: number, keyValSep?: string, pairsSep?: string): string | null;
+    free(obj: OptionCapableObject): void;
+    show(obj: OptionCapableObject, reqFlags?: number, rejFlags?: number): number;
+}
+/**
+ * The complete native binding interface
+ */
+export interface NativeBinding {
+    Packet: NativePacketConstructor;
+    Frame: NativeFrameConstructor;
+    Codec: NativeCodecConstructor;
+    CodecContext: NativeCodecContextConstructor;
+    CodecParameters: NativeCodecParametersConstructor;
+    CodecParser: NativeCodecParserConstructor;
+    FormatContext: NativeFormatContextConstructor;
+    Stream: NativeStreamConstructor;
+    InputFormat: NativeInputFormatConstructor;
+    OutputFormat: NativeOutputFormatConstructor;
+    IOContext: NativeIOContextConstructor;
+    Filter: NativeFilterConstructor;
+    FilterContext: NativeFilterContextConstructor;
+    FilterGraph: NativeFilterGraphConstructor;
+    FilterInOut: NativeFilterInOutConstructor;
+    BitStreamFilter: NativeBitStreamFilterConstructor;
+    BitStreamFilterContext: NativeBitStreamFilterContextConstructor;
+    AudioFifo: NativeAudioFifoConstructor;
+    SoftwareScaleContext: NativeSoftwareScaleContextConstructor;
+    SoftwareResampleContext: NativeSoftwareResampleContextConstructor;
+    HardwareDeviceContext: NativeHardwareDeviceContextConstructor;
+    HardwareFramesContext: NativeHardwareFramesContextConstructor;
+    Dictionary: NativeDictionaryConstructor;
+    FFmpegError: NativeFFmpegErrorConstructor;
+    Log: NativeLogConstructor;
+    Option: NativeOptionStatic;
+    getVersion: () => string;
+    avGetBytesPerSample: (sampleFmt: AVSampleFormat) => number;
+    avGetSampleFmtName: (sampleFmt: AVSampleFormat) => string | null;
+    avGetPackedSampleFmt: (sampleFmt: AVSampleFormat) => AVSampleFormat;
+    avGetPlanarSampleFmt: (sampleFmt: AVSampleFormat) => AVSampleFormat;
+    avSampleFmtIsPlanar: (sampleFmt: AVSampleFormat) => boolean;
+    avGetPixFmtName: (pixFmt: AVPixelFormat) => string | null;
+    avGetPixFmtFromName: (name: string) => AVPixelFormat;
+    avIsHardwarePixelFormat: (pixFmt: AVPixelFormat) => boolean;
+    avGetMediaTypeString: (mediaType: AVMediaType) => string | null;
+    avImageAlloc: (width: number, height: number, pixFmt: AVPixelFormat, align: number) => {
+        buffer: Buffer;
+        size: number;
+        linesizes: number[];
+    } | number;
+    avImageCopy2: (dstData: Buffer[], dstLinesizes: number[], srcData: Buffer[], srcLinesizes: number[], pixFmt: AVPixelFormat, width: number, height: number) => void;
+    avImageGetBufferSize: (pixFmt: AVPixelFormat, width: number, height: number, align: number) => number;
+    avImageCopyToBuffer: (dst: Buffer, dstSize: number, srcData: Buffer[] | null, srcLinesize: number[] | null, pixFmt: AVPixelFormat, width: number, height: number, align: number) => number;
+    avTs2Str: (ts: bigint | number | null) => string;
+    avTs2TimeStr: (ts: bigint | number | null, timeBase: IRational) => string;
+    avCompareTs: (tsA: bigint | number | null, tbA: IRational, tsB: bigint | number | null, tbB: IRational) => number;
+    avRescaleQ: (a: bigint | number | null, bq: IRational, cq: IRational) => bigint;
+    avRescaleRnd: (a: bigint | number, b: bigint | number, c: bigint | number, rnd: number) => bigint;
+    avUsleep: (usec: number) => void;
+    avSamplesAlloc: (nbChannels: number, nbSamples: number, sampleFmt: AVSampleFormat, align: number) => {
+        data: Buffer[];
+        linesize: number;
+        size: number;
+    } | number;
+    avSamplesGetBufferSize: (nbChannels: number, nbSamples: number, sampleFmt: AVSampleFormat, align: number) => {
+        size: number;
+        linesize: number;
+    } | number;
+    avChannelLayoutDescribe: (channelLayout: Partial<ChannelLayout>) => string | null;
+    avSdpCreate: (contexts: NativeFormatContext[]) => string | null;
+}
+/**
+ * Union type for all native FFmpeg objects that support AVOptions.
+ *
+ * These objects have an AVClass structure as their first member,
+ * which enables the AVOption API for runtime configuration.
+ */
+export type OptionCapableObject = NativeCodecContext | NativeFormatContext | NativeFilterContext | NativeFilterGraph | NativeSoftwareScaleContext | NativeSoftwareResampleContext | NativeIOContext | NativeBitStreamFilterContext;
+declare const bindings: NativeBinding;
+export { bindings };

package/dist/lib/binding.js

@@ -0,0 +1,70 @@
+/**
+ * Native bindings loader
+ *
+ * This module loads the native C++ bindings compiled by node-gyp.
+ * All native classes are accessed through this single entry point.
+ */
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import { join } from 'path';
+function loadBinding() {
+    const require = createRequire(import.meta.url);
+    const errors = [];
+    // Detect platform
+    const platform = process.platform;
+    const arch = process.arch;
+    const platformArch = `${platform}-${arch}`;
+    // Try 1: Platform-specific package (optionalDependencies)
+    try {
+        const packageName = `@seydx/node-av-${platformArch}`;
+        return require(`${packageName}/node-av.node`);
+    }
+    catch (err) {
+        errors.push(new Error(`Platform package not found: ${err}`));
+    }
+    // Try 2: Local build directory (development)
+    try {
+        const localPath = join(process.cwd(), 'build', 'Release', 'node-av.node');
+        if (existsSync(localPath)) {
+            return require(localPath);
+        }
+    }
+    catch (err) {
+        errors.push(new Error(`Local build not found: ${err}`));
+    }
+    // Try 3: Binary directory (postinstall)
+    try {
+        const binaryPath = join(process.cwd(), 'binary', 'node-av.node');
+        if (existsSync(binaryPath)) {
+            return require(binaryPath);
+        }
+    }
+    catch (err) {
+        errors.push(new Error(`Binary directory not found: ${err}`));
+    }
+    // Try 4: node-gyp-build style paths
+    try {
+        const gypBuildPath = join(process.cwd(), 'build', 'node-av.node');
+        if (existsSync(gypBuildPath)) {
+            return require(gypBuildPath);
+        }
+    }
+    catch (err) {
+        errors.push(new Error(`node-gyp build not found: ${err}`));
+    }
+    // All attempts failed
+    const errorMessages = errors.map((e) => e.message).join('\n  ');
+    // prettier-ignore
+    throw new Error(`Could not load the node-av native binding for ${platformArch}.\n` +
+        `Attempted locations:\n  ${errorMessages}\n\n` +
+        'Possible solutions:\n' +
+        "1. Run 'npm install' to download the prebuilt binary\n" +
+        "2. Run 'npm install --build-from-source' to compile from source\n" +
+        '3. Ensure you have the required dependencies for your platform\n' +
+        '\n' +
+        'See https://github.com/seydx/av for more information.');
+}
+// Load the native binding with fallback logic
+const bindings = loadBinding();
+export { bindings };
+//# sourceMappingURL=binding.js.map

package/dist/lib/binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.js","sourceRoot":"","sources":["../../src/lib/binding.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAChC,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AA+Q5B,SAAS,WAAW;IAClB,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/C,MAAM,MAAM,GAAY,EAAE,CAAC;IAE3B,kBAAkB;IAClB,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAClC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,MAAM,YAAY,GAAG,GAAG,QAAQ,IAAI,IAAI,EAAE,CAAC;IAE3C,0DAA0D;IAC1D,IAAI,CAAC;QACH,MAAM,WAAW,GAAG,kBAAkB,YAAY,EAAE,CAAC;QACrD,OAAO,OAAO,CAAC,GAAG,WAAW,eAAe,CAAC,CAAC;IAChD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,+BAA+B,GAAG,EAAE,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,6CAA6C;IAC7C,IAAI,CAAC;QACH,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QAC1E,IAAI,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;YAC1B,OAAO,OAAO,CAAC,SAAS,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,0BAA0B,GAAG,EAAE,CAAC,CAAC,CAAC;IAC1D,CAAC;IAED,wCAAwC;IACxC,IAAI,CAAC;QACH,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;QACjE,IAAI,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;YAC3B,OAAO,OAAO,CAAC,UAAU,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,+BAA+B,GAAG,EAAE,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,oCAAoC;IACpC,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC;QAClE,IAAI,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;YAC7B,OAAO,OAAO,CAAC,YAAY,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,6BAA6B,GAAG,EAAE,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED,sBAAsB;IACtB,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChE,kBAAkB;IAClB,MAAM,IAAI,KAAK,CACb,iDAAiD,YAAY,KAAK;QAClE,2BAA2B,aAAa,MAAM;QAC9C,uBAAuB;QACvB,wDAAwD;QACxD,mEAAmE;QACnE,kEAAkE;QAClE,IAAI;QACJ,uDAAuD,CACxD,CAAC;AACJ,CAAC;AAED,8CAA8C;AAC9C,MAAM,QAAQ,GAAG,WAAW,EAAE,CAAC;AAE/B,OAAO,EAAE,QAAQ,EAAE,CAAC"}

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

@@ -0,0 +1,345 @@
+import { BitStreamFilter } from './bitstream-filter.js';
+import { CodecParameters } from './codec-parameters.js';
+import { OptionMember } from './option.js';
+import { Rational } from './rational.js';
+import type { NativeBitStreamFilterContext, NativeWrapper } from './native-types.js';
+import type { Packet } from './packet.js';
+/**
+ * Bitstream filter context for processing packets.
+ *
+ * Manages the state for bitstream filtering operations.
+ * Processes packets through a bitstream filter without decoding.
+ * Supports packet-by-packet filtering with internal buffering.
+ *
+ * Direct mapping to FFmpeg's AVBSFContext.
+ *
+ * @example
+ * ```typescript
+ * import { BitStreamFilter, BitStreamFilterContext, Packet, FFmpegError } from 'node-av';
+ * import { AVERROR_EOF, AVERROR } from 'node-av/constants';
+ *
+ * // Create and initialize filter context
+ * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+ * const ctx = new BitStreamFilterContext();
+ *
+ * // Allocate and configure
+ * let ret = ctx.alloc(filter);
+ * FFmpegError.throwIfError(ret, 'alloc');
+ *
+ * // Copy input parameters from stream to BSF context
+ * stream.codecpar.copy(ctx.inputCodecParameters);
+ * ctx.inputTimeBase = stream.timeBase;
+ *
+ * // Initialize filter
+ * ret = ctx.init();
+ * FFmpegError.throwIfError(ret, 'init');
+ *
+ * // Process packets
+ * while (hasMorePackets) {
+ *   const inputPacket = getNextPacket();
+ *
+ *   // Send packet to filter
+ *   ret = await ctx.sendPacket(inputPacket);
+ *   FFmpegError.throwIfError(ret, 'sendPacket');
+ *
+ *   // Receive filtered packets
+ *   while (true) {
+ *     const outputPacket = new Packet();
+ *     const result = await ctx.receivePacket(outputPacket);
+ *
+ *     if (result.eagain || result.eof) break;
+ *     FFmpegError.throwIfError(result.ret || result, 'receivePacket');
+ *
+ *     // Process filtered packet
+ *     processPacket(outputPacket);
+ *     outputPacket.unref();
+ *   }
+ * }
+ *
+ * // Send EOF
+ * await ctx.sendPacket(null);
+ *
+ * // Drain remaining packets
+ * while (true) {
+ *   const outputPacket = new Packet();
+ *   const result = await ctx.receivePacket(outputPacket);
+ *   if (result.eof) break;
+ *   // Process remaining packets
+ * }
+ *
+ * // Cleanup
+ * ctx.free();
+ * ```
+ */
+export declare class BitStreamFilterContext extends OptionMember<NativeBitStreamFilterContext> implements Disposable, NativeWrapper<NativeBitStreamFilterContext> {
+    private _filter?;
+    /**
+     * Create a new bitstream filter context.
+     *
+     * The context is uninitialized - you must call alloc() and init() before use.
+     * No FFmpeg resources are allocated until initialization.
+     *
+     * Direct wrapper around AVBSFContext.
+     *
+     * @example
+     * ```typescript
+     * const ctx = new BitStreamFilterContext();
+     * ctx.alloc(filter);
+     * ctx.init();
+     * // Context is now ready for filtering
+     * ```
+     */
+    constructor();
+    /**
+     * Check if the context is initialized.
+     *
+     * Returns true if init() has been called successfully.
+     *
+     * @returns True if initialized, false otherwise
+     */
+    get isInitialized(): boolean;
+    /**
+     * Input codec parameters (read-only reference, mutable contents).
+     *
+     * Returns a reference to the BSF context's internal codec parameters.
+     * While you cannot replace this object (no setter), you can modify its contents
+     * or use it as a destination for copy operations.
+     *
+     * You must configure these parameters before calling init().
+     *
+     * Maps to AVBSFContext->par_in.
+     *
+     * @example
+     * ```typescript
+     * // Copy parameters from input stream to BSF context
+     * if (ctx.inputCodecParameters) {
+     *   stream.codecpar.copy(ctx.inputCodecParameters);
+     *
+     *   // Or set individual properties
+     *   ctx.inputCodecParameters.codecType = AVMEDIA_TYPE_VIDEO;
+     *   ctx.inputCodecParameters.codecId = AV_CODEC_ID_H264;
+     * }
+     * ```
+     */
+    get inputCodecParameters(): CodecParameters | null;
+    /**
+     * Output codec parameters (read-only reference, read-only contents).
+     *
+     * Returns a reference to the BSF context's output codec parameters.
+     * These are automatically configured by the filter during init().
+     * You should not modify these parameters.
+     *
+     * Maps to AVBSFContext->par_out.
+     *
+     * @example
+     * ```typescript
+     * // After initialization, read the output parameters
+     * console.log(`Output codec: ${ctx.outputCodecParameters?.codecId}`);
+     *
+     * // Use them to configure downstream components
+     * if (ctx.outputCodecParameters) {
+     *   ctx.outputCodecParameters.copy(nextStream.codecpar);
+     * }
+     * ```
+     */
+    get outputCodecParameters(): CodecParameters | null;
+    /**
+     * Input time base.
+     *
+     * Time base for input packet timestamps.
+     * Must be set before calling init().
+     *
+     * Maps to AVBSFContext->time_base_in.
+     *
+     * @example
+     * ```typescript
+     * ctx.inputTimeBase = new Rational(1, 1000); // 1ms time base
+     * ```
+     */
+    get inputTimeBase(): Rational;
+    set inputTimeBase(value: Rational);
+    /**
+     * Output time base.
+     *
+     * Time base for output packet timestamps.
+     * Set by the filter during init().
+     *
+     * Maps to AVBSFContext->time_base_out.
+     *
+     * @example
+     * ```typescript
+     * // After initialization
+     * console.log(`Output time base: ${ctx.outputTimeBase.num}/${ctx.outputTimeBase.den}`);
+     * ```
+     */
+    get outputTimeBase(): Rational | null;
+    /**
+     * The bitstream filter being used.
+     *
+     * Reference to the filter this context was allocated with.
+     *
+     * Maps to AVBSFContext->filter.
+     *
+     * @example
+     * ```typescript
+     * console.log(`Using filter: ${ctx.filter?.name}`);
+     * ```
+     */
+    get filter(): BitStreamFilter | null;
+    /**
+     * Allocate the bitstream filter context.
+     *
+     * Allocates the context for the specified filter.
+     * Must be called before any other operations.
+     * After allocation, configure input parameters before calling init().
+     *
+     * Calls av_bsf_alloc() internally.
+     *
+     * @param filter - The bitstream filter to use
+     * @returns 0 on success, negative error code on failure
+     *
+     * @example
+     * ```typescript
+     * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+     * const ctx = new BitStreamFilterContext();
+     * const ret = ctx.alloc(filter);
+     * FFmpegError.throwIfError(ret, 'alloc');
+     * ```
+     */
+    alloc(filter: BitStreamFilter): number;
+    /**
+     * Initialize the bitstream filter context.
+     *
+     * Prepares the filter for use after parameters have been set.
+     * Sets up output parameters based on input and filter configuration.
+     * Must be called after alloc() and parameter configuration.
+     *
+     * Calls av_bsf_init() internally.
+     *
+     * @returns 0 on success, negative error code on failure
+     *
+     * @example
+     * ```typescript
+     * // After allocation and parameter setup
+     * const ret = ctx.init();
+     * FFmpegError.throwIfError(ret, 'init');
+     * ```
+     */
+    init(): number;
+    /**
+     * Free the bitstream filter context.
+     *
+     * Releases all resources associated with the context.
+     * The context cannot be used after calling this method.
+     *
+     * Calls av_bsf_free() internally.
+     *
+     * @example
+     * ```typescript
+     * ctx.free();
+     * // Context is now freed and unusable
+     * ```
+     */
+    free(): void;
+    /**
+     * Flush the bitstream filter.
+     *
+     * Resets the internal filter state.
+     * Should be called when seeking or switching streams.
+     *
+     * Calls av_bsf_flush() internally.
+     *
+     * @example
+     * ```typescript
+     * // When seeking
+     * ctx.flush();
+     * // Filter is reset and ready for new packets
+     * ```
+     */
+    flush(): void;
+    /**
+     * Send a packet to the filter.
+     *
+     * Submits a packet for filtering.
+     * The filter takes ownership of the packet.
+     * Pass null to signal end of stream.
+     *
+     * After sending a packet, call receivePacket() repeatedly
+     * until it returns EAGAIN or EOF.
+     *
+     * Calls av_bsf_send_packet() internally.
+     *
+     * @param packet - Packet to filter, or null for EOF
+     * @returns Promise resolving to 0 on success, error code on failure
+     *
+     * @example
+     * ```typescript
+     * // Send packet
+     * const ret = await ctx.sendPacket(inputPacket);
+     * if (ret < 0 && ret !== AVERROR_EAGAIN) {
+     *   throw new Error('Failed to send packet');
+     * }
+     *
+     * // Send EOF
+     * await ctx.sendPacket(null);
+     * ```
+     */
+    sendPacket(packet: Packet | null): Promise<number>;
+    /**
+     * Receive a filtered packet.
+     *
+     * Gets a filtered packet from the filter.
+     * Must be called repeatedly after sendPacket() until EAGAIN or EOF.
+     * One input packet may produce multiple output packets.
+     *
+     * Calls av_bsf_receive_packet() internally.
+     *
+     * @param packet - Packet to receive filtered data into
+     * @returns Promise resolving to 0 on success, negative error code on failure
+     *
+     * @example
+     * ```typescript
+     * import { AVERROR_EAGAIN, AVERROR_EOF } from 'node-av/constants';
+     *
+     * const packet = new Packet();
+     * const ret = await ctx.receivePacket(packet);
+     *
+     * if (ret === AVERROR_EAGAIN) {
+     *   // Need to send more packets
+     * } else if (ret === AVERROR_EOF) {
+     *   // No more packets
+     * } else if (ret < 0) {
+     *   // Error occurred
+     * } else {
+     *   // Got a packet successfully
+     *   processPacket(packet);
+     * }
+     * ```
+     */
+    receivePacket(packet: Packet): Promise<number>;
+    /**
+     * Get the underlying native object.
+     *
+     * For advanced use cases that need direct access to the native bindings.
+     *
+     * @returns Native BitStreamFilterContext object
+     * @internal
+     */
+    getNative(): NativeBitStreamFilterContext;
+    /**
+     * Dispose of the context resources.
+     *
+     * Automatically called when using the `using` statement.
+     * Frees all associated FFmpeg resources.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   using ctx = new BitStreamFilterContext();
+     *   ctx.alloc(filter);
+     *   // ... use context
+     * } // Automatically freed when leaving scope
+     * ```
+     */
+    [Symbol.dispose](): void;
+}