node-av 3.0.5 → 3.1.0

package/dist/api/fmp4.js

@@ -0,0 +1,702 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { AV_CODEC_ID_AAC, AV_CODEC_ID_AV1, AV_CODEC_ID_FLAC, AV_CODEC_ID_H264, AV_CODEC_ID_HEVC, AV_CODEC_ID_OPUS, AV_HWDEVICE_TYPE_NONE, AV_SAMPLE_FMT_FLTP, } from '../constants/constants.js';
+import { FF_ENCODER_AAC, FF_ENCODER_LIBX264 } from '../constants/encoders.js';
+import { avGetCodecStringHls } from '../lib/utilities.js';
+import { Decoder } from './decoder.js';
+import { Encoder } from './encoder.js';
+import { FilterPreset } from './filter-presets.js';
+import { FilterAPI } from './filter.js';
+import { HardwareContext } from './hardware.js';
+import { MediaInput } from './media-input.js';
+import { MediaOutput } from './media-output.js';
+/**
+ * Target codec strings for fMP4 streaming.
+ */
+export const FMP4_CODECS = {
+    H264: 'avc1.640029',
+    H265: 'hvc1.1.6.L153.B0',
+    AV1: 'av01.0.00M.08',
+    AAC: 'mp4a.40.2',
+    FLAC: 'flac',
+    OPUS: 'opus',
+};
+/**
+ * High-level fMP4 streaming with automatic codec detection and transcoding.
+ *
+ * Provides fragmented MP4 streaming for clients.
+ * Automatically transcodes video to H.264 and audio to AAC if not supported by client.
+ * Client sends supported codecs, server transcodes accordingly.
+ * Essential component for building adaptive streaming servers.
+ *
+ * @example
+ * ```typescript
+ * import { FMP4Stream } from 'node-av/api';
+ *
+ * // Client sends supported codecs
+ * const supportedCodecs = 'avc1.640029,hvc1.1.6.L153.B0,mp4a.40.2,flac';
+ *
+ * // Create stream with codec negotiation
+ * const stream = await FMP4Stream.create('rtsp://camera.local/stream', {
+ *   supportedCodecs,
+ *   onChunk: (chunk) => ws.send(chunk)
+ * });
+ *
+ * // Start streaming (auto-transcodes if needed)
+ * await stream.start();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Stream with hardware acceleration
+ * const stream = await FMP4Stream.create('input.mp4', {
+ *   supportedCodecs: 'avc1.640029,mp4a.40.2',
+ *   hardware: 'auto',
+ *   fragDuration: 1,
+ *   onChunk: (chunk) => sendToClient(chunk)
+ * });
+ *
+ * await stream.start();
+ * stream.stop();
+ * stream.dispose();
+ * ```
+ *
+ * @see {@link MediaInput} For input media handling
+ * @see {@link MediaOutput} For fMP4 generation
+ * @see {@link HardwareContext} For GPU acceleration
+ */
+export class FMP4Stream {
+    input;
+    options;
+    output = null;
+    hardwareContext = null;
+    videoDecoder = null;
+    videoEncoder = null;
+    audioDecoder = null;
+    audioFilter = null;
+    audioEncoder = null;
+    streamActive = false;
+    supportedCodecs;
+    /**
+     * @param input - Media input source
+     *
+     * @param options - Stream configuration options
+     *
+     * Use {@link create} factory method
+     *
+     * @internal
+     */
+    constructor(input, options) {
+        this.input = input;
+        this.options = {
+            onChunk: options.onChunk ?? (() => { }),
+            supportedCodecs: options.supportedCodecs ?? '',
+            fragDuration: options.fragDuration ?? 1,
+            hardware: options.hardware ?? { deviceType: AV_HWDEVICE_TYPE_NONE },
+        };
+        // Parse supported codecs
+        this.supportedCodecs = new Set(this.options.supportedCodecs
+            .split(',')
+            .map((c) => c.trim())
+            .filter(Boolean));
+    }
+    /**
+     * Create a fMP4 stream from a media source.
+     *
+     * Opens the input media, detects video and audio codecs, and prepares
+     * transcoding pipelines based on client-supported codecs.
+     * Automatically transcodes to H.264 and AAC if necessary.
+     *
+     * @param inputUrl - Media source URL (RTSP, file path, HTTP, etc.)
+     *
+     * @param options - Stream configuration options with supported codecs
+     *
+     * @returns Configured fMP4 stream instance
+     *
+     * @throws {Error} If no video stream found in input
+     *
+     * @throws {FFmpegError} If input cannot be opened
+     *
+     * @example
+     * ```typescript
+     * // Stream from file with codec negotiation
+     * const stream = await FMP4Stream.create('video.mp4', {
+     *   supportedCodecs: 'avc1.640029,mp4a.40.2',
+     *   onChunk: (chunk) => ws.send(chunk)
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Stream from RTSP with auto hardware acceleration
+     * const stream = await FMP4Stream.create('rtsp://camera.local/stream', {
+     *   supportedCodecs: 'avc1.640029,hvc1.1.6.L153.B0,mp4a.40.2',
+     *   hardware: 'auto',
+     *   fragDuration: 0.5
+     * });
+     * ```
+     */
+    static async create(inputUrl, options = {}) {
+        const isRtsp = inputUrl.toLowerCase().startsWith('rtsp://');
+        const input = await MediaInput.open(inputUrl, {
+            options: isRtsp ? { rtsp_transport: 'tcp' } : undefined,
+        });
+        const videoStream = input.video();
+        if (!videoStream) {
+            throw new Error('No video stream found in input');
+        }
+        return new FMP4Stream(input, options);
+    }
+    /**
+     * Get the codec string that will be used by client.
+     *
+     * Returns the MIME type codec string based on input codecs and transcoding decisions.
+     * Call this after creating the stream to know what codec string to use for addSourceBuffer().
+     *
+     * @returns MIME type codec string (e.g., "avc1.640029,mp4a.40.2")
+     *
+     * @example
+     * ```typescript
+     * const stream = await FMP4Stream.create('input.mp4', {
+     *   supportedCodecs: 'avc1.640029,mp4a.40.2'
+     * });
+     *
+     * const codecString = stream.getCodecString();
+     * console.log(codecString); // "avc1.640029,mp4a.40.2"
+     * // Use this for: sourceBuffer = mediaSource.addSourceBuffer(`video/mp4; codecs="${codecString}"`);
+     * ```
+     */
+    getCodecString() {
+        const videoStream = this.input.video();
+        const audioStream = this.input.audio();
+        const videoCodecId = videoStream.codecpar.codecId;
+        const audioCodecId = audioStream?.codecpar.codecId;
+        // Determine video codec string
+        let videoCodec;
+        const needsVideoTranscode = !this.isVideoCodecSupported(videoCodecId);
+        if (needsVideoTranscode) {
+            // Transcoding to H.264
+            videoCodec = FMP4_CODECS.H264;
+        }
+        else if (videoCodecId === AV_CODEC_ID_H264) {
+            // H.264 - use HLS codec string from input
+            const hlsCodec = avGetCodecStringHls(videoStream.codecpar);
+            videoCodec = hlsCodec ?? FMP4_CODECS.H264;
+        }
+        else if (videoCodecId === AV_CODEC_ID_HEVC) {
+            // H.265 - use HLS codec string from input
+            const hlsCodec = avGetCodecStringHls(videoStream.codecpar);
+            videoCodec = hlsCodec ?? FMP4_CODECS.H265;
+        }
+        else if (videoCodecId === AV_CODEC_ID_AV1) {
+            // AV1 - use HLS codec string from input
+            const hlsCodec = avGetCodecStringHls(videoStream.codecpar);
+            videoCodec = hlsCodec ?? FMP4_CODECS.AV1;
+        }
+        else {
+            // Fallback to H.264 (should not happen as we transcode unsupported codecs)
+            videoCodec = FMP4_CODECS.H264;
+        }
+        // Determine audio codec string
+        let audioCodec = null;
+        if (audioCodecId) {
+            const needsAudioTranscode = !this.isAudioCodecSupported(audioCodecId);
+            if (needsAudioTranscode) {
+                // Transcoding to AAC
+                audioCodec = FMP4_CODECS.AAC;
+            }
+            else if (audioCodecId === AV_CODEC_ID_AAC) {
+                // AAC - use fixed codec string
+                audioCodec = FMP4_CODECS.AAC;
+            }
+            else if (audioCodecId === AV_CODEC_ID_FLAC) {
+                // FLAC
+                audioCodec = FMP4_CODECS.FLAC;
+            }
+            else if (audioCodecId === AV_CODEC_ID_OPUS) {
+                // Opus
+                audioCodec = FMP4_CODECS.OPUS;
+            }
+            else {
+                // Fallback to AAC (should not happen as we transcode unsupported codecs)
+                audioCodec = FMP4_CODECS.AAC;
+            }
+        }
+        // Combine video and audio codec strings
+        return audioCodec ? `${videoCodec},${audioCodec}` : videoCodec;
+    }
+    /**
+     * Get the resolution of the input video stream.
+     *
+     * @returns Object with width and height properties
+     *
+     * @example
+     * ```typescript
+     * const stream = await FMP4Stream.create('input.mp4', {
+     *   supportedCodecs: 'avc1.640029,mp4a.40.2'
+     * });
+     *
+     * const resolution = stream.getResolution();
+     * console.log(`Width: ${resolution.width}, Height: ${resolution.height}`);
+     * ```
+     */
+    getResolution() {
+        const videoStream = this.input.video();
+        return {
+            width: videoStream.codecpar.width,
+            height: videoStream.codecpar.height,
+        };
+    }
+    /**
+     * Start streaming media to fMP4 chunks.
+     *
+     * Begins the media processing pipeline, reading packets from input,
+     * transcoding based on supported codecs, and generating fMP4 chunks.
+     * Video transcodes to H.264 if H.264/H.265 not supported.
+     * Audio transcodes to AAC if AAC/FLAC/Opus not supported.
+     * This method blocks until streaming completes or {@link stop} is called.
+     *
+     * @returns Promise that resolves when streaming completes
+     *
+     * @throws {FFmpegError} If transcoding or muxing fails
+     *
+     * @example
+     * ```typescript
+     * const stream = await FMP4Stream.create('input.mp4', {
+     *   supportedCodecs: 'avc1.640029,mp4a.40.2',
+     *   onChunk: (chunk) => sendToClient(chunk)
+     * });
+     *
+     * // Start streaming (blocks until complete)
+     * await stream.start();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Non-blocking start with background promise
+     * const stream = await FMP4Stream.create('input.mp4', {
+     *   supportedCodecs: 'avc1.640029,mp4a.40.2'
+     * });
+     * const streamPromise = stream.start();
+     *
+     * // Later: stop streaming
+     * stream.stop();
+     * await streamPromise;
+     * ```
+     */
+    async start() {
+        if (this.streamActive) {
+            return;
+        }
+        this.streamActive = true;
+        const videoStream = this.input.video();
+        const audioStream = this.input.audio();
+        // Check if we need hardware acceleration
+        if (this.options.hardware === 'auto') {
+            this.hardwareContext = HardwareContext.auto();
+        }
+        else if (this.options.hardware.deviceType !== AV_HWDEVICE_TYPE_NONE) {
+            this.hardwareContext = HardwareContext.create(this.options.hardware.deviceType, this.options.hardware.device, this.options.hardware.options);
+        }
+        // Check if video needs transcoding
+        const needsVideoTranscode = !this.isVideoCodecSupported(videoStream.codecpar.codecId);
+        if (needsVideoTranscode) {
+            // Transcode to H.264
+            this.videoDecoder = await Decoder.create(videoStream, {
+                hardware: this.hardwareContext ?? undefined,
+                exitOnError: false,
+            });
+            this.videoEncoder = await Encoder.create(FF_ENCODER_LIBX264, {
+                timeBase: videoStream.timeBase,
+                frameRate: videoStream.avgFrameRate,
+            });
+        }
+        // Check if audio needs transcoding
+        const needsAudioTranscode = audioStream && !this.isAudioCodecSupported(audioStream.codecpar.codecId);
+        if (needsAudioTranscode) {
+            // Transcode to AAC
+            this.audioDecoder = await Decoder.create(audioStream, {
+                exitOnError: false,
+            });
+            const targetSampleRate = 48000;
+            const filterChain = FilterPreset.chain().aformat(AV_SAMPLE_FMT_FLTP, targetSampleRate, 'stereo').asetnsamples(1024).build();
+            this.audioFilter = FilterAPI.create(filterChain, {
+                timeBase: audioStream.timeBase,
+            });
+            this.audioEncoder = await Encoder.create(FF_ENCODER_AAC, {
+                timeBase: { num: 1, den: targetSampleRate },
+            });
+        }
+        // Setup output with callback
+        const cb = {
+            write: (buffer) => {
+                this.options.onChunk(buffer);
+                return buffer.length;
+            },
+        };
+        this.output = await MediaOutput.open(cb, {
+            format: 'mp4',
+            options: {
+                movflags: '+frag_keyframe+separate_moof+default_base_moof+empty_moov',
+                frag_duration: this.options.fragDuration,
+            },
+        });
+        // Add streams to output
+        const videoStreamIndex = this.videoEncoder ? this.output.addStream(this.videoEncoder) : this.output.addStream(videoStream);
+        const audioStreamIndex = this.audioEncoder ? this.output.addStream(this.audioEncoder) : audioStream ? this.output.addStream(audioStream) : null;
+        const hasAudio = audioStreamIndex !== null && audioStream !== undefined;
+        // Start processing loop
+        for await (const packet_1 of this.input.packets()) {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const packet = __addDisposableResource(env_1, packet_1, false);
+                if (!this.streamActive) {
+                    break;
+                }
+                if (packet.streamIndex === videoStream.index) {
+                    if (this.videoDecoder && this.videoEncoder) {
+                        const env_2 = { stack: [], error: void 0, hasError: false };
+                        try {
+                            // Transcode video
+                            const decodedFrame = __addDisposableResource(env_2, await this.videoDecoder.decode(packet), false);
+                            if (!decodedFrame) {
+                                continue;
+                            }
+                            const encodedPacket = __addDisposableResource(env_2, await this.videoEncoder.encode(decodedFrame), false);
+                            if (!encodedPacket) {
+                                continue;
+                            }
+                            await this.output.writePacket(encodedPacket, videoStreamIndex);
+                        }
+                        catch (e_1) {
+                            env_2.error = e_1;
+                            env_2.hasError = true;
+                        }
+                        finally {
+                            __disposeResources(env_2);
+                        }
+                    }
+                    else {
+                        // Stream copy video
+                        await this.output.writePacket(packet, videoStreamIndex);
+                    }
+                }
+                else if (hasAudio && packet.streamIndex === audioStream.index) {
+                    if (this.audioDecoder && this.audioFilter && this.audioEncoder) {
+                        const env_3 = { stack: [], error: void 0, hasError: false };
+                        try {
+                            // Transcode audio
+                            const decodedFrame = __addDisposableResource(env_3, await this.audioDecoder.decode(packet), false);
+                            if (!decodedFrame) {
+                                continue;
+                            }
+                            const filteredFrame = __addDisposableResource(env_3, await this.audioFilter.process(decodedFrame), false);
+                            if (!filteredFrame) {
+                                continue;
+                            }
+                            const encodedPacket = __addDisposableResource(env_3, await this.audioEncoder.encode(filteredFrame), false);
+                            if (!encodedPacket) {
+                                continue;
+                            }
+                            await this.output.writePacket(encodedPacket, audioStreamIndex);
+                        }
+                        catch (e_2) {
+                            env_3.error = e_2;
+                            env_3.hasError = true;
+                        }
+                        finally {
+                            __disposeResources(env_3);
+                        }
+                    }
+                    else {
+                        // Stream copy audio
+                        await this.output.writePacket(packet, audioStreamIndex);
+                    }
+                }
+            }
+            catch (e_3) {
+                env_1.error = e_3;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        }
+        // Flush pipelines
+        await Promise.allSettled([this.flushVideo(videoStreamIndex), this.flushAudio(audioStreamIndex)]);
+        // Close output - remaining data will be written via callback
+        await this.output.close();
+    }
+    /**
+     * Stop streaming gracefully.
+     *
+     * Signals the streaming loop to exit after the current packet is processed.
+     * Does not immediately close resources - use {@link dispose} for cleanup.
+     * Safe to call multiple times.
+     *
+     * @example
+     * ```typescript
+     * const stream = await FMP4Stream.create('input.mp4', {
+     *   supportedCodecs: 'avc1.640029,mp4a.40.2'
+     * });
+     * const streamPromise = stream.start();
+     *
+     * // Stop after 10 seconds
+     * setTimeout(() => stream.stop(), 10000);
+     *
+     * await streamPromise; // Resolves when stopped
+     * stream.dispose();
+     * ```
+     */
+    stop() {
+        this.streamActive = false;
+    }
+    /**
+     * Clean up all resources and close the stream.
+     *
+     * Stops streaming if active and releases all FFmpeg resources including
+     * decoders, encoders, filters, output, and input. Should be called when
+     * done with the stream to prevent memory leaks.
+     * Safe to call multiple times.
+     *
+     * @example
+     * ```typescript
+     * const stream = await FMP4Stream.create('input.mp4', {
+     *   supportedCodecs: 'avc1.640029,mp4a.40.2'
+     * });
+     * await stream.start();
+     * stream.dispose();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Using automatic cleanup
+     * {
+     *   await using stream = await FMP4Stream.create('input.mp4', {
+     *     supportedCodecs: 'avc1.640029,mp4a.40.2'
+     *   });
+     *   await stream.start();
+     * } // Automatically disposed
+     * ```
+     */
+    dispose() {
+        this.stop();
+        this.output?.close();
+        this.videoDecoder?.close();
+        this.videoEncoder?.close();
+        this.audioDecoder?.close();
+        this.audioFilter?.close();
+        this.audioEncoder?.close();
+        this.hardwareContext?.dispose();
+        this.hardwareContext = null;
+        this.input.close();
+    }
+    /**
+     * Check if video codec is supported.
+     *
+     * @param codecId - Codec ID
+     *
+     * @returns True if H.264, H.265, or AV1 is in supported codecs
+     *
+     * @internal
+     */
+    isVideoCodecSupported(codecId) {
+        if (codecId === AV_CODEC_ID_H264 && (this.supportedCodecs.has(FMP4_CODECS.H264) || this.supportedCodecs.has('avc1'))) {
+            return true;
+        }
+        if (codecId === AV_CODEC_ID_HEVC && (this.supportedCodecs.has(FMP4_CODECS.H265) || this.supportedCodecs.has('hvc1') || this.supportedCodecs.has('hev1'))) {
+            return true;
+        }
+        if (codecId === AV_CODEC_ID_AV1 && (this.supportedCodecs.has(FMP4_CODECS.AV1) || this.supportedCodecs.has('av01'))) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if audio codec is supported.
+     *
+     * @param codecId - Codec ID
+     *
+     * @returns True if AAC, FLAC, or Opus is in supported codecs
+     *
+     * @internal
+     */
+    isAudioCodecSupported(codecId) {
+        if (codecId === AV_CODEC_ID_AAC && (this.supportedCodecs.has(FMP4_CODECS.AAC) || this.supportedCodecs.has('mp4a'))) {
+            return true;
+        }
+        if (codecId === AV_CODEC_ID_FLAC && this.supportedCodecs.has(FMP4_CODECS.FLAC)) {
+            return true;
+        }
+        if (codecId === AV_CODEC_ID_OPUS && this.supportedCodecs.has(FMP4_CODECS.OPUS)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Flush video encoder pipeline.
+     *
+     * @param videoStreamIndex - Output video stream index
+     *
+     * @internal
+     */
+    async flushVideo(videoStreamIndex) {
+        if (!this.videoDecoder || !this.videoEncoder || !this.output) {
+            return;
+        }
+        for await (const frame_1 of this.videoDecoder.flushFrames()) {
+            const env_4 = { stack: [], error: void 0, hasError: false };
+            try {
+                const frame = __addDisposableResource(env_4, frame_1, false);
+                const encodedPacket = __addDisposableResource(env_4, await this.videoEncoder.encode(frame), false);
+                if (encodedPacket) {
+                    await this.output.writePacket(encodedPacket, videoStreamIndex);
+                }
+            }
+            catch (e_4) {
+                env_4.error = e_4;
+                env_4.hasError = true;
+            }
+            finally {
+                __disposeResources(env_4);
+            }
+        }
+        for await (const packet_2 of this.videoEncoder.flushPackets()) {
+            const env_5 = { stack: [], error: void 0, hasError: false };
+            try {
+                const packet = __addDisposableResource(env_5, packet_2, false);
+                await this.output.writePacket(packet, videoStreamIndex);
+            }
+            catch (e_5) {
+                env_5.error = e_5;
+                env_5.hasError = true;
+            }
+            finally {
+                __disposeResources(env_5);
+            }
+        }
+    }
+    /**
+     * Flush audio encoder pipeline.
+     *
+     * @param audioStreamIndex - Output audio stream index
+     *
+     * @internal
+     */
+    async flushAudio(audioStreamIndex) {
+        if (!this.audioDecoder || !this.audioFilter || !this.audioEncoder || audioStreamIndex === null || !this.output) {
+            return;
+        }
+        for await (const frame_2 of this.audioDecoder.flushFrames()) {
+            const env_6 = { stack: [], error: void 0, hasError: false };
+            try {
+                const frame = __addDisposableResource(env_6, frame_2, false);
+                const filteredFrame = __addDisposableResource(env_6, await this.audioFilter.process(frame), false);
+                if (!filteredFrame) {
+                    continue;
+                }
+                const encodedPacket = __addDisposableResource(env_6, await this.audioEncoder.encode(filteredFrame), false);
+                if (encodedPacket) {
+                    await this.output.writePacket(encodedPacket, audioStreamIndex);
+                }
+            }
+            catch (e_6) {
+                env_6.error = e_6;
+                env_6.hasError = true;
+            }
+            finally {
+                __disposeResources(env_6);
+            }
+        }
+        for await (const frame_3 of this.audioFilter.flushFrames()) {
+            const env_7 = { stack: [], error: void 0, hasError: false };
+            try {
+                const frame = __addDisposableResource(env_7, frame_3, false);
+                const encodedPacket = __addDisposableResource(env_7, await this.audioEncoder.encode(frame), false);
+                if (encodedPacket) {
+                    await this.output.writePacket(encodedPacket, audioStreamIndex);
+                }
+            }
+            catch (e_7) {
+                env_7.error = e_7;
+                env_7.hasError = true;
+            }
+            finally {
+                __disposeResources(env_7);
+            }
+        }
+        for await (const packet_3 of this.audioEncoder.flushPackets()) {
+            const env_8 = { stack: [], error: void 0, hasError: false };
+            try {
+                const packet = __addDisposableResource(env_8, packet_3, false);
+                await this.output.writePacket(packet, audioStreamIndex);
+            }
+            catch (e_8) {
+                env_8.error = e_8;
+                env_8.hasError = true;
+            }
+            finally {
+                __disposeResources(env_8);
+            }
+        }
+    }
+    /**
+     * Symbol.dispose implementation for automatic cleanup.
+     *
+     * @internal
+     */
+    [Symbol.dispose]() {
+        this.dispose();
+    }
+}
+//# sourceMappingURL=fmp4.js.map