node-av 3.1.3 → 5.0.0

package/dist/api/media-input.js

@@ -1,1075 +0,0 @@
-import { closeSync, openSync, readSync } from 'fs';
-import { open } from 'fs/promises';
-import { resolve } from 'path';
-import { AVFLAG_NONE, AVFMT_FLAG_CUSTOM_IO, AVFMT_FLAG_NONBLOCK, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_VIDEO } from '../constants/constants.js';
-import { avGetPixFmtName, avGetSampleFmtName, Dictionary, FFmpegError, FormatContext, InputFormat, IOContext, Packet, Rational } from '../lib/index.js';
-import { IOStream } from './io-stream.js';
-/**
- * High-level media input for reading and demuxing media files.
- *
- * Provides simplified access to media streams, packets, and metadata.
- * Handles file opening, format detection, and stream information extraction.
- * Supports files, URLs, buffers, and raw data input with automatic cleanup.
- * Essential component for media processing pipelines and transcoding.
- *
- * @example
- * ```typescript
- * import { MediaInput } from 'node-av/api';
- *
- * // Open media file
- * await using input = await MediaInput.open('video.mp4');
- * console.log(`Format: ${input.formatName}`);
- * console.log(`Duration: ${input.duration}s`);
- *
- * // Process packets
- * for await (const packet of input.packets()) {
- *   console.log(`Packet from stream ${packet.streamIndex}`);
- *   packet.free();
- * }
- * ```
- *
- * @example
- * ```typescript
- * // From buffer
- * const buffer = await fs.readFile('video.mp4');
- * await using input = await MediaInput.open(buffer);
- *
- * // Access streams
- * const videoStream = input.video();
- * const audioStream = input.audio();
- * ```
- *
- * @see {@link MediaOutput} For writing media files
- * @see {@link Decoder} For decoding packets to frames
- * @see {@link FormatContext} For low-level API
- */
-export class MediaInput {
-    formatContext;
-    _streams = [];
-    ioContext;
-    isClosed = false;
-    /**
-     * @param formatContext - Opened format context
-     *
-     * @param ioContext - Optional IO context for custom I/O (e.g., from Buffer)
-     *
-     * @internal
-     */
-    constructor(formatContext, ioContext) {
-        this.formatContext = formatContext;
-        this.ioContext = ioContext;
-        this._streams = formatContext.streams ?? [];
-    }
-    /**
-     * Probe media format without fully opening the file.
-     *
-     * Detects format by analyzing file headers and content.
-     * Useful for format validation before processing.
-     *
-     * Direct mapping to av_probe_input_format().
-     *
-     * @param input - File path or buffer to probe
-     *
-     * @returns Format information or null if unrecognized
-     *
-     * @example
-     * ```typescript
-     * const info = await MediaInput.probeFormat('video.mp4');
-     * if (info) {
-     *   console.log(`Format: ${info.format}`);
-     *   console.log(`Confidence: ${info.confidence}%`);
-     * }
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Probe from buffer
-     * const buffer = await fs.readFile('video.webm');
-     * const info = await MediaInput.probeFormat(buffer);
-     * console.log(`MIME type: ${info?.mimeType}`);
-     * ```
-     *
-     * @see {@link InputFormat.probe} For low-level probing
-     */
-    static async probeFormat(input) {
-        try {
-            if (Buffer.isBuffer(input)) {
-                // Probe from buffer
-                const format = InputFormat.probe(input);
-                if (!format) {
-                    return null;
-                }
-                return {
-                    format: format.name ?? 'unknown',
-                    longName: format.longName ?? undefined,
-                    extensions: format.extensions ?? undefined,
-                    mimeType: format.mimeType ?? undefined,
-                    confidence: 100, // Direct probe always has high confidence
-                };
-            }
-            else {
-                // For files, read first part and probe
-                let fileHandle;
-                try {
-                    fileHandle = await open(input, 'r');
-                    // Read first 64KB for probing
-                    const buffer = Buffer.alloc(65536);
-                    const { bytesRead } = await fileHandle.read(buffer, 0, 65536, 0);
-                    const probeBuffer = buffer.subarray(0, bytesRead);
-                    const format = InputFormat.probe(probeBuffer, input);
-                    if (!format) {
-                        return null;
-                    }
-                    return {
-                        format: format.name ?? 'unknown',
-                        longName: format.longName ?? undefined,
-                        extensions: format.extensions ?? undefined,
-                        mimeType: format.mimeType ?? undefined,
-                        confidence: 90, // File-based probe with filename hint
-                    };
-                }
-                catch {
-                    // If file reading fails, return null
-                    return null;
-                }
-                finally {
-                    await fileHandle?.close();
-                }
-            }
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Probe media format without fully opening the file synchronously.
-     * Synchronous version of probeFormat.
-     *
-     * Detects format by analyzing file headers and content.
-     * Useful for format validation before processing.
-     *
-     * Direct mapping to av_probe_input_format().
-     *
-     * @param input - File path or buffer to probe
-     *
-     * @returns Format information or null if unrecognized
-     *
-     * @example
-     * ```typescript
-     * const info = MediaInput.probeFormatSync('video.mp4');
-     * if (info) {
-     *   console.log(`Format: ${info.format}`);
-     *   console.log(`Confidence: ${info.confidence}%`);
-     * }
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Probe from buffer
-     * const buffer = fs.readFileSync('video.webm');
-     * const info = MediaInput.probeFormatSync(buffer);
-     * console.log(`MIME type: ${info?.mimeType}`);
-     * ```
-     *
-     * @see {@link probeFormat} For async version
-     */
-    static probeFormatSync(input) {
-        try {
-            if (Buffer.isBuffer(input)) {
-                // Probe from buffer
-                const format = InputFormat.probe(input);
-                if (!format) {
-                    return null;
-                }
-                return {
-                    format: format.name ?? 'unknown',
-                    longName: format.longName ?? undefined,
-                    extensions: format.extensions ?? undefined,
-                    mimeType: format.mimeType ?? undefined,
-                    confidence: 100, // Direct probe always has high confidence
-                };
-            }
-            else {
-                // For files, read first part and probe
-                let fd;
-                try {
-                    fd = openSync(input, 'r');
-                    // Read first 64KB for probing
-                    const buffer = Buffer.alloc(65536);
-                    const bytesRead = readSync(fd, buffer, 0, 65536, 0);
-                    const probeBuffer = buffer.subarray(0, bytesRead);
-                    const format = InputFormat.probe(probeBuffer, input);
-                    if (!format) {
-                        return null;
-                    }
-                    return {
-                        format: format.name ?? 'unknown',
-                        longName: format.longName ?? undefined,
-                        extensions: format.extensions ?? undefined,
-                        mimeType: format.mimeType ?? undefined,
-                        confidence: 90, // File-based probe with filename hint
-                    };
-                }
-                catch {
-                    // If file reading fails, return null
-                    return null;
-                }
-                finally {
-                    if (fd !== undefined)
-                        closeSync(fd);
-                }
-            }
-        }
-        catch {
-            return null;
-        }
-    }
-    static async open(input, options = {}) {
-        // Check if input is raw data
-        if (typeof input === 'object' && 'type' in input && ('width' in input || 'sampleRate' in input)) {
-            // Build options for raw data
-            const rawOptions = {
-                bufferSize: options.bufferSize,
-                format: options.format ?? (input.type === 'video' ? 'rawvideo' : 's16le'),
-                options: {
-                    ...options.options,
-                },
-            };
-            if (input.type === 'video') {
-                rawOptions.options = {
-                    ...rawOptions.options,
-                    video_size: `${input.width}x${input.height}`,
-                    pixel_format: avGetPixFmtName(input.pixelFormat) ?? 'yuv420p',
-                    framerate: new Rational(input.frameRate.num, input.frameRate.den).toString(),
-                };
-            }
-            else {
-                rawOptions.options = {
-                    ...rawOptions.options,
-                    sample_rate: input.sampleRate,
-                    channels: input.channels,
-                    sample_fmt: avGetSampleFmtName(input.sampleFormat) ?? 's16le',
-                };
-            }
-            // Open with the raw data source
-            return MediaInput.open(input.input, rawOptions);
-        }
-        // Original implementation for non-raw data
-        const formatContext = new FormatContext();
-        let ioContext;
-        let optionsDict = null;
-        let inputFormat = null;
-        try {
-            // Create options dictionary if options are provided
-            if (options.options) {
-                optionsDict = Dictionary.fromObject(options.options);
-            }
-            // Find input format if specified
-            if (options.format) {
-                inputFormat = InputFormat.findInputFormat(options.format);
-                if (!inputFormat) {
-                    throw new Error(`Input format '${options.format}' not found`);
-                }
-            }
-            if (typeof input === 'string') {
-                // File path or URL - resolve relative paths to absolute
-                // Check if it's a URL (starts with protocol://) or a file path
-                const isUrl = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(input);
-                const resolvedInput = isUrl ? input : resolve(input);
-                const ret = await formatContext.openInput(resolvedInput, inputFormat, optionsDict);
-                FFmpegError.throwIfError(ret, 'Failed to open input');
-                formatContext.setFlags(AVFMT_FLAG_NONBLOCK);
-            }
-            else if (Buffer.isBuffer(input)) {
-                // Validate buffer is not empty
-                if (input.length === 0) {
-                    throw new Error('Cannot open media from empty buffer');
-                }
-                // From buffer - allocate context first for custom I/O
-                formatContext.allocContext();
-                ioContext = IOStream.create(input, { bufferSize: options.bufferSize });
-                formatContext.pb = ioContext;
-                const ret = await formatContext.openInput('', inputFormat, optionsDict);
-                FFmpegError.throwIfError(ret, 'Failed to open input from buffer');
-            }
-            else if (typeof input === 'object' && 'read' in input) {
-                // Custom I/O with callbacks - format is required
-                if (!options.format) {
-                    throw new Error('Format must be specified for custom I/O');
-                }
-                // Allocate context first for custom I/O
-                formatContext.allocContext();
-                // Setup custom I/O with callbacks
-                ioContext = new IOContext();
-                ioContext.allocContextWithCallbacks(options.bufferSize ?? 8192, 0, input.read, null, input.seek);
-                formatContext.pb = ioContext;
-                formatContext.flags = AVFMT_FLAG_CUSTOM_IO;
-                const ret = await formatContext.openInput('', inputFormat, optionsDict);
-                FFmpegError.throwIfError(ret, 'Failed to open input from custom I/O');
-            }
-            else {
-                throw new TypeError('Invalid input type. Expected file path, URL, Buffer, or IOInputCallbacks');
-            }
-            // Find stream information
-            const ret = await formatContext.findStreamInfo(null);
-            FFmpegError.throwIfError(ret, 'Failed to find stream info');
-            const mediaInput = new MediaInput(formatContext, ioContext);
-            return mediaInput;
-        }
-        catch (error) {
-            // Clean up only on error
-            if (ioContext) {
-                // Clear the pb reference first
-                formatContext.pb = null;
-                // Free the IOContext (for both custom I/O and buffer-based I/O)
-                ioContext.freeContext();
-            }
-            // Clean up FormatContext
-            await formatContext.closeInput();
-            throw error;
-        }
-        finally {
-            // Clean up options dictionary
-            if (optionsDict) {
-                optionsDict.free();
-            }
-        }
-    }
-    static openSync(input, options = {}) {
-        // Check if input is raw data
-        if (typeof input === 'object' && 'type' in input && ('width' in input || 'sampleRate' in input)) {
-            // Build options for raw data
-            const rawOptions = {
-                bufferSize: options.bufferSize,
-                format: options.format ?? (input.type === 'video' ? 'rawvideo' : 's16le'),
-                options: {
-                    ...options.options,
-                },
-            };
-            if (input.type === 'video') {
-                rawOptions.options = {
-                    ...rawOptions.options,
-                    video_size: `${input.width}x${input.height}`,
-                    pixel_format: avGetPixFmtName(input.pixelFormat) ?? 'yuv420p',
-                    framerate: new Rational(input.frameRate.num, input.frameRate.den).toString(),
-                };
-            }
-            else {
-                rawOptions.options = {
-                    ...rawOptions.options,
-                    sample_rate: input.sampleRate,
-                    channels: input.channels,
-                    sample_fmt: avGetSampleFmtName(input.sampleFormat) ?? 's16le',
-                };
-            }
-            // Open with the raw data source
-            return MediaInput.openSync(input.input, rawOptions);
-        }
-        // Original implementation for non-raw data
-        const formatContext = new FormatContext();
-        let ioContext;
-        let optionsDict = null;
-        let inputFormat = null;
-        try {
-            // Create options dictionary if options are provided
-            if (options.options) {
-                optionsDict = Dictionary.fromObject(options.options);
-            }
-            // Find input format if specified
-            if (options.format) {
-                inputFormat = InputFormat.findInputFormat(options.format);
-                if (!inputFormat) {
-                    throw new Error(`Input format '${options.format}' not found`);
-                }
-            }
-            if (typeof input === 'string') {
-                // File path or URL - resolve relative paths to absolute
-                // Check if it's a URL (starts with protocol://) or a file path
-                const isUrl = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(input);
-                const resolvedInput = isUrl ? input : resolve(input);
-                const ret = formatContext.openInputSync(resolvedInput, inputFormat, optionsDict);
-                FFmpegError.throwIfError(ret, 'Failed to open input');
-                formatContext.setFlags(AVFMT_FLAG_NONBLOCK);
-            }
-            else if (Buffer.isBuffer(input)) {
-                // Validate buffer is not empty
-                if (input.length === 0) {
-                    throw new Error('Cannot open media from empty buffer');
-                }
-                // From buffer - allocate context first for custom I/O
-                formatContext.allocContext();
-                ioContext = IOStream.create(input, { bufferSize: options.bufferSize });
-                formatContext.pb = ioContext;
-                const ret = formatContext.openInputSync('', inputFormat, optionsDict);
-                FFmpegError.throwIfError(ret, 'Failed to open input from buffer');
-            }
-            else if (typeof input === 'object' && 'read' in input) {
-                // Custom I/O with callbacks - format is required
-                if (!options.format) {
-                    throw new Error('Format must be specified for custom I/O');
-                }
-                // Allocate context first for custom I/O
-                formatContext.allocContext();
-                // Setup custom I/O with callbacks
-                ioContext = new IOContext();
-                ioContext.allocContextWithCallbacks(options.bufferSize ?? 8192, 0, input.read, null, input.seek);
-                formatContext.pb = ioContext;
-                formatContext.flags = AVFMT_FLAG_CUSTOM_IO;
-                const ret = formatContext.openInputSync('', inputFormat, optionsDict);
-                FFmpegError.throwIfError(ret, 'Failed to open input from custom I/O');
-            }
-            else {
-                throw new TypeError('Invalid input type. Expected file path, URL, Buffer, or IOInputCallbacks');
-            }
-            // Find stream information
-            const ret = formatContext.findStreamInfoSync(null);
-            FFmpegError.throwIfError(ret, 'Failed to find stream info');
-            const mediaInput = new MediaInput(formatContext, ioContext);
-            return mediaInput;
-        }
-        catch (error) {
-            // Clean up only on error
-            if (ioContext) {
-                // Clear the pb reference first
-                formatContext.pb = null;
-                // Free the IOContext (for both custom I/O and buffer-based I/O)
-                ioContext.freeContext();
-            }
-            // Clean up FormatContext
-            formatContext.closeInputSync();
-            throw error;
-        }
-        finally {
-            // Clean up options dictionary
-            if (optionsDict) {
-                optionsDict.free();
-            }
-        }
-    }
-    /**
-     * Check if input is open.
-     *
-     * @example
-     * ```typescript
-     * if (!input.isInputOpen) {
-     *   console.log('Input is not open');
-     * }
-     * ```
-     */
-    get isInputOpen() {
-        return !this.isClosed;
-    }
-    /**
-     * Get all streams in the media.
-     *
-     * @example
-     * ```typescript
-     * for (const stream of input.streams) {
-     *   console.log(`Stream ${stream.index}: ${stream.codecpar.codecType}`);
-     * }
-     * ```
-     */
-    get streams() {
-        return this._streams;
-    }
-    /**
-     * Get media duration in seconds.
-     *
-     * Returns 0 if duration is unknown or not available or input is closed.
-     *
-     * @example
-     * ```typescript
-     * console.log(`Duration: ${input.duration} seconds`);
-     * ```
-     */
-    get duration() {
-        if (this.isClosed) {
-            return 0;
-        }
-        const duration = this.formatContext.duration;
-        if (!duration || duration <= 0) {
-            return 0;
-        }
-        // Convert from AV_TIME_BASE (microseconds) to seconds
-        return Number(duration) / 1000000;
-    }
-    /**
-     * Get media bitrate in kilobits per second.
-     *
-     * Returns 0 if bitrate is unknown or not available or input is closed.
-     *
-     * @example
-     * ```typescript
-     * console.log(`Bitrate: ${input.bitRate} kbps`);
-     * ```
-     */
-    get bitRate() {
-        if (this.isClosed) {
-            return 0;
-        }
-        const bitrate = this.formatContext.bitRate;
-        if (!bitrate || bitrate <= 0) {
-            return 0;
-        }
-        // Convert from bits per second to kilobits per second
-        return Number(bitrate) / 1000;
-    }
-    /**
-     * Get media metadata.
-     *
-     * Returns all metadata tags as key-value pairs.
-     *
-     * @example
-     * ```typescript
-     * const metadata = input.metadata;
-     * console.log(`Title: ${metadata.title}`);
-     * console.log(`Artist: ${metadata.artist}`);
-     * ```
-     */
-    get metadata() {
-        if (this.isClosed) {
-            return {};
-        }
-        return this.formatContext.metadata?.getAll() ?? {};
-    }
-    /**
-     * Get format name.
-     *
-     * Returns 'unknown' if input is closed or format is not available.
-     *
-     * @example
-     * ```typescript
-     * console.log(`Format: ${input.formatName}`); // "mov,mp4,m4a,3gp,3g2,mj2"
-     * ```
-     */
-    get formatName() {
-        if (this.isClosed) {
-            return 'unknown';
-        }
-        return this.formatContext.iformat?.name ?? 'unknown';
-    }
-    /**
-     * Get format long name.
-     *
-     * Returns 'Unknown Format' if input is closed or format is not available.
-     *
-     * @example
-     * ```typescript
-     * console.log(`Format: ${input.formatLongName}`); // "QuickTime / MOV"
-     * ```
-     */
-    get formatLongName() {
-        if (this.isClosed) {
-            return 'Unknown Format';
-        }
-        return this.formatContext.iformat?.longName ?? 'Unknown Format';
-    }
-    /**
-     * Get MIME type of the input format.
-     *
-     * Returns null if input is closed or format is not available.
-     *
-     * @example
-     * ```typescript
-     * console.log(`MIME Type: ${input.mimeType}`); // "video/mp4"
-     * ```
-     */
-    get mimeType() {
-        if (this.isClosed) {
-            return null;
-        }
-        return this.formatContext.iformat?.mimeType ?? null;
-    }
-    /**
-     * Get input stream by index.
-     *
-     * Returns the stream at the specified index.
-     *
-     * @param index - Stream index
-     *
-     * @returns Stream or undefined if index is invalid
-     *
-     * @example
-     * ```typescript
-     * const input = await MediaInput.open('input.mp4');
-     *
-     * // Get the input stream to inspect codec parameters
-     * const stream = input.getStream(1); // Get stream at index 1
-     * if (stream) {
-     *   console.log(`Input codec: ${stream.codecpar.codecId}`);
-     * }
-     * ```
-     *
-     * @see {@link video} For getting video streams
-     * @see {@link audio} For getting audio streams
-     */
-    getStream(index) {
-        const streams = this.formatContext.streams;
-        if (!streams || index < 0 || index >= streams.length) {
-            return undefined;
-        }
-        return streams[index];
-    }
-    /**
-     * Get video stream by index.
-     *
-     * Returns the nth video stream (0-based index).
-     * Returns undefined if stream doesn't exist.
-     *
-     * @param index - Video stream index (default: 0)
-     *
-     * @returns Video stream or undefined
-     *
-     * @example
-     * ```typescript
-     * const videoStream = input.video();
-     * if (videoStream) {
-     *   console.log(`Video: ${videoStream.codecpar.width}x${videoStream.codecpar.height}`);
-     * }
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Get second video stream
-     * const secondVideo = input.video(1);
-     * ```
-     *
-     * @see {@link audio} For audio streams
-     * @see {@link findBestStream} For automatic selection
-     */
-    video(index = 0) {
-        const streams = this._streams.filter((s) => s.codecpar.codecType === AVMEDIA_TYPE_VIDEO);
-        return streams[index];
-    }
-    /**
-     * Get audio stream by index.
-     *
-     * Returns the nth audio stream (0-based index).
-     * Returns undefined if stream doesn't exist.
-     *
-     * @param index - Audio stream index (default: 0)
-     *
-     * @returns Audio stream or undefined
-     *
-     * @example
-     * ```typescript
-     * const audioStream = input.audio();
-     * if (audioStream) {
-     *   console.log(`Audio: ${audioStream.codecpar.sampleRate}Hz`);
-     * }
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Get second audio stream
-     * const secondAudio = input.audio(1);
-     * ```
-     *
-     * @see {@link video} For video streams
-     * @see {@link findBestStream} For automatic selection
-     */
-    audio(index = 0) {
-        const streams = this._streams.filter((s) => s.codecpar.codecType === AVMEDIA_TYPE_AUDIO);
-        return streams[index];
-    }
-    /**
-     * Get input format details.
-     *
-     * Returns null if input is closed or format is not available.
-     *
-     * @returns Input format or null
-     *
-     * @example
-     * ```typescript
-     * const inputFormat = input.inputFormat;
-     * if (inputFormat) {
-     *   console.log(`Input Format: ${inputFormat.name}`);
-     * }
-     * ```
-     */
-    inputFormat() {
-        return this.formatContext.iformat;
-    }
-    /**
-     * Find the best stream of a given type.
-     *
-     * Uses FFmpeg's stream selection algorithm.
-     * Considers codec support, default flags, and quality.
-     *
-     * Direct mapping to av_find_best_stream().
-     *
-     * @param type - Media type to find
-     *
-     * @returns Best stream or undefined if not found or input is closed
-     *
-     * @example
-     * ```typescript
-     * import { AVMEDIA_TYPE_VIDEO } from 'node-av/constants';
-     *
-     * const bestVideo = input.findBestStream(AVMEDIA_TYPE_VIDEO);
-     * if (bestVideo) {
-     *   const decoder = await Decoder.create(bestVideo);
-     * }
-     * ```
-     *
-     * @see {@link video} For direct video stream access
-     * @see {@link audio} For direct audio stream access
-     */
-    findBestStream(type) {
-        if (this.isClosed) {
-            return undefined;
-        }
-        const bestStreamIndex = this.formatContext.findBestStream(type);
-        return this._streams.find((s) => s.index === bestStreamIndex);
-    }
-    /**
-     * Read packets from media as async generator.
-     *
-     * Yields demuxed packets for processing.
-     * Automatically handles packet memory management.
-     * Optionally filters packets by stream index.
-     *
-     * Direct mapping to av_read_frame().
-     *
-     * @param index - Optional stream index to filter
-     *
-     * @yields {Packet} Demuxed packets (must be freed by caller)
-     *
-     * @throws {Error} If packet cloning fails
-     *
-     * @example
-     * ```typescript
-     * // Read all packets
-     * for await (const packet of input.packets()) {
-     *   console.log(`Packet: stream=${packet.streamIndex}, pts=${packet.pts}`);
-     *   packet.free();
-     * }
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Read only video packets
-     * const videoStream = input.video();
-     * for await (const packet of input.packets(videoStream.index)) {
-     *   // Process video packet
-     *   packet.free();
-     * }
-     * ```
-     *
-     * @see {@link Decoder.frames} For decoding packets
-     */
-    async *packets(index) {
-        const packet = new Packet();
-        packet.alloc();
-        try {
-            while (!this.isClosed) {
-                const ret = await this.formatContext.readFrame(packet);
-                if (ret < 0) {
-                    // End of file or error
-                    break;
-                }
-                if (index === undefined || packet.streamIndex === index) {
-                    // Clone the packet for the user
-                    // This creates a new Packet object that shares the same data buffer
-                    // through reference counting. The data won't be freed until both
-                    // the original and the clone are unreferenced.
-                    const cloned = packet.clone();
-                    if (!cloned) {
-                        throw new Error('Failed to clone packet (out of memory)');
-                    }
-                    yield cloned;
-                }
-                // Unreference the original packet's data buffer
-                // This allows us to reuse the packet object for the next readFrame()
-                // The data itself is still alive because the clone has a reference
-                packet.unref();
-            }
-        }
-        finally {
-            packet.free();
-        }
-    }
-    /**
-     * Read packets from media as generator synchronously.
-     * Synchronous version of packets.
-     *
-     * Yields demuxed packets for processing.
-     * Automatically handles packet memory management.
-     * Optionally filters packets by stream index.
-     *
-     * Direct mapping to av_read_frame().
-     *
-     * @param index - Optional stream index to filter
-     *
-     * @yields {Packet} Demuxed packets (must be freed by caller)
-     *
-     * @throws {Error} If packet cloning fails
-     *
-     * @example
-     * ```typescript
-     * // Read all packets
-     * for (const packet of input.packetsSync()) {
-     *   console.log(`Packet: stream=${packet.streamIndex}, pts=${packet.pts}`);
-     *   packet.free();
-     * }
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Read only video packets
-     * const videoStream = input.video();
-     * for (const packet of input.packetsSync(videoStream.index)) {
-     *   // Process video packet
-     *   packet.free();
-     * }
-     * ```
-     *
-     * @see {@link packets} For async version
-     */
-    *packetsSync(index) {
-        const packet = new Packet();
-        packet.alloc();
-        try {
-            while (!this.isClosed) {
-                const ret = this.formatContext.readFrameSync(packet);
-                if (ret < 0) {
-                    // End of file or error
-                    break;
-                }
-                if (index === undefined || packet.streamIndex === index) {
-                    // Clone the packet for the user
-                    // This creates a new Packet object that shares the same data buffer
-                    // through reference counting. The data won't be freed until both
-                    // the original and the clone are unreferenced.
-                    const cloned = packet.clone();
-                    if (!cloned) {
-                        throw new Error('Failed to clone packet (out of memory)');
-                    }
-                    yield cloned;
-                }
-                // Unreference the original packet's data buffer
-                // This allows us to reuse the packet object for the next readFrame()
-                // The data itself is still alive because the clone has a reference
-                packet.unref();
-            }
-        }
-        finally {
-            packet.free();
-        }
-    }
-    /**
-     * Seek to timestamp in media.
-     *
-     * Seeks to the specified position in seconds.
-     * Can seek in specific stream or globally.
-     *
-     * Direct mapping to av_seek_frame().
-     *
-     * @param timestamp - Target position in seconds
-     *
-     * @param streamIndex - Stream index or -1 for global (default: -1)
-     *
-     * @param flags - Seek flags (default: AVFLAG_NONE)
-     *
-     * @returns 0 on success, negative on error
-     *
-     * @throws {Error} If input is closed
-     *
-     * @example
-     * ```typescript
-     * // Seek to 30 seconds
-     * const ret = await input.seek(30);
-     * FFmpegError.throwIfError(ret, 'seek failed');
-     * ```
-     *
-     * @example
-     * ```typescript
-     * import { AVSEEK_FLAG_BACKWARD } from 'node-av/constants';
-     *
-     * // Seek to keyframe before 60 seconds
-     * await input.seek(60, -1, AVSEEK_FLAG_BACKWARD);
-     * ```
-     *
-     * @see {@link AVSeekFlag} For seek flags
-     */
-    async seek(timestamp, streamIndex = -1, flags = AVFLAG_NONE) {
-        if (this.isClosed) {
-            throw new Error('Cannot seek on closed input');
-        }
-        // Convert seconds to AV_TIME_BASE
-        const ts = BigInt(Math.floor(timestamp * 1000000));
-        return this.formatContext.seekFrame(streamIndex, ts, flags);
-    }
-    /**
-     * Seek to timestamp in media synchronously.
-     * Synchronous version of seek.
-     *
-     * Seeks to the specified position in seconds.
-     * Can seek in specific stream or globally.
-     *
-     * Direct mapping to av_seek_frame().
-     *
-     * @param timestamp - Target position in seconds
-     *
-     * @param streamIndex - Stream index or -1 for global (default: -1)
-     *
-     * @param flags - Seek flags (default: AVFLAG_NONE)
-     *
-     * @returns 0 on success, negative on error
-     *
-     * @throws {Error} If input is closed
-     *
-     * @example
-     * ```typescript
-     * // Seek to 30 seconds
-     * const ret = input.seekSync(30);
-     * FFmpegError.throwIfError(ret, 'seek failed');
-     * ```
-     *
-     * @example
-     * ```typescript
-     * import { AVSEEK_FLAG_BACKWARD } from 'node-av/constants';
-     *
-     * // Seek to keyframe before 60 seconds
-     * input.seekSync(60, -1, AVSEEK_FLAG_BACKWARD);
-     * ```
-     *
-     * @see {@link seek} For async version
-     */
-    seekSync(timestamp, streamIndex = -1, flags = AVFLAG_NONE) {
-        if (this.isClosed) {
-            throw new Error('Cannot seek on closed input');
-        }
-        // Convert seconds to AV_TIME_BASE
-        const ts = BigInt(Math.floor(timestamp * 1000000));
-        return this.formatContext.seekFrameSync(streamIndex, ts, flags);
-    }
-    /**
-     * Close media input and free resources.
-     *
-     * Releases format context and I/O context.
-     * Safe to call multiple times.
-     * Automatically called by Symbol.asyncDispose.
-     *
-     * Direct mapping to avformat_close_input().
-     *
-     * @example
-     * ```typescript
-     * const input = await MediaInput.open('video.mp4');
-     * try {
-     *   // Use input
-     * } finally {
-     *   await input.close();
-     * }
-     * ```
-     *
-     * @see {@link Symbol.asyncDispose} For automatic cleanup
-     */
-    async close() {
-        if (this.isClosed) {
-            return;
-        }
-        this.isClosed = true;
-        // IMPORTANT: Clear pb reference FIRST to prevent use-after-free
-        if (this.ioContext) {
-            this.formatContext.pb = null;
-        }
-        // Close FormatContext
-        await this.formatContext.closeInput();
-        // NOW we can safely free the IOContext
-        if (this.ioContext) {
-            this.ioContext.freeContext();
-            this.ioContext = undefined;
-        }
-    }
-    /**
-     * Close media input and free resources synchronously.
-     * Synchronous version of close.
-     *
-     * Releases format context and I/O context.
-     * Safe to call multiple times.
-     * Automatically called by Symbol.dispose.
-     *
-     * Direct mapping to avformat_close_input().
-     *
-     * @example
-     * ```typescript
-     * const input = MediaInput.openSync('video.mp4');
-     * try {
-     *   // Use input
-     * } finally {
-     *   input.closeSync();
-     * }
-     * ```
-     *
-     * @see {@link close} For async version
-     */
-    closeSync() {
-        if (this.isClosed) {
-            return;
-        }
-        this.isClosed = true;
-        // IMPORTANT: Clear pb reference FIRST to prevent use-after-free
-        if (this.ioContext) {
-            this.formatContext.pb = null;
-        }
-        // Close FormatContext
-        this.formatContext.closeInputSync();
-        // NOW we can safely free the IOContext
-        if (this.ioContext) {
-            this.ioContext.freeContext();
-            this.ioContext = undefined;
-        }
-    }
-    /**
-     * Get underlying format context.
-     *
-     * Returns the internal format context for advanced operations.
-     *
-     * @returns Format context
-     *
-     * @internal
-     */
-    getFormatContext() {
-        return this.formatContext;
-    }
-    /**
-     * Dispose of media input.
-     *
-     * Implements AsyncDisposable interface for automatic cleanup.
-     * Equivalent to calling close().
-     *
-     * @example
-     * ```typescript
-     * {
-     *   await using input = await MediaInput.open('video.mp4');
-     *   // Process media...
-     * } // Automatically closed
-     * ```
-     *
-     * @see {@link close} For manual cleanup
-     */
-    async [Symbol.asyncDispose]() {
-        await this.close();
-    }
-    /**
-     * Dispose of media input synchronously.
-     *
-     * Implements Disposable interface for automatic cleanup.
-     * Equivalent to calling closeSync().
-     *
-     * @example
-     * ```typescript
-     * {
-     *   using input = MediaInput.openSync('video.mp4');
-     *   // Process media...
-     * } // Automatically closed
-     * ```
-     *
-     * @see {@link closeSync} For manual cleanup
-     */
-    [Symbol.dispose]() {
-        this.closeSync();
-    }
-}
-//# sourceMappingURL=media-input.js.map