node-av 1.3.0 → 2.1.0

package/dist/api/media-output.js

@@ -1,3 +1,4 @@
+import { mkdirSync } from 'fs';
 import { mkdir } from 'fs/promises';
 import { dirname, resolve } from 'path';
 import { AVFMT_FLAG_CUSTOM_IO, AVFMT_NOFILE, AVIO_FLAG_WRITE } from '../constants/constants.js';
@@ -7,6 +8,8 @@ import { Encoder } from './encoder.js';
  * High-level media output for writing and muxing media files.
  *
  * Provides simplified access to media muxing and file writing operations.
+ * Automatically manages header and trailer writing - header is written on first packet,
+ * trailer is written on close. Supports lazy initialization for both encoders and streams.
  * Handles stream configuration, packet writing, and format management.
  * Supports files, URLs, and custom I/O with automatic cleanup.
  * Essential component for media encoding pipelines and transcoding.
@@ -22,14 +25,11 @@ import { Encoder } from './encoder.js';
  * const videoIdx = output.addStream(videoEncoder);
  * const audioIdx = output.addStream(audioEncoder);
  *
- * // Write header
- * await output.writeHeader();
- *
- * // Write packets
+ * // Write packets - header written automatically on first packet
  * await output.writePacket(packet, videoIdx);
  *
- * // Write trailer and close
- * await output.writeTrailer();
+ * // Close - trailer written automatically
+ * // (automatic with await using)
  * ```
  *
  * @example
@@ -40,8 +40,8 @@ import { Encoder } from './encoder.js';
  *
  * // Copy stream configuration
  * const videoIdx = output.addStream(input.video());
- * await output.writeHeader();
  *
+ * // Process packets - header/trailer handled automatically
  * for await (const packet of input.packets()) {
  *   await output.writePacket(packet, videoIdx);
  *   packet.free();
@@ -58,7 +58,8 @@ export class MediaOutput {
     ioContext;
     headerWritten = false;
     trailerWritten = false;
-    closed = false;
+    isClosed = false;
+    headerWritePromise;
     /**
      * @internal
      */
@@ -75,7 +76,9 @@ export class MediaOutput {
      * Direct mapping to avformat_alloc_output_context2() and avio_open2().
      *
      * @param target - File path, URL, or I/O callbacks
+     *
      * @param options - Output configuration options
+     *
      * @returns Opened media output instance
      *
      * @throws {Error} If format required for custom I/O
@@ -193,25 +196,142 @@ export class MediaOutput {
             throw error;
         }
     }
+    /**
+     * Open media output for writing synchronously.
+     * Synchronous version of open.
+     *
+     * Creates and configures output context for muxing.
+     * Automatically creates directories for file output.
+     * Supports files, URLs, and custom I/O callbacks.
+     *
+     * Direct mapping to avformat_alloc_output_context2() and avio_open2().
+     *
+     * @param target - File path, URL, or I/O callbacks
+     *
+     * @param options - Output configuration options
+     *
+     * @returns Opened media output instance
+     *
+     * @throws {Error} If format required for custom I/O
+     *
+     * @throws {FFmpegError} If allocation or opening fails
+     *
+     * @example
+     * ```typescript
+     * // Create file output
+     * using output = MediaOutput.openSync('output.mp4');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Create output with specific format
+     * using output = MediaOutput.openSync('output.ts', {
+     *   format: 'mpegts'
+     * });
+     * ```
+     *
+     * @see {@link open} For async version
+     */
+    static openSync(target, options) {
+        const output = new MediaOutput();
+        try {
+            if (typeof target === 'string') {
+                // File or stream URL - resolve relative paths and create directories
+                // Check if it's a URL (starts with protocol://) or a file path
+                const isUrl = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(target);
+                const resolvedTarget = isUrl ? target : resolve(target);
+                // Create directory structure for local files (not URLs)
+                if (!isUrl && target !== '') {
+                    const dir = dirname(resolvedTarget);
+                    mkdirSync(dir, { recursive: true });
+                }
+                // Allocate output context
+                const ret = output.formatContext.allocOutputContext2(null, options?.format ?? null, resolvedTarget === '' ? null : resolvedTarget);
+                FFmpegError.throwIfError(ret, 'Failed to allocate output context');
+                // Check if we need to open IO
+                const oformat = output.formatContext.oformat;
+                if (resolvedTarget && oformat && !(oformat.flags & AVFMT_NOFILE)) {
+                    // For file-based formats, we need to open the file using avio_open2
+                    // FFmpeg will manage the AVIOContext internally
+                    output.ioContext = new IOContext();
+                    const openRet = output.ioContext.open2Sync(resolvedTarget, AVIO_FLAG_WRITE);
+                    FFmpegError.throwIfError(openRet, `Failed to open output file: ${resolvedTarget}`);
+                    output.formatContext.pb = output.ioContext;
+                }
+            }
+            else {
+                // Custom IO with callbacks - format is required
+                if (!options?.format) {
+                    throw new Error('Format must be specified for custom IO');
+                }
+                const ret = output.formatContext.allocOutputContext2(null, options.format, null);
+                FFmpegError.throwIfError(ret, 'Failed to allocate output context');
+                // Setup custom IO with callbacks
+                output.ioContext = new IOContext();
+                output.ioContext.allocContextWithCallbacks(options.bufferSize ?? 4096, 1, target.read, target.write, target.seek);
+                output.ioContext.maxPacketSize = options.bufferSize ?? 4096;
+                output.formatContext.pb = output.ioContext;
+                output.formatContext.flags = AVFMT_FLAG_CUSTOM_IO;
+            }
+            return output;
+        }
+        catch (error) {
+            // Cleanup on error
+            if (output.ioContext) {
+                try {
+                    const isCustomIO = (output.formatContext.flags & AVFMT_FLAG_CUSTOM_IO) !== 0;
+                    if (isCustomIO) {
+                        // Clear the pb reference first
+                        output.formatContext.pb = null;
+                        // For custom IO with callbacks, free the context
+                        output.ioContext.freeContext();
+                    }
+                    else {
+                        // For file-based IO, close the file handle
+                        output.ioContext.closepSync();
+                    }
+                }
+                catch {
+                    // Ignore errors
+                }
+            }
+            if (output.formatContext) {
+                try {
+                    output.formatContext.freeContext();
+                }
+                catch {
+                    // Ignore errors
+                }
+            }
+            throw error;
+        }
+    }
     /**
      * Add a stream to the output.
      *
      * Configures output stream from encoder or input stream.
-     * Must be called before writeHeader().
+     * Must be called before writing any packets.
      * Returns stream index for packet writing.
      *
-     * Direct mapping to avformat_new_stream() and avcodec_parameters_copy().
+     * Streams are initialized lazily - codec parameters are configured
+     * automatically when the first packet is written. This allows encoders
+     * to be initialized from frame properties.
+     *
+     * Direct mapping to avformat_new_stream().
      *
      * @param source - Encoder or stream to add
+     *
      * @param options - Stream configuration options
+     *
      * @param options.timeBase - Optional custom timebase for the stream
+     *
      * @returns Stream index for packet writing
      *
-     * @throws {Error} If called after header written or output closed
+     * @throws {Error} If called after packets have been written or output closed
      *
      * @example
      * ```typescript
-     * // Add stream from encoder
+     * // Add stream from encoder (lazy initialization)
      * const videoIdx = output.addStream(videoEncoder);
      * const audioIdx = output.addStream(audioEncoder);
      * ```
@@ -228,68 +348,74 @@ export class MediaOutput {
      * @see {@link Encoder} For transcoding source
      */
     addStream(source, options) {
-        if (this.closed) {
+        if (this.isClosed) {
             throw new Error('MediaOutput is closed');
         }
         if (this.headerWritten) {
-            throw new Error('Cannot add streams after header is written');
+            throw new Error('Cannot add streams after packets have been written');
         }
         const stream = this.formatContext.newStream(null);
         if (!stream) {
             throw new Error('Failed to create new stream');
         }
-        let isStreamCopy = false;
-        let sourceTimeBase;
-        if (source instanceof Encoder) {
-            // Transcoding with encoder
-            const codecContext = source.getCodecContext();
-            if (!codecContext) {
-                throw new Error('Failed to get codec context from encoder');
-            }
-            const ret = stream.codecpar.fromContext(codecContext);
-            FFmpegError.throwIfError(ret, 'Failed to copy codec parameters from encoder');
-            // Store the encoder's timebase as source (we'll need it for rescaling)
-            sourceTimeBase = codecContext.timeBase;
-            // Output stream uses encoder's timebase (or custom if specified)
-            stream.timeBase = options?.timeBase ? new Rational(options.timeBase.num, options.timeBase.den) : codecContext.timeBase;
+        const isStreamCopy = !(source instanceof Encoder);
+        // For stream copy, initialize immediately since we have all the info
+        if (isStreamCopy) {
+            const inputStream = source;
+            const ret = inputStream.codecpar.copy(stream.codecpar);
+            FFmpegError.throwIfError(ret, 'Failed to copy codec parameters');
+            // Set the timebases
+            const sourceTimeBase = inputStream.timeBase;
+            stream.timeBase = options?.timeBase ? new Rational(options.timeBase.num, options.timeBase.den) : inputStream.timeBase;
+            this.streams.set(stream.index, {
+                initialized: true,
+                stream,
+                source,
+                timeBase: options?.timeBase,
+                sourceTimeBase,
+                isStreamCopy: true,
+                bufferedPackets: [],
+            });
         }
         else {
-            // Stream copy
-            const ret = source.codecpar.copy(stream.codecpar);
-            FFmpegError.throwIfError(ret, 'Failed to copy codec parameters');
-            // Store the input stream's timebase as source (we'll need it for rescaling)
-            sourceTimeBase = source.timeBase;
-            // Output stream uses input stream's timebase (or custom if specified)
-            stream.timeBase = options?.timeBase ? new Rational(options.timeBase.num, options.timeBase.den) : source.timeBase;
-            stream.codecpar.codecTag = 0; // Important for format compatibility
-            isStreamCopy = true;
-        }
-        this.streams.set(stream.index, {
-            stream,
-            timeBase: stream.timeBase,
-            isStreamCopy,
-            sourceTimeBase,
-        });
+            this.streams.set(stream.index, {
+                initialized: false,
+                stream,
+                source,
+                timeBase: options?.timeBase,
+                sourceTimeBase: undefined, // Will be set on initialization
+                isStreamCopy: false,
+                bufferedPackets: [],
+            });
+        }
         return stream.index;
     }
     /**
      * Write a packet to the output.
      *
      * Writes muxed packet to the specified stream.
-     * Automatically handles timestamp rescaling.
-     * Must be called after writeHeader() and before writeTrailer().
+     * Automatically handles:
+     * - Stream initialization on first packet (lazy initialization)
+     * - Codec parameter configuration from encoder or input stream
+     * - Header writing on first packet
+     * - Timestamp rescaling between source and output timebases
+     *
+     * For encoder sources, the encoder must have processed at least one frame
+     * before packets can be written (encoder must be initialized).
      *
-     * Direct mapping to av_interleaved_write_frame().
+     * Direct mapping to avformat_write_header() (on first packet) and av_interleaved_write_frame().
      *
      * @param packet - Packet to write
+     *
      * @param streamIndex - Target stream index
-     * @throws {Error} If stream invalid or called at wrong time
+     *
+     * @throws {Error} If stream invalid or encoder not initialized
      *
      * @throws {FFmpegError} If write fails
      *
      * @example
      * ```typescript
-     * // Write encoded packet
+     * // Write encoded packet - header written automatically on first packet
      * const packet = await encoder.encode(frame);
      * if (packet) {
      *   await output.writePacket(packet, videoIdx);
@@ -309,119 +435,216 @@ export class MediaOutput {
      * ```
      *
      * @see {@link addStream} For adding streams
-     * @see {@link writeHeader} Must be called first
      */
     async writePacket(packet, streamIndex) {
-        if (this.closed) {
+        if (this.isClosed) {
             throw new Error('MediaOutput is closed');
         }
-        if (!this.headerWritten) {
-            throw new Error('Header must be written before packets');
-        }
         if (this.trailerWritten) {
-            throw new Error('Cannot write packets after trailer');
+            throw new Error('Cannot write packets after output is finalized');
         }
-        const streamInfo = this.streams.get(streamIndex);
-        if (!streamInfo) {
+        if (!this.streams.get(streamIndex)) {
             throw new Error(`Invalid stream index: ${streamIndex}`);
         }
+        // Initialize any encoder streams that are ready
+        for (const streamInfo of this.streams.values()) {
+            if (!streamInfo.initialized && streamInfo.source instanceof Encoder) {
+                const encoder = streamInfo.source;
+                const codecContext = encoder.getCodecContext();
+                // Skip if encoder not ready yet
+                if (!encoder.isEncoderInitialized || !codecContext) {
+                    continue;
+                }
+                // This encoder is ready, initialize it now
+                const ret = streamInfo.stream.codecpar.fromContext(codecContext);
+                FFmpegError.throwIfError(ret, 'Failed to copy codec parameters from encoder');
+                // Update the timebase from the encoder
+                streamInfo.sourceTimeBase = codecContext.timeBase;
+                // Output stream uses encoder's timebase (or custom if specified)
+                streamInfo.stream.timeBase = streamInfo.timeBase ? new Rational(streamInfo.timeBase.num, streamInfo.timeBase.den) : codecContext.timeBase;
+                // Mark as initialized
+                streamInfo.initialized = true;
+            }
+        }
+        const streamInfo = this.streams.get(streamIndex);
+        // Check if any streams are still uninitialized
+        const uninitialized = Array.from(this.streams.values()).some((s) => !s.initialized);
+        if (uninitialized) {
+            const clonedPacket = packet.clone();
+            packet.free();
+            if (clonedPacket) {
+                streamInfo.bufferedPackets.push(clonedPacket);
+            }
+            return;
+        }
+        // Automatically write header if not written yet
+        // Use a promise to ensure only one thread writes the header
+        if (!this.headerWritten) {
+            this.headerWritePromise ??= (async () => {
+                const ret = await this.formatContext.writeHeader();
+                FFmpegError.throwIfError(ret, 'Failed to write header');
+                this.headerWritten = true;
+            })();
+            // All threads wait for the header to be written
+            await this.headerWritePromise;
+        }
         // Set stream index
         packet.streamIndex = streamIndex;
-        // Rescale packet timestamps if source and output timebases differ
-        // Note: The stream's timebase may have been changed by writeHeader (e.g., MP4 uses 1/time_scale)
-        if (streamInfo.sourceTimeBase) {
-            const outputStream = this.formatContext.streams?.[streamIndex];
-            if (outputStream) {
-                // Only rescale if timebases actually differ
-                const srcTb = streamInfo.sourceTimeBase;
-                const dstTb = outputStream.timeBase;
-                if (srcTb.num !== dstTb.num || srcTb.den !== dstTb.den) {
-                    packet.rescaleTs(streamInfo.sourceTimeBase, outputStream.timeBase);
+        const write = async (pkt) => {
+            // Rescale packet timestamps if source and output timebases differ
+            // Note: The stream's timebase may have been changed by writeHeader (e.g., MP4 uses 1/time_scale)
+            if (streamInfo.sourceTimeBase) {
+                const outputStream = this.formatContext.streams?.[streamIndex];
+                if (outputStream) {
+                    // Only rescale if timebases actually differ
+                    const srcTb = streamInfo.sourceTimeBase;
+                    const dstTb = outputStream.timeBase;
+                    if (srcTb.num !== dstTb.num || srcTb.den !== dstTb.den) {
+                        pkt.rescaleTs(streamInfo.sourceTimeBase, outputStream.timeBase);
+                    }
                 }
             }
+            // Write the packet
+            const ret = await this.formatContext.interleavedWriteFrame(pkt);
+            FFmpegError.throwIfError(ret, 'Failed to write packet');
+        };
+        // Write any buffered packets first
+        for (const bufferedPacket of streamInfo.bufferedPackets) {
+            await write(bufferedPacket);
+            bufferedPacket.free();
         }
-        // Write the packet
-        const ret = await this.formatContext.interleavedWriteFrame(packet);
-        FFmpegError.throwIfError(ret, 'Failed to write packet');
+        streamInfo.bufferedPackets = [];
+        // Write the current packet
+        await write(packet);
     }
     /**
-     * Write file header.
+     * Write a packet to the output synchronously.
+     * Synchronous version of writePacket.
+     *
+     * Writes muxed packet to the specified stream.
+     * Automatically handles:
+     * - Stream initialization on first packet (lazy initialization)
+     * - Codec parameter configuration from encoder or input stream
+     * - Header writing on first packet
+     * - Timestamp rescaling between source and output timebases
      *
-     * Writes format header with stream configuration.
-     * Must be called after adding all streams and before writing packets.
-     * Finalizes stream parameters and initializes muxer.
+     * For encoder sources, the encoder must have processed at least one frame
+     * before packets can be written (encoder must be initialized).
      *
-     * Direct mapping to avformat_write_header().
+     * Direct mapping to avformat_write_header() (on first packet) and av_interleaved_write_frame().
      *
-     * @throws {Error} If already written or output closed
+     * @param packet - Packet to write
+     *
+     * @param streamIndex - Target stream index
+     *
+     * @throws {Error} If stream invalid or encoder not initialized
      *
      * @throws {FFmpegError} If write fails
      *
      * @example
      * ```typescript
-     * // Standard workflow
-     * const output = await MediaOutput.open('output.mp4');
-     * output.addStream(encoder);
-     * await output.writeHeader();
-     * // Now ready to write packets
+     * // Write encoded packet - header written automatically on first packet
+     * const packet = encoder.encodeSync(frame);
+     * if (packet) {
+     *   output.writePacketSync(packet, videoIdx);
+     *   packet.free();
+     * }
      * ```
      *
-     * @see {@link addStream} Must add streams first
-     * @see {@link writePacket} Can write packets after
-     * @see {@link writeTrailer} Must call at end
-     */
-    async writeHeader() {
-        if (this.closed) {
-            throw new Error('MediaOutput is closed');
-        }
-        if (this.headerWritten) {
-            throw new Error('Header already written');
-        }
-        const ret = await this.formatContext.writeHeader();
-        FFmpegError.throwIfError(ret, 'Failed to write header');
-        this.headerWritten = true;
-    }
-    /**
-     * Write file trailer.
-     *
-     * Writes format trailer and finalizes the file.
-     * Must be called after all packets are written.
-     * Flushes any buffered data and updates file headers.
-     *
-     * Direct mapping to av_write_trailer().
-     *
-     * @throws {Error} If header not written or already written
-     *
-     * @throws {FFmpegError} If write fails
-     *
      * @example
      * ```typescript
-     * // Finalize output
-     * await output.writeTrailer();
-     * await output.close();
+     * // Stream copy with packet processing
+     * for (const packet of input.packetsSync()) {
+     *   if (packet.streamIndex === inputVideoIdx) {
+     *     output.writePacketSync(packet, outputVideoIdx);
+     *   }
+     *   packet.free();
+     * }
      * ```
      *
-     * @see {@link writeHeader} Must be called first
-     * @see {@link close} For cleanup after trailer
+     * @see {@link writePacket} For async version
      */
-    async writeTrailer() {
-        if (this.closed) {
+    writePacketSync(packet, streamIndex) {
+        if (this.isClosed) {
             throw new Error('MediaOutput is closed');
         }
+        if (this.trailerWritten) {
+            throw new Error('Cannot write packets after output is finalized');
+        }
+        if (!this.streams.get(streamIndex)) {
+            throw new Error(`Invalid stream index: ${streamIndex}`);
+        }
+        // Initialize any encoder streams that are ready
+        for (const streamInfo of this.streams.values()) {
+            if (!streamInfo.initialized && streamInfo.source instanceof Encoder) {
+                const encoder = streamInfo.source;
+                const codecContext = encoder.getCodecContext();
+                // Skip if encoder not ready yet
+                if (!encoder.isEncoderInitialized || !codecContext) {
+                    continue;
+                }
+                // This encoder is ready, initialize it now
+                const ret = streamInfo.stream.codecpar.fromContext(codecContext);
+                FFmpegError.throwIfError(ret, 'Failed to copy codec parameters from encoder');
+                // Update the timebase from the encoder
+                streamInfo.sourceTimeBase = codecContext.timeBase;
+                // Output stream uses encoder's timebase (or custom if specified)
+                streamInfo.stream.timeBase = streamInfo.timeBase ? new Rational(streamInfo.timeBase.num, streamInfo.timeBase.den) : codecContext.timeBase;
+                // Mark as initialized
+                streamInfo.initialized = true;
+            }
+        }
+        const streamInfo = this.streams.get(streamIndex);
+        // Check if any streams are still uninitialized
+        const uninitialized = Array.from(this.streams.values()).some((s) => !s.initialized);
+        if (uninitialized) {
+            const clonedPacket = packet.clone();
+            packet.free();
+            if (clonedPacket) {
+                streamInfo.bufferedPackets.push(clonedPacket);
+            }
+            return;
+        }
+        // Automatically write header if not written yet
         if (!this.headerWritten) {
-            throw new Error('Cannot write trailer without header');
+            const ret = this.formatContext.writeHeaderSync();
+            FFmpegError.throwIfError(ret, 'Failed to write header');
+            this.headerWritten = true;
         }
-        if (this.trailerWritten) {
-            throw new Error('Trailer already written');
+        // Set stream index
+        packet.streamIndex = streamIndex;
+        const write = (pkt) => {
+            // Rescale packet timestamps if source and output timebases differ
+            // Note: The stream's timebase may have been changed by writeHeader (e.g., MP4 uses 1/time_scale)
+            if (streamInfo.sourceTimeBase) {
+                const outputStream = this.formatContext.streams?.[streamIndex];
+                if (outputStream) {
+                    // Only rescale if timebases actually differ
+                    const srcTb = streamInfo.sourceTimeBase;
+                    const dstTb = outputStream.timeBase;
+                    if (srcTb.num !== dstTb.num || srcTb.den !== dstTb.den) {
+                        pkt.rescaleTs(streamInfo.sourceTimeBase, outputStream.timeBase);
+                    }
+                }
+            }
+            // Write the packet
+            const ret = this.formatContext.interleavedWriteFrameSync(pkt);
+            FFmpegError.throwIfError(ret, 'Failed to write packet');
+        };
+        // Write any buffered packets first
+        for (const bufferedPacket of streamInfo.bufferedPackets) {
+            write(bufferedPacket);
+            bufferedPacket.free();
         }
-        const ret = await this.formatContext.writeTrailer();
-        FFmpegError.throwIfError(ret, 'Failed to write trailer');
-        this.trailerWritten = true;
+        streamInfo.bufferedPackets = [];
+        // Write the current packet
+        write(packet);
     }
     /**
      * Close media output and free resources.
      *
-     * Writes trailer if needed and releases all resources.
+     * Automatically writes trailer if header was written.
+     * Closes the output file and releases all resources.
      * Safe to call multiple times.
      * Automatically called by Symbol.asyncDispose.
      *
@@ -429,7 +652,7 @@ export class MediaOutput {
      * ```typescript
      * const output = await MediaOutput.open('output.mp4');
      * try {
-     *   // Use output
+     *   // Use output - trailer written automatically on close
      * } finally {
      *   await output.close();
      * }
@@ -438,14 +661,23 @@ export class MediaOutput {
      * @see {@link Symbol.asyncDispose} For automatic cleanup
      */
     async close() {
-        if (this.closed) {
+        if (this.isClosed) {
             return;
         }
-        this.closed = true;
+        this.isClosed = true;
+        // Free any buffered packets
+        for (const streamInfo of this.streams.values()) {
+            // Free any buffered packets
+            for (const pkt of streamInfo.bufferedPackets) {
+                pkt.free();
+            }
+            streamInfo.bufferedPackets = [];
+        }
         // Try to write trailer if header was written but trailer wasn't
         try {
             if (this.headerWritten && !this.trailerWritten) {
                 await this.formatContext.writeTrailer();
+                this.trailerWritten = true;
             }
         }
         catch {
@@ -487,67 +719,83 @@ export class MediaOutput {
         }
     }
     /**
-     * Get stream information.
-     *
-     * Returns internal stream info for the specified index.
-     *
-     * @param streamIndex - Stream index
-     * @returns Stream info or undefined
-     *
-     * @example
-     * ```typescript
-     * const info = output.getStreamInfo(0);
-     * console.log(`Stream 0 timebase: ${info?.timeBase.num}/${info?.timeBase.den}`);
-     * ```
-     */
-    getStreamInfo(streamIndex) {
-        return this.streams.get(streamIndex);
-    }
-    /**
-     * Get all stream indices.
-     *
-     * Returns array of all added stream indices.
-     *
-     * @returns Array of stream indices
-     *
-     * @example
-     * ```typescript
-     * const indices = output.getStreamIndices();
-     * console.log(`Output has ${indices.length} streams`);
-     * ```
-     */
-    getStreamIndices() {
-        return Array.from(this.streams.keys());
-    }
-    /**
-     * Check if header has been written.
+     * Close media output and free resources synchronously.
+     * Synchronous version of close.
      *
-     * @returns true if header written
+     * Automatically writes trailer if header was written.
+     * Closes the output file and releases all resources.
+     * Safe to call multiple times.
+     * Automatically called by Symbol.dispose.
      *
      * @example
      * ```typescript
-     * if (!output.isHeaderWritten()) {
-     *   await output.writeHeader();
+     * const output = MediaOutput.openSync('output.mp4');
+     * try {
+     *   // Use output - trailer written automatically on close
+     * } finally {
+     *   output.closeSync();
      * }
      * ```
-     */
-    isHeaderWritten() {
-        return this.headerWritten;
-    }
-    /**
-     * Check if trailer has been written.
      *
-     * @returns true if trailer written
-     *
-     * @example
-     * ```typescript
-     * if (!output.isTrailerWritten()) {
-     *   await output.writeTrailer();
-     * }
-     * ```
+     * @see {@link close} For async version
      */
-    isTrailerWritten() {
-        return this.trailerWritten;
+    closeSync() {
+        if (this.isClosed) {
+            return;
+        }
+        this.isClosed = true;
+        // Free any buffered packets
+        for (const streamInfo of this.streams.values()) {
+            // Free any buffered packets
+            for (const pkt of streamInfo.bufferedPackets) {
+                pkt.free();
+            }
+            streamInfo.bufferedPackets = [];
+        }
+        // Try to write trailer if header was written but trailer wasn't
+        try {
+            if (this.headerWritten && !this.trailerWritten) {
+                this.formatContext.writeTrailerSync();
+                this.trailerWritten = true;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        // Clear pb reference first to prevent use-after-free
+        if (this.ioContext) {
+            this.formatContext.pb = null;
+        }
+        // Determine if this is custom IO before freeing format context
+        const isCustomIO = (this.formatContext.flags & AVFMT_FLAG_CUSTOM_IO) !== 0;
+        // For file-based IO, close the file handle via closep
+        // For custom IO, the context will be freed below
+        if (this.ioContext && !isCustomIO) {
+            try {
+                this.ioContext.closepSync();
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        // Free format context
+        if (this.formatContext) {
+            try {
+                this.formatContext.freeContext();
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        // Now free custom IO context if present
+        if (this.ioContext && isCustomIO) {
+            try {
+                this.ioContext.freeContext();
+            }
+            catch {
+                // Ignore errors
+            }
+        }
     }
     /**
      * Get underlying format context.
@@ -580,5 +828,24 @@ export class MediaOutput {
     async [Symbol.asyncDispose]() {
         await this.close();
     }
+    /**
+     * Dispose of media output synchronously.
+     *
+     * Implements Disposable interface for automatic cleanup.
+     * Equivalent to calling closeSync().
+     *
+     * @example
+     * ```typescript
+     * {
+     *   using output = MediaOutput.openSync('output.mp4');
+     *   // Use output...
+     * } // Automatically closed
+     * ```
+     *
+     * @see {@link closeSync} For manual cleanup
+     */
+    [Symbol.dispose]() {
+        this.closeSync();
+    }
 }
 //# sourceMappingURL=media-output.js.map