@revizly/node-av 5.2.2-beta.1

package/dist/lib/audio-fifo.js

@@ -0,0 +1,431 @@
+import { bindings } from './binding.js';
+/**
+ * Audio FIFO (First-In-First-Out) buffer for managing audio samples.
+ *
+ * Provides a thread-safe buffer for audio sample data, supporting both planar and interleaved formats.
+ * Automatically handles buffer reallocation when needed. Essential for audio resampling,
+ * format conversion, and buffering operations.
+ *
+ * Direct mapping to FFmpeg's AVAudioFifo.
+ *
+ * @example
+ * ```typescript
+ * import { AudioFifo, FFmpegError } from 'node-av';
+ * import { AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+ *
+ * // Create FIFO for stereo float planar audio
+ * const fifo = new AudioFifo();
+ * fifo.alloc(AV_SAMPLE_FMT_FLTP, 2, 4096);
+ *
+ * // Write samples
+ * const leftChannel = Buffer.alloc(1024 * 4);  // 1024 float samples
+ * const rightChannel = Buffer.alloc(1024 * 4);
+ * const written = await fifo.write([leftChannel, rightChannel], 1024);
+ * FFmpegError.throwIfError(written, 'write');
+ *
+ * // Read samples when enough available
+ * if (fifo.size >= 512) {
+ *   const outLeft = Buffer.alloc(512 * 4);
+ *   const outRight = Buffer.alloc(512 * 4);
+ *   const read = await fifo.read([outLeft, outRight], 512);
+ *   FFmpegError.throwIfError(read, 'read');
+ * }
+ *
+ * // Cleanup
+ * fifo.free();
+ * ```
+ *
+ * @see [AudioFifo](https://ffmpeg.org/doxygen/trunk/structAVAudioFifo.html) - FFmpeg Doxygen
+ */
+export class AudioFifo {
+    native;
+    constructor() {
+        this.native = new bindings.AudioFifo();
+    }
+    /**
+     * Number of samples currently in the FIFO.
+     *
+     * Direct mapping to av_audio_fifo_size().
+     */
+    get size() {
+        return this.native.size;
+    }
+    /**
+     * Number of samples that can be written without reallocation.
+     *
+     * Direct mapping to av_audio_fifo_space().
+     */
+    get space() {
+        return this.native.space;
+    }
+    /**
+     * Allocate an AVAudioFifo buffer.
+     *
+     * Creates a FIFO buffer for the specified audio format and size.
+     * The FIFO will automatically grow if more data is written than allocated.
+     *
+     * Direct mapping to av_audio_fifo_alloc().
+     *
+     * @param sampleFmt - Sample format (e.g., AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLTP)
+     *
+     * @param channels - Number of audio channels
+     *
+     * @param nbSamples - Initial buffer size in samples
+     *
+     * @throws {Error} If allocation fails (ENOMEM)
+     *
+     * @example
+     * ```typescript
+     * import { AudioFifo } from 'node-av';
+     * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+     *
+     * // For interleaved 16-bit stereo
+     * const fifo1 = new AudioFifo();
+     * fifo1.alloc(AV_SAMPLE_FMT_S16, 2, 4096);
+     *
+     * // For planar float 5.1 audio
+     * const fifo2 = new AudioFifo();
+     * fifo2.alloc(AV_SAMPLE_FMT_FLTP, 6, 8192);
+     * ```
+     *
+     * @see {@link realloc} To resize the FIFO
+     * @see {@link free} To release the FIFO
+     */
+    alloc(sampleFmt, channels, nbSamples) {
+        this.native.alloc(sampleFmt, channels, nbSamples);
+    }
+    /**
+     * Free the FIFO buffer and all associated resources.
+     *
+     * After calling this, the FIFO is invalid and must be reallocated before use.
+     *
+     * Direct mapping to av_audio_fifo_free().
+     *
+     * @example
+     * ```typescript
+     * fifo.free();
+     * // FIFO is now invalid, must call alloc() before using again
+     * ```
+     *
+     * @see {@link Symbol.dispose} For automatic cleanup
+     * @see {@link alloc} To allocate
+     */
+    free() {
+        this.native.free();
+    }
+    /**
+     * Write audio samples to the FIFO.
+     *
+     * Writes samples to the FIFO buffer. Automatically reallocates if more space is needed.
+     * For planar formats, provide an array of buffers (one per channel).
+     * For interleaved formats, provide a single buffer.
+     *
+     * Direct mapping to av_audio_fifo_write().
+     *
+     * @param data - Audio data buffer(s). Array for planar, single Buffer for interleaved
+     *
+     * @param nbSamples - Number of samples to write
+     *
+     * @returns Number of samples written, or negative AVERROR:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *   - AVERROR_ENOMEM: Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * // Planar format (e.g., FLTP) - separate buffers per channel
+     * const leftData = Buffer.alloc(1024 * 4);  // 1024 float samples
+     * const rightData = Buffer.alloc(1024 * 4);
+     * const written = await fifo.write([leftData, rightData], 1024);
+     * FFmpegError.throwIfError(written, 'write');
+     * console.log(`Wrote ${written} samples`);
+     *
+     * // Interleaved format (e.g., S16) - single buffer
+     * const interleavedData = Buffer.alloc(1024 * 2 * 2);  // 1024 stereo S16 samples
+     * const written2 = await fifo.write(interleavedData, 1024);
+     * FFmpegError.throwIfError(written2, 'write');
+     * ```
+     *
+     * @see {@link read} To retrieve samples from FIFO
+     * @see {@link space} To check available space
+     */
+    async write(data, nbSamples) {
+        return await this.native.write(data, nbSamples);
+    }
+    /**
+     * Write samples to the FIFO synchronously.
+     * Synchronous version of write.
+     *
+     * Adds audio samples to the FIFO buffer.
+     * The FIFO automatically handles format and layout conversions.
+     * Can write fewer samples than requested if space is limited.
+     *
+     * Direct mapping to av_audio_fifo_write().
+     *
+     * @param data - Audio data buffer(s). Array for planar, single Buffer for interleaved
+     *
+     * @param nbSamples - Number of samples to write per channel
+     *
+     * @returns Number of samples written, or negative AVERROR:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * // Interleaved stereo data (2 channels * 1024 samples * 4 bytes)
+     * const buffer = Buffer.alloc(2 * 1024 * 4);
+     * // Fill with audio data...
+     *
+     * const written = fifo.writeSync(buffer, 1024);
+     * FFmpegError.throwIfError(written, 'writeSync');
+     * console.log(`Wrote ${written} samples`);
+     * ```
+     *
+     * @see {@link write} For async version
+     */
+    writeSync(data, nbSamples) {
+        return this.native.writeSync(data, nbSamples);
+    }
+    /**
+     * Read and remove samples from the FIFO.
+     *
+     * Reads up to the specified number of samples from the FIFO.
+     * The samples are removed from the FIFO after reading.
+     * Buffers must be pre-allocated with sufficient size.
+     *
+     * Direct mapping to av_audio_fifo_read().
+     *
+     * @param data - Pre-allocated buffer(s) to read into. Array for planar, single Buffer for interleaved
+     *
+     * @param nbSamples - Maximum number of samples to read
+     *
+     * @returns Number of samples read, or negative AVERROR:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * // Check available samples
+     * const available = fifo.size;
+     * if (available >= 1024) {
+     *   // Planar format
+     *   const leftOut = Buffer.alloc(1024 * 4);
+     *   const rightOut = Buffer.alloc(1024 * 4);
+     *   const read = await fifo.read([leftOut, rightOut], 1024);
+     *   FFmpegError.throwIfError(read, 'read');
+     *   console.log(`Read ${read} samples`);
+     * }
+     * ```
+     *
+     * @see {@link peek} To read without removing
+     * @see {@link size} To check available samples
+     */
+    async read(data, nbSamples) {
+        return await this.native.read(data, nbSamples);
+    }
+    /**
+     * Read and remove samples from the FIFO synchronously.
+     * Synchronous version of read.
+     *
+     * Reads up to the specified number of samples from the FIFO.
+     * The samples are removed from the FIFO after reading.
+     * Buffers must be pre-allocated with sufficient size.
+     *
+     * Direct mapping to av_audio_fifo_read().
+     *
+     * @param data - Pre-allocated buffer(s) to read into. Array for planar, single Buffer for interleaved
+     *
+     * @param nbSamples - Maximum number of samples to read
+     *
+     * @returns Number of samples read, or negative AVERROR:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * // Read up to 1024 samples
+     * const readBuffer = Buffer.alloc(2 * 1024 * 4); // stereo float32
+     * const read = fifo.readSync(readBuffer, 1024);
+     * FFmpegError.throwIfError(read, 'readSync');
+     *
+     * console.log(`Read ${read} samples from FIFO`);
+     * console.log(`FIFO now has ${fifo.size} samples remaining`);
+     * ```
+     *
+     * @see {@link read} For async version
+     */
+    readSync(data, nbSamples) {
+        return this.native.readSync(data, nbSamples);
+    }
+    /**
+     * Read samples from the FIFO without removing them.
+     *
+     * Similar to read() but leaves the samples in the FIFO.
+     * Useful for inspecting upcoming data without consuming it.
+     *
+     * Direct mapping to av_audio_fifo_peek().
+     *
+     * @param data - Pre-allocated buffer(s) to peek into. Array for planar, single Buffer for interleaved
+     *
+     * @param nbSamples - Maximum number of samples to peek
+     *
+     * @returns Number of samples peeked, or negative AVERROR:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * // Peek at next samples without removing them
+     * const peekBuffer = Buffer.alloc(256 * 4);
+     * const peeked = await fifo.peek(peekBuffer, 256);
+     * FFmpegError.throwIfError(peeked, 'peek');
+     *
+     * // Samples are still in FIFO
+     * console.log(`FIFO still has ${fifo.size} samples`);
+     * ```
+     *
+     * @see {@link read} To read and remove samples
+     */
+    async peek(data, nbSamples) {
+        return await this.native.peek(data, nbSamples);
+    }
+    /**
+     * Read samples from the FIFO without removing them synchronously.
+     * Synchronous version of peek.
+     *
+     * Similar to readSync() but leaves the samples in the FIFO.
+     * Useful for inspecting upcoming data without consuming it.
+     *
+     * Direct mapping to av_audio_fifo_peek().
+     *
+     * @param data - Pre-allocated buffer(s) to peek into. Array for planar, single Buffer for interleaved
+     *
+     * @param nbSamples - Maximum number of samples to peek
+     *
+     * @returns Number of samples peeked, or negative AVERROR:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * // Peek at next samples without removing them
+     * const peekBuffer = Buffer.alloc(256 * 4);
+     * const peeked = fifo.peekSync(peekBuffer, 256);
+     * FFmpegError.throwIfError(peeked, 'peekSync');
+     *
+     * // Samples are still in FIFO
+     * console.log(`FIFO still has ${fifo.size} samples`);
+     * ```
+     *
+     * @see {@link peek} For async version
+     */
+    peekSync(data, nbSamples) {
+        return this.native.peekSync(data, nbSamples);
+    }
+    /**
+     * Remove samples from the FIFO without reading them.
+     *
+     * Discards the specified number of samples from the FIFO.
+     * Useful for skipping unwanted audio data.
+     *
+     * Direct mapping to av_audio_fifo_drain().
+     *
+     * @param nbSamples - Number of samples to discard
+     *
+     * @example
+     * ```typescript
+     * // Skip 100 samples
+     * fifo.drain(100);
+     * console.log(`FIFO now has ${fifo.size} samples`);
+     * ```
+     *
+     * @see {@link reset} To remove all samples
+     */
+    drain(nbSamples) {
+        this.native.drain(nbSamples);
+    }
+    /**
+     * Remove all samples from the FIFO.
+     *
+     * Empties the FIFO buffer without deallocating it.
+     * The FIFO remains allocated and ready for new data.
+     *
+     * Direct mapping to av_audio_fifo_reset().
+     *
+     * @example
+     * ```typescript
+     * fifo.reset();
+     * console.log(fifo.size);  // 0
+     * console.log(fifo.space); // Original allocation size
+     * ```
+     *
+     * @see {@link drain} To remove specific number of samples
+     */
+    reset() {
+        this.native.reset();
+    }
+    /**
+     * Resize the FIFO buffer.
+     *
+     * Changes the allocated size of the FIFO. Can grow or shrink the buffer.
+     * Existing samples are preserved up to the new size.
+     *
+     * Direct mapping to av_audio_fifo_realloc().
+     *
+     * @param nbSamples - New allocation size in samples
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_EINVAL: Invalid size
+     *   - AVERROR_ENOMEM: Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * // Grow FIFO to handle larger buffers
+     * const ret = fifo.realloc(16384);
+     * FFmpegError.throwIfError(ret, 'realloc');
+     * console.log(`New space: ${fifo.space} samples`);
+     * ```
+     *
+     * @see {@link alloc} For initial allocation
+     */
+    realloc(nbSamples) {
+        return this.native.realloc(nbSamples);
+    }
+    /**
+     * Get the underlying native AudioFifo object.
+     *
+     * @returns The native AudioFifo binding object
+     *
+     * @internal
+     */
+    getNative() {
+        return this.native;
+    }
+    /**
+     * Dispose of the audio FIFO buffer.
+     *
+     * Implements the Disposable interface for automatic cleanup.
+     * Equivalent to calling free().
+     *
+     * @example
+     * ```typescript
+     * {
+     *   using fifo = new AudioFifo();
+     *   fifo.alloc(AV_SAMPLE_FMT_FLTP, 2, 4096);
+     *   // Use fifo...
+     * } // Automatically freed when leaving scope
+     * ```
+     */
+    [Symbol.dispose]() {
+        this.native[Symbol.dispose]();
+    }
+}
+//# sourceMappingURL=audio-fifo.js.map

package/dist/lib/audio-fifo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-fifo.js","sourceRoot":"","sources":["../../src/lib/audio-fifo.ts"],"names":[],"mappings":"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"}

package/dist/lib/binding.d.ts

@@ -0,0 +1,228 @@
+/**
+ * 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 { AVCodecID, AVError, AVHWDeviceType, AVLogLevel, AVMediaType, AVOptionSearchFlags, AVPixelFormat, AVSampleFormat, FFDecoderCodec, FFEncoderCodec } from '../constants/index.js';
+import type { PosixError } from './error.js';
+import type { NativeAudioFifo, NativeBitStreamFilter, NativeBitStreamFilterContext, NativeCodec, NativeCodecContext, NativeCodecParameters, NativeCodecParser, NativeDeviceModule, NativeDictionary, NativeFFmpegError, NativeFifo, NativeFilter, NativeFilterContext, NativeFilterGraph, NativeFilterInOut, NativeFormatContext, NativeFrame, NativeFrameUtils, NativeHardwareDeviceContext, NativeHardwareFramesContext, NativeInputFormat, NativeIOContext, NativeLog, NativeOption, NativeOutputFormat, NativePacket, NativeSoftwareResampleContext, NativeSoftwareScaleContext, NativeStream, NativeSyncQueue } from './native-types.js';
+import type { ChannelLayout, DtsPredictState, IDimension, IRational } from './types.js';
+type NativePacketConstructor = new () => NativePacket;
+type NativeFrameConstructor = new () => NativeFrame;
+interface NativeCodecConstructor {
+    new (): NativeCodec;
+    findDecoder(id: AVCodecID): NativeCodec | null;
+    findEncoder(id: AVCodecID): NativeCodec | null;
+    findDecoderByName(name: FFDecoderCodec): NativeCodec | null;
+    findEncoderByName(name: FFEncoderCodec): 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>;
+    probeBufferSync(ioContext: NativeIOContext, maxProbeSize?: number): 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;
+    getAverror(errorName: PosixError): AVError;
+}
+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 NativeFifoConstructor = new () => NativeFifo;
+type NativeSoftwareScaleContextConstructor = new () => NativeSoftwareScaleContext;
+type NativeSoftwareResampleContextConstructor = new () => NativeSoftwareResampleContext;
+type NativeFrameUtilsConstructor = new (width: number, height: number) => NativeFrameUtils;
+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): IDimension | 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;
+}
+interface NativeSyncQueueConstructor {
+    create(type: number, bufferSizeUs: number): NativeSyncQueue;
+}
+/**
+ * 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;
+    Fifo: NativeFifoConstructor;
+    SoftwareScaleContext: NativeSoftwareScaleContextConstructor;
+    SoftwareResampleContext: NativeSoftwareResampleContextConstructor;
+    FrameUtils: NativeFrameUtilsConstructor;
+    HardwareDeviceContext: NativeHardwareDeviceContextConstructor;
+    HardwareFramesContext: NativeHardwareFramesContextConstructor;
+    Dictionary: NativeDictionaryConstructor;
+    FFmpegError: NativeFFmpegErrorConstructor;
+    Log: NativeLogConstructor;
+    Option: NativeOptionStatic;
+    SyncQueue: NativeSyncQueueConstructor;
+    Device: NativeDeviceModule;
+    getFFmpegInfo: () => {
+        version: string;
+        configuration: string;
+        libraries: {
+            avutil: string;
+            avcodec: string;
+            avformat: string;
+            avfilter: string;
+            avdevice: string;
+            swscale: string;
+            swresample: string;
+        };
+    };
+    avGetBytesPerSample: (sampleFmt: AVSampleFormat) => number;
+    avGetSampleFmtName: (sampleFmt: AVSampleFormat) => string | null;
+    avGetSampleFmtFromName: (name: string) => AVSampleFormat;
+    avGetPackedSampleFmt: (sampleFmt: AVSampleFormat) => AVSampleFormat;
+    avGetPlanarSampleFmt: (sampleFmt: AVSampleFormat) => AVSampleFormat;
+    avSampleFmtIsPlanar: (sampleFmt: AVSampleFormat) => boolean;
+    avGetCodecName: (codecId: AVCodecID) => string | null;
+    avGetCodecString: (codecpar: NativeCodecParameters, frameRate?: IRational) => string | null;
+    avGetMimeTypeDash: (codecpar: NativeCodecParameters) => string | null;
+    avGetPixFmtName: (pixFmt: AVPixelFormat) => string | null;
+    avGetPixFmtFromName: (name: string) => AVPixelFormat;
+    avIsHardwarePixelFormat: (pixFmt: AVPixelFormat) => boolean;
+    avGetHardwareDeviceTypeName: (type: AVHWDeviceType) => string | null;
+    avGetHardwareDeviceTypeFromName: (name: string) => AVHWDeviceType;
+    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;
+    avImageCrop: (dstBuffer: Buffer, srcBuffer: Buffer, pixFmt: AVPixelFormat, srcWidth: number, srcHeight: number, cropX: number, cropY: number, cropWidth: number, cropHeight: 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;
+    avRescaleDelta: (inTb: IRational, inTs: bigint | number, fsTb: IRational, duration: number, lastRef: {
+        value: bigint;
+    }, outTb: IRational) => bigint;
+    avMulQ: (a: IRational, b: IRational) => IRational;
+    avInvQ: (q: IRational) => IRational;
+    avAddQ: (a: IRational, b: IRational) => IRational;
+    avGcd: (a: bigint | number, b: bigint | number) => bigint;
+    avRescaleQRnd: (a: bigint | number | null, bq: IRational, cq: IRational, rnd: number) => bigint;
+    avGetAudioFrameDuration2: (codecpar: NativeCodecParameters, frameBytes: number) => number;
+    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;
+    dtsPredict: (packet: NativePacket, stream: NativeStream, state: DtsPredictState) => DtsPredictState;
+}
+/**
+ * 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 };