node-av 3.0.6 → 3.1.1

package/dist/api/webrtc.js

@@ -0,0 +1,1118 @@
+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 { MediaStreamTrack, RTCIceCandidate, RTCPeerConnection, RTCRtpCodecParameters, RTCSessionDescription, RtpPacket } from 'werift';
+import { AV_CODEC_ID_AV1, AV_CODEC_ID_H264, AV_CODEC_ID_HEVC, AV_CODEC_ID_OPUS, AV_CODEC_ID_PCM_ALAW, AV_CODEC_ID_PCM_MULAW, AV_CODEC_ID_VP8, AV_CODEC_ID_VP9, AV_HWDEVICE_TYPE_NONE, AV_SAMPLE_FMT_S16, } from '../constants/constants.js';
+import { FF_ENCODER_LIBOPUS, FF_ENCODER_LIBX264 } from '../constants/encoders.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';
+/**
+ * High-level WebRTC streaming with automatic codec detection and transcoding.
+ *
+ * Provides library-agnostic RTP streaming for WebRTC applications.
+ * Automatically detects input codecs and transcodes non-WebRTC-compatible formats.
+ * Handles video (H.264, H.265, VP8, VP9) and audio (Opus, PCMA, PCMU) codecs.
+ * Supports hardware acceleration for video transcoding.
+ * Essential component for building WebRTC streaming servers without direct WebRTC library coupling.
+ *
+ * @example
+ * ```typescript
+ * import { WebRTCStream } from 'node-av/api';
+ *
+ * // Create stream with RTP packet callbacks
+ * const stream = await WebRTCStream.create('rtsp://camera.local/stream', {
+ *   mtu: 1200,
+ *   hardware: 'auto',
+ *   onVideoPacket: (rtp) => {
+ *     // Send RTP packet to WebRTC peer connection
+ *     videoTrack.writeRtp(rtp);
+ *   },
+ *   onAudioPacket: (rtp) => {
+ *     audioTrack.writeRtp(rtp);
+ *   }
+ * });
+ *
+ * // Get detected codecs for SDP negotiation
+ * const codecs = stream.getCodecs();
+ * console.log('Video:', codecs.video.mimeType);
+ * console.log('Audio:', codecs.audio?.mimeType);
+ *
+ * // Start streaming
+ * await stream.start();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Stream with hardware acceleration
+ * import { AV_HWDEVICE_TYPE_CUDA } from 'node-av/constants';
+ *
+ * const stream = await WebRTCStream.create('video.mp4', {
+ *   hardware: {
+ *     deviceType: AV_HWDEVICE_TYPE_CUDA,
+ *     device: '/dev/nvidia0'
+ *   },
+ *   onVideoPacket: (rtp) => sendToWebRTC(rtp)
+ * });
+ *
+ * await stream.start();
+ * stream.stop();
+ * stream.dispose();
+ * ```
+ *
+ * @see {@link WebRTCSession} For complete WebRTC session management with werift
+ * @see {@link MediaInput} For input media handling
+ * @see {@link HardwareContext} For GPU acceleration
+ */
+export class WebRTCStream {
+    input;
+    codecInfo;
+    options;
+    videoOutput = null;
+    audioOutput = null;
+    hardwareContext = null;
+    videoDecoder = null;
+    videoEncoder = null;
+    audioDecoder = null;
+    audioFilter = null;
+    audioEncoder = null;
+    streamActive = false;
+    /**
+     * @param input - Media input source
+     *
+     * @param options - Stream configuration options
+     *
+     * Use {@link create} factory method
+     *
+     * @internal
+     */
+    constructor(input, options) {
+        this.input = input;
+        const videoStream = input.video();
+        const audioStream = input.audio();
+        const videoCodecId = videoStream.codecpar.codecId;
+        const audioCodecId = audioStream?.codecpar.codecId ?? null;
+        const videoConfig = this.getVideoCodecConfig(videoCodecId) ?? this.getVideoCodecConfig(AV_CODEC_ID_H264); // We transcode unsupported codecs to H264
+        this.codecInfo = {
+            video: {
+                codecId: videoCodecId,
+                ...videoConfig,
+            },
+        };
+        if (audioCodecId !== null) {
+            const audioConfig = this.getAudioCodecConfig(audioCodecId) ?? this.getAudioCodecConfig(AV_CODEC_ID_OPUS); // We transcode unsupported codecs to OPUS
+            this.codecInfo.audio = {
+                codecId: audioCodecId,
+                ...audioConfig,
+            };
+        }
+        this.options = {
+            onVideoPacket: options.onVideoPacket ?? (() => { }),
+            onAudioPacket: options.onAudioPacket ?? (() => { }),
+            mtu: options.mtu ?? 1200,
+            hardware: options.hardware ?? { deviceType: AV_HWDEVICE_TYPE_NONE },
+            inputOptions: options.inputOptions,
+        };
+    }
+    /**
+     * Create a WebRTC stream from a media source.
+     *
+     * Opens the input media, detects video and audio codecs, and prepares
+     * transcoding pipelines for non-WebRTC-compatible formats.
+     * Automatically configures H.264 encoding for unsupported video codecs
+     * and Opus encoding for unsupported audio codecs.
+     *
+     * @param inputUrl - Media source URL (RTSP, file path, HTTP, etc.)
+     *
+     * @param options - Stream configuration options
+     *
+     * @returns Configured WebRTC stream instance
+     *
+     * @throws {Error} If no video stream found in input
+     *
+     * @throws {FFmpegError} If input cannot be opened
+     *
+     * @example
+     * ```typescript
+     * // Stream from RTSP camera
+     * const stream = await WebRTCStream.create('rtsp://camera.local/stream', {
+     *   mtu: 1200,
+     *   onVideoPacket: (rtp) => videoTrack.writeRtp(rtp),
+     *   onAudioPacket: (rtp) => audioTrack.writeRtp(rtp)
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Stream file with auto hardware acceleration
+     * const stream = await WebRTCStream.create('video.mp4', {
+     *   hardware: 'auto'
+     * });
+     * ```
+     */
+    static async create(inputUrl, options = {}) {
+        const isRtsp = inputUrl.toLowerCase().startsWith('rtsp');
+        options.inputOptions = options.inputOptions ?? {};
+        options.inputOptions = {
+            flags: 'low_delay',
+            rtsp_transport: isRtsp ? 'tcp' : undefined,
+            ...options.inputOptions,
+        };
+        const input = await MediaInput.open(inputUrl, {
+            options: options.inputOptions,
+        });
+        const videoStream = input.video();
+        if (!videoStream) {
+            throw new Error('No video stream found in input');
+        }
+        return new WebRTCStream(input, options);
+    }
+    /**
+     * Get detected codec information for SDP negotiation.
+     *
+     * Returns RTP codec parameters and FFmpeg codec IDs for video and audio.
+     * Use this information to configure WebRTC peer connections with matching codecs.
+     *
+     * @returns Codec configuration for video and audio streams
+     *
+     * @example
+     * ```typescript
+     * const stream = await WebRTCStream.create('input.mp4');
+     * const codecs = stream.getCodecs();
+     *
+     * console.log('Video codec:', codecs.video.mimeType);
+     * console.log('Audio codec:', codecs.audio?.mimeType);
+     * ```
+     */
+    getCodecs() {
+        return this.codecInfo;
+    }
+    /**
+     * Start streaming media to RTP packets.
+     *
+     * Begins the media processing pipeline, reading packets from input,
+     * transcoding if necessary, and invoking RTP packet callbacks.
+     * Automatically handles video and audio streams in parallel.
+     * Flushes all buffers at the end of stream.
+     * 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 WebRTCStream.create('rtsp://camera.local/stream', {
+     *   onVideoPacket: (rtp) => sendRtp(rtp)
+     * });
+     *
+     * // Start streaming (blocks until complete or stopped)
+     * await stream.start();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Non-blocking start with background promise
+     * const stream = await WebRTCStream.create('input.mp4');
+     * 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();
+        // Setup video transcoding if needed
+        if (!this.isVideoCodecSupported(videoStream.codecpar.codecId)) {
+            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);
+            }
+            this.videoDecoder = await Decoder.create(videoStream, {
+                exitOnError: false,
+                hardware: this.hardwareContext,
+            });
+            const encoderCodec = this.hardwareContext?.getEncoderCodec('h264') ?? FF_ENCODER_LIBX264;
+            const encoderOptions = {};
+            if (encoderCodec === FF_ENCODER_LIBX264) {
+                encoderOptions.preset = 'ultrafast';
+                encoderOptions.tune = 'zerolatency';
+            }
+            this.videoEncoder = await Encoder.create(encoderCodec, {
+                timeBase: videoStream.timeBase,
+                frameRate: videoStream.avgFrameRate,
+                maxBFrames: 0,
+                options: encoderOptions,
+            });
+        }
+        // Setup video output
+        this.videoOutput = await MediaOutput.open({
+            write: (buffer) => {
+                this.options.onVideoPacket(RtpPacket.deSerialize(buffer));
+                return buffer.length;
+            },
+        }, {
+            format: 'rtp',
+            bufferSize: this.options.mtu,
+            options: {
+                pkt_size: this.options.mtu,
+            },
+        });
+        const videoStreamIndex = this.videoEncoder ? this.videoOutput.addStream(this.videoEncoder) : this.videoOutput.addStream(videoStream);
+        // Setup audio if available
+        let audioStreamIndex = null;
+        if (audioStream) {
+            if (!this.isAudioCodecSupported(audioStream.codecpar.codecId)) {
+                this.audioDecoder = await Decoder.create(audioStream, {
+                    exitOnError: false,
+                });
+                const targetSampleRate = 48000;
+                const filterChain = FilterPreset.chain().aformat(AV_SAMPLE_FMT_S16, targetSampleRate, 'stereo').asetnsamples(960).build();
+                this.audioFilter = FilterAPI.create(filterChain, {
+                    timeBase: audioStream.timeBase,
+                });
+                this.audioEncoder = await Encoder.create(FF_ENCODER_LIBOPUS, {
+                    timeBase: { num: 1, den: targetSampleRate },
+                    options: {
+                        application: 'lowdelay',
+                        frame_duration: 20,
+                    },
+                });
+            }
+            this.audioOutput = await MediaOutput.open({
+                write: (buffer) => {
+                    this.options.onAudioPacket(RtpPacket.deSerialize(buffer));
+                    return buffer.length;
+                },
+            }, {
+                format: 'rtp',
+                bufferSize: this.options.mtu,
+                options: {
+                    pkt_size: this.options.mtu,
+                },
+            });
+            audioStreamIndex = this.audioEncoder ? this.audioOutput.addStream(this.audioEncoder) : this.audioOutput.addStream(audioStream);
+        }
+        const hasAudio = audioStreamIndex !== null && this.audioOutput !== 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 === null || this.videoEncoder === null) {
+                        await this.videoOutput.writePacket(packet, videoStreamIndex);
+                    }
+                    else {
+                        const env_2 = { stack: [], error: void 0, hasError: false };
+                        try {
+                            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.videoOutput.writePacket(encodedPacket, videoStreamIndex);
+                        }
+                        catch (e_1) {
+                            env_2.error = e_1;
+                            env_2.hasError = true;
+                        }
+                        finally {
+                            __disposeResources(env_2);
+                        }
+                    }
+                }
+                else if (hasAudio && packet.streamIndex === audioStream.index) {
+                    if (this.audioDecoder === null || this.audioFilter === null || this.audioEncoder === null) {
+                        await this.audioOutput?.writePacket(packet, audioStreamIndex);
+                        continue;
+                    }
+                    else {
+                        const env_3 = { stack: [], error: void 0, hasError: false };
+                        try {
+                            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.audioOutput?.writePacket(encodedPacket, audioStreamIndex);
+                        }
+                        catch (e_2) {
+                            env_3.error = e_2;
+                            env_3.hasError = true;
+                        }
+                        finally {
+                            __disposeResources(env_3);
+                        }
+                    }
+                }
+            }
+            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, hasAudio)]);
+    }
+    /**
+     * 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 WebRTCStream.create('input.mp4');
+     * 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, outputs, and input. Should be called when
+     * done with the stream to prevent memory leaks.
+     * Safe to call multiple times.
+     *
+     * @example
+     * ```typescript
+     * const stream = await WebRTCStream.create('input.mp4');
+     * await stream.start();
+     * stream.dispose();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Using automatic cleanup
+     * {
+     *   await using stream = await WebRTCStream.create('input.mp4');
+     *   await stream.start();
+     * } // Automatically disposed
+     * ```
+     */
+    dispose() {
+        if (!this.streamActive) {
+            return;
+        }
+        this.stop();
+        this.videoOutput?.close();
+        this.audioOutput?.close();
+        this.videoDecoder?.close();
+        this.videoEncoder?.close();
+        this.audioDecoder?.close();
+        this.audioFilter?.close();
+        this.audioEncoder?.close();
+        this.input.close();
+    }
+    /**
+     * Check if the given audio codec is compatible with WebRTC.
+     *
+     * @param codecId - The AVCodecID to check
+     *
+     * @returns True if the codec is WebRTC compatible, false otherwise
+     *
+     * @internal
+     */
+    isAudioCodecSupported(codecId) {
+        switch (codecId) {
+            case AV_CODEC_ID_PCM_ALAW:
+            case AV_CODEC_ID_PCM_MULAW:
+            case AV_CODEC_ID_OPUS:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Check if the given video codec is compatible with WebRTC.
+     *
+     * @param codecId - The AVCodecID to check
+     *
+     * @returns True if the codec is WebRTC compatible, false otherwise
+     *
+     * @internal
+     */
+    isVideoCodecSupported(codecId) {
+        switch (codecId) {
+            case AV_CODEC_ID_H264:
+            case AV_CODEC_ID_HEVC:
+            case AV_CODEC_ID_VP8:
+            case AV_CODEC_ID_VP9:
+            case AV_CODEC_ID_AV1:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Get the audio codec configuration for WebRTC.
+     *
+     * @param codecId - The AVCodecID of the audio codec
+     *
+     * @returns An object containing MIME type, clock rate, and channels, or null if unsupported
+     *
+     * @internal
+     */
+    getAudioCodecConfig(codecId) {
+        switch (codecId) {
+            case AV_CODEC_ID_OPUS:
+                return {
+                    mimeType: 'audio/opus',
+                    clockRate: 48000,
+                    channels: 2,
+                    payloadType: 111,
+                };
+            case AV_CODEC_ID_PCM_MULAW:
+                return {
+                    mimeType: 'audio/PCMU',
+                    clockRate: 8000,
+                    channels: 1,
+                    payloadType: 0,
+                };
+            case AV_CODEC_ID_PCM_ALAW:
+                return {
+                    mimeType: 'audio/PCMA',
+                    clockRate: 8000,
+                    channels: 1,
+                    payloadType: 8,
+                };
+            default:
+                return null;
+        }
+    }
+    /**
+     * Get the video codec configuration for WebRTC.
+     *
+     * @param codecId - The AVCodecID of the video codec
+     *
+     * @returns An object containing MIME type and clock rate, or null if unsupported
+     *
+     * @internal
+     */
+    getVideoCodecConfig(codecId) {
+        switch (codecId) {
+            case AV_CODEC_ID_H264:
+                return {
+                    mimeType: 'video/H264',
+                    clockRate: 90000,
+                    payloadType: 102,
+                };
+            case AV_CODEC_ID_HEVC:
+                return {
+                    mimeType: 'video/H265',
+                    clockRate: 90000,
+                    payloadType: 103,
+                };
+            case AV_CODEC_ID_VP8:
+                return {
+                    mimeType: 'video/VP8',
+                    clockRate: 90000,
+                    payloadType: 96,
+                };
+            case AV_CODEC_ID_VP9:
+                return {
+                    mimeType: 'video/VP9',
+                    clockRate: 90000,
+                    payloadType: 98,
+                };
+            case AV_CODEC_ID_AV1:
+                return {
+                    mimeType: 'video/AV1',
+                    clockRate: 90000,
+                    payloadType: 35,
+                };
+            default:
+                return null;
+        }
+    }
+    /**
+     * Flush video encoder pipeline.
+     *
+     * @param videoStreamIndex - Output video stream index
+     *
+     * @internal
+     */
+    async flushVideo(videoStreamIndex) {
+        if (!this.videoDecoder || !this.videoEncoder || !this.videoOutput) {
+            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.videoOutput.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.videoOutput.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
+     *
+     * @param hasAudio - Whether audio stream exists
+     *
+     * @internal
+     */
+    async flushAudio(audioStreamIndex, hasAudio) {
+        if (!this.audioDecoder || !this.audioFilter || !this.audioEncoder || !hasAudio || !this.audioOutput) {
+            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.audioOutput.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.audioOutput.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.audioOutput.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();
+    }
+}
+/**
+ * Complete WebRTC session management with werift integration.
+ *
+ * Provides end-to-end WebRTC streaming with automatic SDP negotiation,
+ * ICE candidate handling, and peer connection management.
+ * Built on top of {@link WebRTCStream} but handles all WebRTC protocol details.
+ * Integrates with werift library for RTCPeerConnection and media track handling.
+ * Ideal for building complete WebRTC streaming applications with minimal code.
+ *
+ * @example
+ * ```typescript
+ * import { WebRTCSession } from 'node-av/api';
+ *
+ * // Create session from media source
+ * const session = await WebRTCSession.create('rtsp://camera.local/stream', {
+ *   mtu: 1200,
+ *   hardware: 'auto',
+ *   iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
+ * });
+ *
+ * // Setup ICE candidate handler
+ * session.onIceCandidate = (candidate) => {
+ *   sendToClient({ type: 'candidate', value: candidate });
+ * };
+ *
+ * // Process SDP offer from client
+ * const answer = await session.setOffer(clientOffer);
+ * sendToClient({ type: 'answer', value: answer });
+ *
+ * // Start streaming
+ * await session.start();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Complete WebSocket signaling server
+ * import { WebSocket } from 'ws';
+ *
+ * ws.on('message', async (data) => {
+ *   const msg = JSON.parse(data);
+ *
+ *   if (msg.type === 'offer') {
+ *     const session = await WebRTCSession.create(msg.url, {
+ *       hardware: 'auto'
+ *     });
+ *
+ *     session.onIceCandidate = (candidate) => {
+ *       ws.send(JSON.stringify({ type: 'candidate', value: candidate }));
+ *     };
+ *
+ *     const answer = await session.setOffer(msg.value);
+ *     ws.send(JSON.stringify({ type: 'answer', value: answer }));
+ *
+ *     await session.start();
+ *   } else if (msg.type === 'candidate') {
+ *     session.addIceCandidate(msg.value);
+ *   }
+ * });
+ * ```
+ *
+ * @see {@link WebRTCStream} For library-agnostic RTP streaming
+ * @see {@link MediaInput} For input media handling
+ * @see {@link HardwareContext} For GPU acceleration
+ */
+export class WebRTCSession {
+    stream = null;
+    pc = null;
+    videoTrack = null;
+    audioTrack = null;
+    options;
+    /**
+     * Callback invoked when a new ICE candidate is discovered.
+     * Send this candidate to the remote peer via signaling channel.
+     *
+     * @param candidate - ICE candidate string to send to remote peer
+     *
+     * @example
+     * ```typescript
+     * session.onIceCandidate = (candidate) => {
+     *   ws.send(JSON.stringify({ type: 'candidate', value: candidate }));
+     * };
+     * ```
+     */
+    onIceCandidate = null;
+    /**
+     * @param options - Session configuration options
+     *
+     * Use {@link create} factory method
+     *
+     * @internal
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Create a WebRTC session from a media source.
+     *
+     * Opens the input media, creates internal streaming components, and prepares
+     * for WebRTC peer connection negotiation. Does not start streaming yet.
+     * Call {@link setOffer} to negotiate SDP and {@link start} to begin streaming.
+     *
+     * @param inputUrl - Media source URL (RTSP, file path, HTTP, etc.)
+     *
+     * @param options - Session configuration options
+     *
+     * @returns Configured WebRTC session instance
+     *
+     * @throws {Error} If no video stream found in input
+     *
+     * @throws {FFmpegError} If input cannot be opened
+     *
+     * @example
+     * ```typescript
+     * const session = await WebRTCSession.create('rtsp://camera.local/stream', {
+     *   mtu: 1200,
+     *   hardware: 'auto',
+     *   iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Session from file with hardware acceleration
+     * const session = await WebRTCSession.create('video.mp4', {
+     *   hardware: {
+     *     deviceType: AV_HWDEVICE_TYPE_CUDA
+     *   }
+     * });
+     * ```
+     */
+    static async create(inputUrl, options = {}) {
+        const session = new WebRTCSession(options);
+        // Create stream to detect codecs
+        session.stream = await WebRTCStream.create(inputUrl, {
+            mtu: options.mtu,
+            hardware: options.hardware,
+            onVideoPacket: (rtp) => {
+                session.videoTrack?.writeRtp(rtp);
+            },
+            onAudioPacket: (rtp) => {
+                session.audioTrack?.writeRtp(rtp);
+            },
+        });
+        return session;
+    }
+    /**
+     * Get detected codec information.
+     *
+     * Returns RTP codec parameters and FFmpeg codec IDs for video and audio.
+     * Useful for inspecting what codecs will be used in the WebRTC session.
+     *
+     * @returns Codec configuration for video and audio streams
+     *
+     * @throws {Error} If stream not initialized
+     *
+     * @example
+     * ```typescript
+     * const session = await WebRTCSession.create('input.mp4');
+     * const codecs = session.getCodecs();
+     *
+     * console.log('Video:', codecs.video.mimeType);
+     * console.log('Audio:', codecs.audio?.mimeType);
+     * ```
+     */
+    getCodecs() {
+        if (!this.stream) {
+            throw new Error('Stream not initialized');
+        }
+        return this.stream.getCodecs();
+    }
+    /**
+     * Process SDP offer from remote peer and generate SDP answer.
+     *
+     * Creates RTCPeerConnection with detected codecs, sets up media tracks,
+     * processes the remote SDP offer, and generates a local SDP answer.
+     * Also configures ICE candidate handling via {@link onIceCandidate} callback.
+     * Must be called before {@link start}.
+     *
+     * @param offerSdp - SDP offer string from remote WebRTC peer
+     *
+     * @returns SDP answer string to send back to remote peer
+     *
+     * @throws {Error} If stream not initialized
+     *
+     * @example
+     * ```typescript
+     * const session = await WebRTCSession.create('input.mp4');
+     *
+     * // Setup ICE candidate handler first
+     * session.onIceCandidate = (candidate) => {
+     *   sendToRemote({ type: 'candidate', value: candidate });
+     * };
+     *
+     * // Process offer and send answer
+     * const answer = await session.setOffer(remoteOffer);
+     * sendToRemote({ type: 'answer', value: answer });
+     * ```
+     */
+    async setOffer(offerSdp) {
+        if (!this.stream) {
+            throw new Error('Stream not initialized');
+        }
+        const codecs = this.stream.getCodecs();
+        const videoConfig = codecs.video;
+        delete videoConfig.codecId;
+        const audioConfig = codecs.audio ?? {
+            mimeType: 'audio/opus',
+            clockRate: 48000,
+            channels: 2,
+            payloadType: 111,
+        };
+        delete audioConfig.codecId;
+        // Create PeerConnection with detected codecs
+        const codecParams = {
+            video: [
+                new RTCRtpCodecParameters({
+                    ...videoConfig,
+                }),
+            ],
+            audio: [
+                new RTCRtpCodecParameters({
+                    ...audioConfig,
+                }),
+            ],
+        };
+        this.pc = new RTCPeerConnection({
+            codecs: codecParams,
+            iceServers: this.options.iceServers,
+        });
+        // Setup ICE candidate handling
+        this.pc.onIceCandidate.subscribe((candidate) => {
+            if (candidate?.candidate && this.onIceCandidate) {
+                this.onIceCandidate(candidate.candidate);
+            }
+        });
+        // Setup tracks
+        this.pc.onTransceiverAdded.subscribe((transceiver) => {
+            if (transceiver.kind === 'video') {
+                this.videoTrack = new MediaStreamTrack({ kind: 'video' });
+                transceiver.sender.replaceTrack(this.videoTrack);
+                transceiver.setDirection('sendonly');
+            }
+            else if (transceiver.kind === 'audio') {
+                this.audioTrack = new MediaStreamTrack({ kind: 'audio' });
+                transceiver.sender.replaceTrack(this.audioTrack);
+                transceiver.setDirection('sendonly');
+            }
+        });
+        // Set remote description and create answer
+        await this.pc.setRemoteDescription(new RTCSessionDescription(offerSdp, 'offer'));
+        const answer = await this.pc.createAnswer();
+        this.pc.setLocalDescription(answer);
+        return this.pc.localDescription?.sdp ?? '';
+    }
+    /**
+     * Add ICE candidate from remote peer.
+     *
+     * Processes ICE candidates received from the remote peer via signaling channel.
+     * Should be called whenever a new candidate message arrives from remote peer.
+     * Can be called multiple times as candidates are discovered.
+     *
+     * @param candidate - ICE candidate string from remote peer
+     *
+     * @throws {Error} If peer connection not initialized (call {@link setOffer} first)
+     *
+     * @example
+     * ```typescript
+     * // In signaling message handler
+     * if (msg.type === 'candidate') {
+     *   session.addIceCandidate(msg.value);
+     * }
+     * ```
+     */
+    addIceCandidate(candidate) {
+        if (!this.pc) {
+            throw new Error('PeerConnection not initialized');
+        }
+        this.pc.addIceCandidate(new RTCIceCandidate({ candidate }));
+    }
+    /**
+     * Start streaming media to WebRTC peer connection.
+     *
+     * Begins the media processing pipeline, reading packets from input,
+     * transcoding if necessary, and sending RTP packets to media tracks.
+     * Must call {@link setOffer} before starting.
+     * This method blocks until streaming completes or {@link stop} is called.
+     *
+     * @returns Promise that resolves when streaming completes
+     *
+     * @throws {Error} If stream not initialized
+     *
+     * @throws {FFmpegError} If transcoding or muxing fails
+     *
+     * @example
+     * ```typescript
+     * const session = await WebRTCSession.create('input.mp4');
+     * session.onIceCandidate = (c) => sendToRemote(c);
+     *
+     * const answer = await session.setOffer(remoteOffer);
+     * sendToRemote(answer);
+     *
+     * // Start streaming (blocks until complete)
+     * await session.start();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Non-blocking start
+     * const session = await WebRTCSession.create('input.mp4');
+     * const streamPromise = session.start();
+     *
+     * // Later: stop streaming
+     * session.stop();
+     * await streamPromise;
+     * ```
+     */
+    async start() {
+        if (!this.stream) {
+            throw new Error('Stream not initialized');
+        }
+        await this.stream.start();
+    }
+    /**
+     * 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 session = await WebRTCSession.create('input.mp4');
+     * const streamPromise = session.start();
+     *
+     * // Stop after 10 seconds
+     * setTimeout(() => session.stop(), 10000);
+     *
+     * await streamPromise;
+     * session.dispose();
+     * ```
+     */
+    stop() {
+        this.stream?.stop();
+    }
+    /**
+     * Clean up all resources and close the session.
+     *
+     * Stops streaming if active, releases all FFmpeg resources, closes peer connection,
+     * and cleans up media tracks. Should be called when done with the session to prevent
+     * memory leaks. Safe to call multiple times.
+     *
+     * @example
+     * ```typescript
+     * const session = await WebRTCSession.create('input.mp4');
+     * await session.start();
+     * session.dispose();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Using automatic cleanup
+     * {
+     *   await using session = await WebRTCSession.create('input.mp4');
+     *   await session.start();
+     * } // Automatically disposed
+     * ```
+     */
+    dispose() {
+        this.stop();
+        this.stream?.dispose();
+        this.pc?.close();
+        this.videoTrack = null;
+        this.audioTrack = null;
+        this.pc = null;
+    }
+    /**
+     * Symbol.dispose implementation for automatic cleanup.
+     *
+     * @internal
+     */
+    [Symbol.dispose]() {
+        this.dispose();
+    }
+}
+//# sourceMappingURL=webrtc.js.map